From 116eb055a14e9de5f13ef1f4cfe7c618b889a149 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sun, 2 Aug 2026 11:51:11 +0200
Subject: [PATCH 01/47] First sketch

---
 .../src/routes/archive/2027.Physics.tsx       |   75 +
 orbitmines.com/src/routes/archive/Physics.tsx | 1208 +++++++++++++++++
 2 files changed, 1283 insertions(+)
 create mode 100644 orbitmines.com/src/routes/archive/2027.Physics.tsx
 create mode 100644 orbitmines.com/src/routes/archive/Physics.tsx

diff --git a/orbitmines.com/src/routes/archive/2027.Physics.tsx b/orbitmines.com/src/routes/archive/2027.Physics.tsx
new file mode 100644
index 0000000..8f803af
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2027.Physics.tsx
@@ -0,0 +1,75 @@
+enum Op {
+  Repell,
+  Attract,
+  Neutral
+}
+
+class Universe {
+  static _2D = () => Universe.nD_Expanding(2);
+  static _3D = () => Universe.nD_Expanding(3);
+  static nD_Expanding = (d: number) => {}
+
+  //TODO Should probably be something occilating instead of random
+  static random<T>(arr: T[]): T {
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+}
+
+class Graph {
+  buffer: node[] = []
+  elements: node[] = []
+
+  tick() {
+    this.buffer = this.elements; //todo copy
+
+    for (const node of this.buffer) {
+      const selected = Universe.random(node)
+      selected.tick();
+    }
+  }
+}
+
+type node = Ray[]
+
+class Ray {
+  boundaries: Boundary[] = []
+
+  tick() {
+    for (const boundary of this.boundaries) {
+      switch(boundary.op) {
+        case Op.Repell: { boundary.repell(); break; }
+        case Op.Attract: { boundary.attract(); break; }
+      }
+    }
+  }
+}
+
+class Boundary {
+  op: Op = Op.Neutral
+  
+  get source(): Boundary { return Universe.random(this.at.boundaries.filter(x => x !== this)); }
+  target?: Boundary
+  
+  constructor(public at: Ray) {}
+
+  repeller() { this.op = Op.Repell; }
+  attractor() { this.op = Op.Attract; }
+
+  repell() {
+    
+  }
+  attract() {
+    if (!this.target) return; //TODO What to do at boundaries?
+    // if (this.target.op === Op.Attract) {
+    //   const source = this.source;
+    //   if (source.op === Op.Repell) return this.annihilate();
+    //   else return 
+    // }
+    
+  }
+
+  annihilate() {
+
+  }
+
+}
\ No newline at end of file
diff --git a/orbitmines.com/src/routes/archive/Physics.tsx b/orbitmines.com/src/routes/archive/Physics.tsx
new file mode 100644
index 0000000..b7521e2
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/Physics.tsx
@@ -0,0 +1,1208 @@
+import { useEffect, useRef, useState, useCallback } from "react";
+
+/* ---------------------------------------------------------------------
+ * Core model — faithful port of Op / Boundary / Ray, plus a spatial
+ * GridNode wrapper (position + velocity) so the abstract graph can be
+ * laid out and drawn. Nothing here is React-specific.
+ * ------------------------------------------------------------------- */
+
+const Op = { Repell: "Repell", Attract: "Attract", Neutral: "Neutral" };
+
+class Boundary {
+  constructor(at) {
+    this.op = Op.Neutral;
+    this.at = at;
+    this.target = null;
+  }
+  repell() {
+    /* like repels like — no structural change, just displacement */
+  }
+  attract() {
+    /* unused by the expanding-grid seed: no Attract boundaries exist yet */
+  }
+}
+
+class Ray {
+  constructor(direction) {
+    this.direction = direction; // unit vector this Ray's Repell boundary faces
+    this.boundaries = [new Boundary(this)];
+  }
+}
+
+class GridNode {
+  // node = Ray[] in the original model; this wraps that with spatial state
+  // so the same graph can be force-laid-out and rendered. gridPos is null
+  // for nodes that don't belong to the lattice (repell-spawned space
+  // markers) — those are driven entirely by the generic physics in
+  // step(), never by the deterministic gridPos×scaleFactor placement.
+  constructor(pos, isCenter, gridPos = pos) {
+    this.gridPos = gridPos ? gridPos.slice() : null;
+    this.pos = pos.slice();
+    this.vel = pos.map(() => 0);
+    this.isCenter = isCenter;
+    this.isPhoton = false;
+    this.weight = 1; // accumulates when this node consumes another
+    this.rays = [];
+  }
+  get repelCount() {
+    let n = 0;
+    for (const ray of this.rays) {
+      for (const b of ray.boundaries) if (b.op === Op.Repell) n++;
+    }
+    return n;
+  }
+  hasOp(op) {
+    return this.rays.some((ray) => ray.boundaries[0].op === op);
+  }
+}
+
+// A ray's direction is one of the grid's own cardinal axes (±x, ±y, ±z —
+// exactly what a mesh-neighbor direction actually is), not an arbitrary
+// continuous direction. This is what makes tryConsume's alignment check
+// meaningful (dot product lands at exactly 1 when a ray really does point
+// at an occupied neighbor slot) and what makes rays render along the same
+// grid lines the mesh edges use, instead of at odd, unrelated angles.
+function randomDir(d) {
+  const axis = Math.floor(Math.random() * d);
+  const sign = Math.random() < 0.5 ? -1 : 1;
+  const v = new Array(d).fill(0);
+  v[axis] = sign;
+  return v;
+}
+
+// 40% Repell / 30% Attract / 30% Neutral — enough Repell to keep the
+// expansion-frontier glow visible, enough Attract density that adjacent
+// cells occasionally line up for an Attract ray to consume its neighbor.
+function randomOp() {
+  const r = Math.random();
+  if (r < 0.4) return Op.Repell;
+  if (r < 0.7) return Op.Attract;
+  return Op.Neutral;
+}
+
+// The axis-aligned direction that points toward center along whichever
+// coordinate is largest in magnitude — the one that actually put this
+// cell at its current ring distance. Used as the boundary's guaranteed
+// inward Repell ray (see below) rather than leaving it to random chance.
+function primaryInwardDir(gridPos, d) {
+  let axis = 0, maxAbs = -1;
+  for (let i = 0; i < d; i++) {
+    const a = Math.abs(gridPos[i]);
+    if (a > maxAbs) {
+      maxAbs = a;
+      axis = i;
+    }
+  }
+  const dir = new Array(d).fill(0);
+  dir[axis] = gridPos[axis] > 0 ? -1 : 1;
+  return dir;
+}
+
+/**
+ * Universe.nD_Expanding — seeds a (2·1+1)^d grid (3×3 for d=2, 3×3×3 for d=3).
+ * Every non-center cell gets two rays, both pointing inward (toward
+ * center along whichever axis is largest — see primaryInwardDir): that
+ * direction is deterministic, defining the cell's structural place in
+ * the lattice. Each ray's op (Repell/Attract/Neutral) is independently
+ * random. The grid's own structure carries the ops directly — there is
+ * no separate node holding them. The center cell gets a single Repell
+ * ray with no direction — it's the seed the rest of the grid expands
+ * from.
+ */
+function nD_Expanding(d, size = 3) {
+  const center = Math.floor(size / 2);
+  const coords = [];
+  (function build(prefix) {
+    if (prefix.length === d) {
+      coords.push(prefix);
+      return;
+    }
+    for (let i = 0; i < size; i++) build([...prefix, i]);
+  })([]);
+
+  const nodes = coords.map((idx) => {
+    const c = idx.map((v) => v - center);
+    const isCenter = c.every((v) => v === 0);
+    const node = new GridNode(c, isCenter);
+
+    if (isCenter) {
+      const seed = new Ray(c.map(() => 0));
+      seed.boundaries[0].op = Op.Repell;
+      node.rays.push(seed);
+    } else {
+      // Direction is deterministic (inward, defining this cell's place in
+      // the lattice); op is random. The grid's own structure carries the
+      // ops directly — there's no separate node holding them.
+      const inward = primaryInwardDir(c, d);
+      for (let k = 0; k < 2; k++) {
+        const ray = new Ray(inward.slice());
+        ray.boundaries[0].op = randomOp();
+        node.rays.push(ray);
+      }
+    }
+    return node;
+  });
+
+  const keyOf = (c) => c.join(",");
+  const byKey = new Map(nodes.map((n) => [keyOf(n.pos), n]));
+
+  // Boundary.target: both of a cell's Repell boundaries target the same
+  // inward neighbor (one step closer to center) — "superposed ... targeting
+  // inward". This is the semantic op-graph the Ray/Boundary model actually
+  // acts on, kept separate from the mesh below.
+  for (const n of nodes) {
+    if (n.isCenter) continue;
+    const parentPos = n.pos.map((v) => v - Math.sign(v));
+    const parent = byKey.get(keyOf(parentPos));
+    if (parent) {
+      for (const ray of n.rays) ray.boundaries[0].target = parent.rays[0].boundaries[0];
+    }
+  }
+
+  // Rendering/layout mesh: full orthogonal grid adjacency — every cell to
+  // its lattice neighbors — so what's on screen reads as an actual grid
+  // (squares in 2D, a cube lattice in 3D) rather than spokes to the center.
+  const edges = [];
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      const a = nodes[i], b = nodes[j];
+      const manhattan = a.pos.reduce((s, v, k) => s + Math.abs(v - b.pos[k]), 0);
+      if (manhattan === 1) edges.push([a, b]);
+    }
+  }
+
+  const initialMaxR = Math.max(...nodes.map((n) => Math.hypot(...n.pos)), 1e-6);
+  const byGridKey = new Map(nodes.map((n) => [keyOf(n.pos), n]));
+  return { nodes, edges, tick: 0, initialMaxR, ringRadius: 1, scaleFactor: 1, freeCount: 0, freeQueue: [], nextGlobalTick: 0, globalTickId: 0, gridNodeCount: nodes.length, byGridKey };
+}
+
+/**
+ * growShell — adds the next outer shell of the lattice (every cell at
+ * Chebyshev distance ringRadius+1 from center). Each new cell gets two
+ * rays, both pointing inward (see primaryInwardDir) — the deterministic
+ * structure that defines the grid's shape. Each ray's op is independently
+ * random (Repell/Attract/Neutral) — the grid's own structure carries the
+ * ops directly, there's no separate node holding them. Spawn position is
+ * exact (gridPos × current scaleFactor), so cells land in place
+ * immediately.
+ */
+// Creates one grid cell at gridPos if that position isn't already
+// occupied — no-op (returns null) otherwise. Shared by growShell's
+// systematic ring-filling and by Repell-triggered spawning below, so
+// both use the exact same cell structure and the exact same dedupe
+// check: whichever gets there first wins, the other is just a no-op.
+function createGridCell(sim, gridPos, d) {
+  const keyOf = (c) => c.join(",");
+  const byGridKey = sim.byGridKey;
+  const key = keyOf(gridPos);
+  if (byGridKey.has(key)) return null;
+
+  const parentGridPos = gridPos.map((v) => v - Math.sign(v));
+  const parent = byGridKey.get(keyOf(parentGridPos));
+
+  const node = new GridNode(gridPos, false);
+  // Position is fully deterministic — no Math.random() anywhere in this
+  // calculation. Seeded from the parent's actual current position (found
+  // via gridPos adjacency, but using the parent's real physics-driven
+  // position, not a gridPos*scale formula) plus a tiny, deterministic
+  // offset along this cell's own inward direction (same value every run
+  // for the same graph state) — just enough to avoid two siblings
+  // landing at the exact same coordinate, which would leave repulsion's
+  // force direction undefined between them. The weak spring on the edge
+  // below, plus repulsion, is what actually determines where this node
+  // ends up — the seed position is only a deterministic starting point.
+  const seedDir = primaryInwardDir(gridPos, d).map((v) => -v);
+  const anchor = parent || sim.nodes[0];
+  node.pos = anchor.pos.map((v, k) => v + seedDir[k] * 0.01);
+
+  // Direction is deterministic (inward); op is random. The grid's own
+  // structure carries the ops directly — no separate node holds them.
+  const inward = primaryInwardDir(gridPos, d);
+  for (let k = 0; k < 2; k++) {
+    const ray = new Ray(inward.slice());
+    ray.boundaries[0].op = randomOp();
+    node.rays.push(ray);
+  }
+
+  if (parent && parent.rays[0]) {
+    for (const ray of node.rays) ray.boundaries[0].target = parent.rays[0].boundaries[0];
+  }
+
+  byGridKey.set(key, node);
+  for (let axis = 0; axis < d; axis++) {
+    for (const step of [-1, 1]) {
+      const np = gridPos.slice();
+      np[axis] += step;
+      const neighbor = byGridKey.get(keyOf(np));
+      if (neighbor) sim.edges.push([node, neighbor]);
+    }
+  }
+
+  sim.nodes.push(node);
+  sim.gridNodeCount = (sim.gridNodeCount || 0) + 1;
+  const ring = Math.max(...gridPos.map((v) => Math.abs(v)));
+  if (ring > sim.ringRadius) sim.ringRadius = ring;
+
+  return node;
+}
+
+function growShell(sim, d) {
+  const newR = sim.ringRadius + 1;
+  const newGridCoords = [];
+  (function build(prefix) {
+    if (prefix.length === d) {
+      const maxAbs = Math.max(...prefix.map((v) => Math.abs(v)));
+      if (maxAbs === newR) newGridCoords.push(prefix);
+      return;
+    }
+    for (let i = -newR; i <= newR; i++) build([...prefix, i]);
+  })([]);
+
+  // Spawn position is exact, not estimated: gridPos × the current global
+  // scale factor — that's what createGridCell uses. Nodes with a gridPos
+  // skip the generic force-directed physics entirely (see step()) and
+  // are driven purely by this scale factor, so they can't drift,
+  // overlap, or destabilize regardless of grid size.
+  for (const gridPos of newGridCoords) createGridCell(sim, gridPos, d);
+
+  sim._forces = null; // resize physics buffers next step()
+  sweep(sim);
+}
+
+/**
+ * Reaction mechanics — the literal reading of repel/attract as space
+ * creation/destruction: a Repell ray periodically sprouts a new node
+ * ahead of itself (on a cooldown, so it's an ongoing trickle rather than
+ * a one-time burst or a permanent exhaustion). An Attract ray, aimed
+ * close enough at an actual neighbor, consumes it — the graph
+ * restructures rather than anything going flying: the target is removed
+ * and its other connections are inherited by the attacker, which is what
+ * accumulates weight over time. When the attacker and target are BOTH
+ * "matter" (an Attract ray and a Repell ray each), the encounter is an
+ * annihilation instead: both are replaced by two photons. Two photons
+ * that end up structurally connected pair-produce back into matter. None
+ * of this uses velocity or movement — it's all graph restructuring, so
+ * it can't reintroduce nodes "flying" anywhere.
+ */
+function markDead(sim, node) {
+  node._dead = true;
+  sim._anyDead = true;
+  if (node.gridPos) sim.gridNodeCount = Math.max((sim.gridNodeCount || 0) - 1, 0);
+  else sim.freeCount = Math.max((sim.freeCount || 0) - 1, 0);
+}
+
+function sweep(sim) {
+  if (!sim._anyDead) return;
+  sim.nodes = sim.nodes.filter((n) => !n._dead);
+  sim.edges = sim.edges.filter(([a, b]) => !a._dead && !b._dead);
+  if (sim.byGridKey) {
+    for (const [k, v] of sim.byGridKey) {
+      if (v._dead) sim.byGridKey.delete(k);
+    }
+  }
+  sim._anyDead = false;
+  sim._forces = null;
+}
+
+// Rewires target's OTHER edges (not the one to `keep`) onto `keep`,
+// skipping anything already connected or dead. Shared by consume and
+// annihilation — both replace a node but want its structure inherited.
+function rewireOnto(sim, keep, from) {
+  const keepNeighbors = new Set();
+  for (const [ea, eb] of sim.edges) {
+    if (ea === keep) keepNeighbors.add(eb);
+    else if (eb === keep) keepNeighbors.add(ea);
+  }
+  for (const [ea, eb] of sim.edges) {
+    let other = null;
+    if (ea === from && eb !== keep) other = eb;
+    else if (eb === from && ea !== keep) other = ea;
+    if (other && !other._dead && other !== keep && !keepNeighbors.has(other)) {
+      sim.edges.push([keep, other, true]);
+      keepNeighbors.add(other);
+    }
+  }
+}
+
+// Rolling window: instead of ever blocking creation once the free-node
+// budget is full, retire the oldest free node to make room first. Repel
+// (and photon/pair-production) creation should never be stoppable — a
+// hard cap that refuses new creation contradicts that, however generous
+// the number. This keeps total count bounded through turnover instead.
+function makeRoomForFreeNode(sim) {
+  while ((sim.freeCount || 0) >= FREE_NODE_CAP && sim.freeQueue.length) {
+    const oldest = sim.freeQueue.shift();
+    if (!oldest._dead) markDead(sim, oldest);
+  }
+}
+
+function spawnPhoton(sim, pos, dir) {
+  makeRoomForFreeNode(sim);
+  const node = new GridNode(pos, false, null);
+  node.isPhoton = true;
+  const ray = new Ray(dir.slice());
+  ray.boundaries[0].op = Op.Neutral;
+  node.rays.push(ray);
+  sim.nodes.push(node);
+  sim.freeQueue.push(node);
+  sim.freeCount = (sim.freeCount || 0) + 1;
+  return node;
+}
+
+function spawnMatter(sim, pos, dir, reversed) {
+  makeRoomForFreeNode(sim);
+  const node = new GridNode(pos, false, null);
+  const front = new Ray(dir.slice());
+  const back = new Ray(dir.map((v) => -v));
+  if (!reversed) {
+    front.boundaries[0].op = Op.Attract;
+    back.boundaries[0].op = Op.Repell;
+  } else {
+    front.boundaries[0].op = Op.Repell;
+    back.boundaries[0].op = Op.Attract;
+  }
+  node.rays.push(front, back);
+  sim.nodes.push(node);
+  sim.freeQueue.push(node);
+  sim.freeCount = (sim.freeCount || 0) + 1;
+  return node;
+}
+
+function isMatter(node) {
+  return node.hasOp(Op.Attract) && node.hasOp(Op.Repell);
+}
+
+// Both nodes are "matter" and aligned — annihilate into two photons
+// instead of a normal one-sided consume. Each photon inherits one side's
+// other connections and points away from the collision, back-to-back —
+// direction only, no velocity. Frontier nodes are exempt, same reasoning
+// as tryConsume.
+function isOnFrontier(sim, node) {
+  return node.gridPos && Math.max(...node.gridPos.map((v) => Math.abs(v))) === sim.ringRadius;
+}
+
+function tryAnnihilate(sim, a, b) {
+  if (a._dead || b._dead || a.isCenter || b.isCenter) return false;
+  if (a.isPhoton || b.isPhoton) return false;
+  if (isOnFrontier(sim, a) || isOnFrontier(sim, b)) return false;
+  if (!isMatter(a) || !isMatter(b)) return false;
+
+  const diff = a.pos.map((v, k) => v - b.pos[k]);
+  const len = Math.hypot(...diff) || 1e-6;
+  const dir = diff.map((v) => v / len);
+
+  const aligned = (n1, n2, d) =>
+    n1.rays.some((ray) => ray.boundaries[0].op === Op.Attract && ray.direction.reduce((s, v, k) => s + v * d[k], 0) > 0.75);
+  const negDir = dir.map((v) => -v);
+  if (!aligned(a, b, negDir) && !aligned(b, a, dir)) return false;
+
+  const mid = a.pos.map((v, k) => (v + b.pos[k]) / 2);
+  const p1 = spawnPhoton(sim, mid, dir);
+  const p2 = spawnPhoton(sim, mid, negDir);
+  rewireOnto(sim, p1, a);
+  rewireOnto(sim, p2, b);
+  markDead(sim, a);
+  markDead(sim, b);
+  return true;
+}
+
+// Two photons sharing an edge pair-produce back into matter, moving in
+// the reverse of their incoming directions — mirrors annihilation.
+function tryPairProduce(sim, a, b) {
+  if (a._dead || b._dead) return false;
+  if (!a.isPhoton || !b.isPhoton) return false;
+
+  const mid = a.pos.map((v, k) => (v + b.pos[k]) / 2);
+  const dirA = a.rays[0].direction.map((v) => -v);
+  const dirB = b.rays[0].direction.map((v) => -v);
+  const m1 = spawnMatter(sim, mid, dirA, false);
+  const m2 = spawnMatter(sim, mid, dirB, true);
+  rewireOnto(sim, m1, a);
+  rewireOnto(sim, m2, b);
+  markDead(sim, a);
+  markDead(sim, b);
+  return true;
+}
+
+// An Attract ray consumes whichever actual neighbor it's aimed closely
+// enough at (dot product of ray direction vs. direction-to-neighbor).
+// The target is removed, but its other edges are rewired onto the
+// attacker — if A/2 points at B/5 and B also has rays 4 and 6 connecting
+// it elsewhere, once B is consumed, 4 and 6 now connect to A instead of
+// dangling or vanishing. Weight transfers along with the structure. The
+// active frontier (the current outermost ring) is exempt — it's freshly
+// spawned and would otherwise get eaten before it ever gets a chance to
+// repel outward itself. It becomes a normal consumption target once a
+// newer shell grows past it.
+function tryConsume(sim, attacker, target) {
+  if (attacker._dead || target._dead || target.isCenter) return false;
+  if (attacker.isPhoton || target.isPhoton) return false;
+  if (isOnFrontier(sim, target)) return false;
+  const diff = target.pos.map((v, k) => v - attacker.pos[k]);
+  const len = Math.hypot(...diff) || 1e-6;
+  const dir = diff.map((v) => v / len);
+  for (const ray of attacker.rays) {
+    if (ray.boundaries[0].op !== Op.Attract) continue;
+    if (ray._lastConsumeTick === sim.globalTickId) continue; // already acted this tick
+    const dot = ray.direction.reduce((s, v, k) => s + v * dir[k], 0);
+    if (dot <= 0.75) continue;
+
+    rewireOnto(sim, attacker, target);
+    attacker.weight += target.weight;
+    ray._lastConsumeTick = sim.globalTickId;
+    markDead(sim, target);
+    return true;
+  }
+  return false;
+}
+
+/* ---------------------------------------------------------------------
+ * Generic force-directed physics — this is what makes the renderer work
+ * for "any arbitrary graph": mutual repulsion keeps nodes from
+ * overlapping, spring edges keep connected nodes near each other. Repell
+ * boundaries add one extra force on top: a push away from the origin,
+ * scaled by how many Repell boundaries a node carries — which is the
+ * literal mechanism of the expansion.
+ * ------------------------------------------------------------------- */
+
+const SPRING_K = 0.05; // almost nothing — just enough to keep connected pairs from drifting apart forever, not to hold any shape
+const REWIRED_SPRING_K = 4.0; // strong — a consumption-driven connection is real graph structure and should actually pull
+const REST_LEN = 1.0;
+const EXPANSION_K = 0.85;
+const DAMPING = 0.8;
+const EXPANSION_RATE = 0.18; // exponential growth rate for gridPos-node scaling
+const MAX_NODES = 10000;
+const FREE_NODE_CAP = 4000; // separate budget for repel/photon-spawned nodes, independent of grid growth
+const GLOBAL_TICK_INTERVAL = 0.9; // seconds between synchronized whole-graph repel/attract updates
+
+function step(sim, dt, dim) {
+  const { nodes, edges } = sim;
+  const n = nodes.length;
+  const dims = nodes[0].pos.length;
+
+  // Deterministic scale factor for anything with a gridPos — exact
+  // self-similar growth (v ∝ r, applied exactly rather than integrated),
+  // so it can't drift, overlap, or destabilize no matter how large the
+  // grid gets. This replaces relying on the force-directed physics below
+  // to determine overall grid scale; that physics remains fully intact
+  // and generic for future non-grid nodes (graph rewrites).
+  sim.scaleFactor *= Math.exp(EXPANSION_RATE * dt);
+  const scale = sim.scaleFactor;
+
+  if (!sim._forces || sim._forces.length !== n) {
+    sim._forces = new Array(n);
+    for (let i = 0; i < n; i++) sim._forces[i] = new Array(dims).fill(0);
+  }
+  const forces = sim._forces;
+  for (let i = 0; i < n; i++) for (let k = 0; k < dims; k++) forces[i][k] = 0;
+
+  if (!sim._index) sim._index = new Map();
+  const index = sim._index;
+  index.clear();
+  for (let i = 0; i < n; i++) index.set(nodes[i], i);
+
+  const delta = new Array(dims);
+
+  // Generic force-directed physics — springs from every edge, including
+  // ones consumption has rewired into long-range connections. Rest length
+  // tracks the current scale factor rather than a fixed constant: grid
+  // spacing itself grows exponentially (scaleFactor), so a fixed rest
+  // length would leave springs permanently fighting to compress a graph
+  // that expansion is simultaneously stretching apart — that fight is
+  // what physics couldn't keep pace with. With rest length tracking
+  // scale, springs and expansion agree on target spacing, and spacing
+  // emerges from the springs themselves rather than needing any position
+  // reset, hard or soft.
+  const restLen = REST_LEN * scale;
+  for (const edge of edges) {
+    const a = edge[0], b = edge[1];
+    const k_spring = edge[2] ? REWIRED_SPRING_K : SPRING_K;
+    const i = index.get(a), j = index.get(b);
+    let distSq = 0;
+    for (let k = 0; k < dims; k++) {
+      delta[k] = b.pos[k] - a.pos[k];
+      distSq += delta[k] * delta[k];
+    }
+    const dist = Math.sqrt(distSq) || 1e-4;
+    const f = (k_spring * (dist - restLen)) / dist;
+    for (let k = 0; k < dims; k++) {
+      const fk = delta[k] * f;
+      forces[i][k] += fk;
+      forces[j][k] -= fk;
+    }
+  }
+
+  const dimBoost = dims === 3 ? 1.5 : 1;
+  for (let i = 0; i < n; i++) {
+    const node = nodes[i];
+    if (node.isCenter || node.gridPos) continue;
+    const f = node.repelCount * EXPANSION_K * dimBoost;
+    for (let k = 0; k < dims; k++) forces[i][k] += node.pos[k] * f;
+  }
+
+  // Spatial repulsion between NEARBY nodes, independent of whether
+  // they're connected by an edge at all. Springs only respond to graph
+  // topology — a region with no rewired edges (like the fully
+  // consumption-immune frontier) has nothing else pulling it away from
+  // the shape its mesh topology implies, no matter how the springs
+  // themselves are tuned. This is what gives every node genuine
+  // positional freedom. Hash-bucketed so cost stays roughly O(n) instead
+  // of O(n²): each node only checks nearby buckets, not the whole graph.
+  //
+  // This pairwise scan was measured at ~88% of total frame time once
+  // population reached a couple thousand nodes — by far the dominant
+  // cost. It's recomputed only every OTHER frame now; each node caches
+  // its own repulsion contribution (a property on the node itself, so
+  // it survives sweep() removing dead nodes and shifting indices) and
+  // that cached value is reused untouched on the skipped frame.
+  // Repulsion is a soft, continuous force, not collision detection — one
+  // frame of staleness is physically safe and visually imperceptible,
+  // and this roughly halves its effective cost.
+  const REPEL_RADIUS = restLen * 3;
+  const REPEL_RADIUS_SQ = REPEL_RADIUS * REPEL_RADIUS;
+  const REPULSION_K = 1.3;
+  const bucketSize = REPEL_RADIUS;
+
+  sim._repulseFrameCounter = (sim._repulseFrameCounter || 0) + 1;
+  const recomputeRepulsion = sim._repulseFrameCounter % 2 === 1;
+
+  if (recomputeRepulsion) {
+    if (!sim._neighborOffsets || sim._neighborOffsetsDims !== dims) {
+      const offsets = [];
+      (function buildOffsets(prefix) {
+        if (prefix.length === dims) {
+          offsets.push(prefix.slice());
+          return;
+        }
+        for (const s of [-1, 0, 1]) buildOffsets([...prefix, s]);
+      })([]);
+      sim._neighborOffsets = offsets;
+      sim._neighborOffsetsDims = dims;
+    }
+    // Numeric integer hash instead of array.map+join string keys — avoids
+    // allocating an array and a string for every node on every frame.
+    const P1 = 73856093, P2 = 19349663, P3 = 83492791;
+    const cellCoord = new Array(dims);
+    function hashCell(c) {
+      let h = 0;
+      if (dims > 0) h ^= (c[0] | 0) * P1;
+      if (dims > 1) h ^= (c[1] | 0) * P2;
+      if (dims > 2) h ^= (c[2] | 0) * P3;
+      return h;
+    }
+    const buckets = new Map();
+    for (let i = 0; i < n; i++) {
+      const p = nodes[i].pos;
+      for (let k = 0; k < dims; k++) cellCoord[k] = Math.floor(p[k] / bucketSize);
+      const key = hashCell(cellCoord);
+      let arr = buckets.get(key);
+      if (!arr) buckets.set(key, (arr = []));
+      arr.push(i);
+    }
+    for (let i = 0; i < n; i++) {
+      const node = nodes[i];
+      if (!node._repulseForce || node._repulseForce.length !== dims) node._repulseForce = new Array(dims).fill(0);
+    }
+    for (let i = 0; i < n; i++) for (let k = 0; k < dims; k++) nodes[i]._repulseForce[k] = 0;
+    for (let i = 0; i < n; i++) {
+      const node = nodes[i];
+      for (let k = 0; k < dims; k++) cellCoord[k] = Math.floor(node.pos[k] / bucketSize);
+      for (const offset of sim._neighborOffsets) {
+        for (let k = 0; k < dims; k++) cellCoord[k] += offset[k];
+        const key = hashCell(cellCoord);
+        for (let k = 0; k < dims; k++) cellCoord[k] -= offset[k]; // restore for next offset
+        const bucketNodes = buckets.get(key);
+        if (!bucketNodes) continue;
+        for (const j of bucketNodes) {
+          if (j <= i) continue; // each pair considered exactly once
+          const other = nodes[j];
+          let distSq2 = 0;
+          for (let k = 0; k < dims; k++) {
+            delta[k] = other.pos[k] - node.pos[k];
+            distSq2 += delta[k] * delta[k];
+          }
+          if (distSq2 >= REPEL_RADIUS_SQ) continue; // cheap reject before the sqrt below
+          const d2 = Math.sqrt(distSq2) || 1e-4;
+          const f2 = (REPULSION_K * (REPEL_RADIUS - d2)) / d2;
+          for (let k = 0; k < dims; k++) {
+            const fk = delta[k] * f2;
+            node._repulseForce[k] -= fk;
+            other._repulseForce[k] += fk;
+          }
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < n; i++) {
+    const node = nodes[i];
+    if (!node._repulseForce) continue; // just created this frame on a skip-frame; gets a fresh value next recompute
+    for (let k = 0; k < dims; k++) forces[i][k] += node._repulseForce[k];
+  }
+
+  const MAX_FORCE = 400;
+  const MAX_VEL = 150;
+
+  for (let i = 0; i < n; i++) {
+    const node = nodes[i];
+
+    if (node.isCenter) {
+      for (let k = 0; k < dims; k++) node.vel[k] = 0;
+      continue;
+    }
+
+    let fMagSq = 0;
+    for (let k = 0; k < dims; k++) fMagSq += forces[i][k] * forces[i][k];
+    if (fMagSq > MAX_FORCE * MAX_FORCE) {
+      const s = MAX_FORCE / Math.sqrt(fMagSq);
+      for (let k = 0; k < dims; k++) forces[i][k] *= s;
+    }
+
+    let vMagSq = 0;
+    for (let k = 0; k < dims; k++) {
+      node.vel[k] = (node.vel[k] + forces[i][k] * dt) * DAMPING;
+      vMagSq += node.vel[k] * node.vel[k];
+    }
+    if (vMagSq > MAX_VEL * MAX_VEL) {
+      const s = MAX_VEL / Math.sqrt(vMagSq);
+      for (let k = 0; k < dims; k++) node.vel[k] *= s;
+    }
+
+    for (let k = 0; k < dims; k++) {
+      node.pos[k] += node.vel[k] * dt;
+      if (!Number.isFinite(node.pos[k])) node.pos[k] = 0;
+    }
+  }
+
+  // One synchronized global tick governs everything: grid growth (one new
+  // ring — 3×3 → 5×5 → 7×7, exactly one ring per tick) and every
+  // Repell/Attract boundary in the graph, together. Not independent
+  // timers. On each tick the whole graph is scanned: every un-consumed
+  // edge is checked for annihilation/pair-production/consumption, and
+  // every Repell ray fires. Repell is never spent and never individually
+  // throttled — a boundary keeps expanding on every single global tick,
+  // unconditionally.
+  if (sim.tick >= (sim.nextGlobalTick || 0)) {
+    sim.nextGlobalTick = sim.tick + GLOBAL_TICK_INTERVAL;
+    sim.globalTickId = (sim.globalTickId || 0) + 1;
+
+    // Snapshot the edge count first — rewireOnto (inside tryConsume/
+    // tryAnnihilate) pushes new edges onto this exact array. Iterating a
+    // live, growing array meant a newly-rewired edge got immediately
+    // reprocessed by this same loop, which could trigger further
+    // consumption on a different node's still-unspent ray, pushing more
+    // edges, reprocessed again — an unbounded same-tick cascade once it
+    // reached a high-weight, high-degree node. Newly-rewired edges now
+    // get their first chance on the NEXT tick instead, same as growShell.
+    const edgeCountAtTickStart = edges.length;
+    for (let ei = 0; ei < edgeCountAtTickStart; ei++) {
+      const [a, b] = edges[ei];
+      if (a._dead || b._dead) continue;
+      if (a.isPhoton && b.isPhoton) {
+        tryPairProduce(sim, a, b);
+        continue;
+      }
+      if (a.isPhoton || b.isPhoton) continue;
+      if (tryAnnihilate(sim, a, b)) continue;
+      tryConsume(sim, a, b);
+      tryConsume(sim, b, a);
+    }
+
+    // Repell-triggered spawning: any grid cell with a Repell-op ray tries
+    // to create a new cell one step further outward, using the exact
+    // same mechanism growShell uses (createGridCell). Most of these
+    // no-op — the target position is already filled by growShell's own
+    // systematic growth — except right at the frontier (genuinely empty)
+    // or over a gap left by consumption (regrows it). That self-limits
+    // the real work to roughly the frontier's surface area without
+    // needing an explicit frontier check. Bounded by n (the tick-start
+    // node count) so newly-created cells this tick aren't immediately
+    // rescanned — same reasoning as the edge-scan snapshot above.
+    if ((sim.gridNodeCount || 0) < MAX_NODES) {
+      for (let i = 0; i < n; i++) {
+        const cell = nodes[i];
+        if (cell._dead || cell.isCenter || !cell.gridPos) continue;
+        for (const ray of cell.rays) {
+          if (ray.boundaries[0].op !== Op.Repell) continue;
+          const outward = ray.direction.map((v) => -v);
+          const targetPos = cell.gridPos.map((v, k) => v + (outward[k] || 0));
+          createGridCell(sim, targetPos, dim);
+        }
+      }
+    }
+
+    if ((sim.gridNodeCount || 0) < MAX_NODES) growShell(sim, dim);
+  }
+  sweep(sim);
+}
+
+/* ---------------------------------------------------------------------
+ * Projection + drawing
+ * ------------------------------------------------------------------- */
+
+function project(pos, dim, rot, tilt, camDist) {
+  const x = pos[0] || 0, y = pos[1] || 0, z = pos[2] || 0;
+  if (dim === 2) return { x, y, depth: 1, clipped: false };
+  const cosR = Math.cos(rot), sinR = Math.sin(rot);
+  const x1 = x * cosR - z * sinR;
+  const z1 = x * sinR + z * cosR;
+  const cosT = Math.cos(tilt), sinT = Math.sin(tilt);
+  const y1 = y * cosT - z1 * sinT;
+  const z2 = y * sinT + z1 * cosT;
+  // True perspective: camera sits at distance camDist from the origin
+  // along the view axis. Points nearer the camera than that (denom small
+  // or negative) are behind/at the lens and get clipped. Convergence
+  // toward a vanishing point is now the CORRECT result of an actual
+  // camera, not a bug — it's what "moving the camera closer" means.
+  const denom = z2 + camDist;
+  if (denom < camDist * 0.02) return { x: 0, y: 0, depth: 0, clipped: true };
+  const persp = camDist / denom;
+  return { x: x1 * persp, y: y1 * persp, depth: Math.min(Math.max(persp, 0.15), 6), clipped: false };
+}
+
+function draw(ctx, canvas, sim, dim, cam, dt) {
+  const w = canvas.clientWidth, h = canvas.clientHeight;
+
+  ctx.fillStyle = "#06070c";
+  ctx.fillRect(0, 0, w, h);
+  const vg = ctx.createRadialGradient(w / 2, h / 2, 0, w / 2, h / 2, Math.max(w, h) / 1.05);
+  vg.addColorStop(0, "rgba(20,22,34,0)");
+  vg.addColorStop(1, "rgba(0,0,0,0.55)");
+  ctx.fillStyle = vg;
+  ctx.fillRect(0, 0, w, h);
+
+  if (!sim) return;
+
+  // Raw world extent (unprojected) — this is what the base pixel scale
+  // tracks, deliberately independent of camera distance/perspective, so
+  // there's no feedback loop between "how far the camera has dollied" and
+  // "how much of the grid fits on screen". A real camera doesn't refit
+  // its FOV to guarantee everything stays visible as it moves closer.
+  let worldExtent = 1e-6;
+  for (const n of sim.nodes) {
+    const r = Math.hypot(...n.pos);
+    if (r > worldExtent) worldExtent = r;
+  }
+
+  // Scale/distance are always exactly proportional to the grid's current
+  // size — recomputed directly every frame, not smoothed toward a target.
+  // That matters for two reasons: (1) no lerp means nothing ever "chases"
+  // a moving target, which is what read as unwanted drift; (2) being
+  // exactly proportional means the camera can never fall behind the
+  // grid's exponential physical growth, which a genuinely fixed distance
+  // eventually does — that falling-behind is what looked like runaway
+  // automatic zoom-in with no way to scroll back out. The user's zoom
+  // level (scaleMult / distMult) is a stable multiplier riding on top,
+  // changed only by scroll — never reset or overridden automatically.
+  if (dim === 3) {
+    cam.dist = worldExtent * (cam.distMult || 1.5);
+    cam.scale = (Math.min(w, h) * 0.38) / worldExtent;
+  } else {
+    cam.scale = ((Math.min(w, h) * 0.38) / worldExtent) * (cam.scaleMult || 1);
+  }
+
+  // Cursor-anchored pan only applies in 2D — there's no camera distance to
+  // dolly there, so screen-space zoom-toward-cursor is the natural
+  // control. In 3D the camera orbits/dollies toward the origin, which is
+  // the standard convention for an orbit camera.
+  const panX = dim === 2 && cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
+  const panY = dim === 2 && cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
+  const cx = w / 2 + panX, cy = h / 2 + panY;
+
+  const projected = new Map();
+  for (const n of sim.nodes) {
+    projected.set(n, project(n.pos, dim, cam.rot, cam.tilt, cam.dist || 1));
+  }
+
+  const pts = new Map();
+  for (const [n, p] of projected) {
+    pts.set(n, { x: cx + p.x * cam.scale, y: cy + p.y * cam.scale, depth: p.depth, clipped: p.clipped });
+  }
+
+  // Viewport culling: skip the detailed rendering work (ray projection,
+  // shadowBlur, stroke/fill calls) for anything clearly off-screen. Once
+  // zoomed into part of a large structure, most of the population isn't
+  // actually visible — this is what stops paying for it anyway. Margin
+  // is generous (a couple of scale-units of screen space) so a node just
+  // outside the canvas edge doesn't have its still-visible ray tip
+  // prematurely clipped.
+  const cullMargin = cam.scale * 2;
+  const onScreen = (p) => p.x > -cullMargin && p.x < w + cullMargin && p.y > -cullMargin && p.y < h + cullMargin;
+
+  for (const [n, parent] of sim.edges) {
+    const a = pts.get(n), b = pts.get(parent);
+    if (a.clipped || b.clipped) continue;
+    if (!onScreen(a) && !onScreen(b)) continue;
+    const w = Math.max(n.weight, parent.weight);
+    if (w > 1) {
+      const boost = Math.min(w - 1, 6);
+      ctx.strokeStyle = `rgba(199,175,255,${Math.min(0.16 + boost * 0.1, 0.7)})`;
+      ctx.lineWidth = 1 + boost * 0.35;
+    } else {
+      ctx.strokeStyle = "rgba(120,130,160,0.16)";
+      ctx.lineWidth = 1;
+    }
+    ctx.beginPath();
+    ctx.moveTo(a.x, a.y);
+    ctx.lineTo(b.x, b.y);
+    ctx.stroke();
+  }
+
+  for (const n of sim.nodes) {
+    const p = pts.get(n);
+    if (p.clipped) continue;
+    if (!onScreen(p)) continue;
+    const depth = dim === 3 ? Math.min(Math.max(p.depth, 0.4), 1.6) : 1;
+
+    if (n.isCenter) {
+      const r = Math.min(Math.max(cam.scale * 0.16 * depth, 0.8), 26);
+      const g = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3);
+      g.addColorStop(0, "rgba(255,217,168,0.9)");
+      g.addColorStop(1, "rgba(255,217,168,0)");
+      ctx.fillStyle = g;
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, r * 3, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.fillStyle = "#FFE9CE";
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, r, 0, Math.PI * 2);
+      ctx.fill();
+      continue;
+    }
+
+    if (n.isPhoton) {
+      const dir = n.rays[0].direction;
+      const tipPos = n.pos.map((v, k) => v + (dir[k] || 0) * 0.5);
+      const tip = project(tipPos, dim, cam.rot, cam.tilt, cam.dist || 1);
+      const tx = cx + tip.x * cam.scale, ty = cy + tip.y * cam.scale;
+      const rayLen = Math.hypot(tx - p.x, ty - p.y);
+      if (!tip.clipped && Number.isFinite(tx) && Number.isFinite(ty) && rayLen < cam.scale * 6) {
+        ctx.strokeStyle = "#FFE9A8";
+        ctx.lineWidth = 2 * depth;
+        ctx.shadowColor = "#FFE9A8";
+        ctx.shadowBlur = Math.min(Math.max(cam.scale * 0.06, 2), 16);
+        ctx.beginPath();
+        ctx.moveTo(p.x, p.y);
+        ctx.lineTo(tx, ty);
+        ctx.stroke();
+        ctx.shadowBlur = 0;
+      }
+      ctx.fillStyle = "#FFF6DC";
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, Math.min(Math.max(cam.scale * 0.07 * depth, 0.6), 11), 0, Math.PI * 2);
+      ctx.fill();
+      continue;
+    }
+
+    // Draw each ray colored by its own op — Repell (amber) vs Attract
+    // (cyan) vs Neutral (not drawn). A node with both an Attract and a
+    // Repell ray gets a bright core, since it can both consume neighbors
+    // and sprout new structure.
+    let hasAttract = false, hasRepell = false;
+    for (const ray of n.rays) {
+      const op = ray.boundaries[0].op;
+      if (op === Op.Attract) hasAttract = true;
+      if (op === Op.Repell) hasRepell = true;
+      if (op === Op.Neutral) continue;
+
+      const dir = op === Op.Repell ? ray.direction.map((v) => -v) : ray.direction;
+      const tipPos = n.pos.map((v, k) => v + (dir[k] || 0) * 0.45);
+      const tip = project(tipPos, dim, cam.rot, cam.tilt, cam.dist || 1);
+      const tx = cx + tip.x * cam.scale, ty = cy + tip.y * cam.scale;
+      const rayLen = Math.hypot(tx - p.x, ty - p.y);
+      // The tip point sits farther from origin than the node itself, so
+      // under true perspective it can cross the near-clip plane (or blow
+      // up near it) even when the node doesn't — skip degenerate tips
+      // rather than draw a stray line to screen-center.
+      if (!(!tip.clipped && Number.isFinite(tx) && Number.isFinite(ty) && rayLen < cam.scale * 6)) continue;
+
+      // A Repell ray on an interior (non-frontier) cell still exists — it
+      // just stopped being "the active boundary". Rendered dim rather
+      // than hidden, so a node's true op composition (e.g. an attractor
+      // that also has a repell ray) is never visually lied about; only
+      // the frontier gets the bright glow.
+      const onFrontierNow = n.gridPos ? isOnFrontier(sim, n) : true;
+      const dim_ = op === Op.Repell && !onFrontierNow;
+      const color = op === Op.Repell ? "#FF7A45" : "#3DDCFF";
+      ctx.strokeStyle = dim_ ? "rgba(255,122,69,0.35)" : color;
+      ctx.lineWidth = (dim_ ? 1 : 1.6) * depth;
+      if (!dim_) {
+        ctx.shadowColor = color;
+        ctx.shadowBlur = Math.min(Math.max(cam.scale * 0.045, 1), 9);
+      }
+      ctx.beginPath();
+      ctx.moveTo(p.x, p.y);
+      ctx.lineTo(tx, ty);
+      ctx.stroke();
+      ctx.shadowBlur = 0;
+    }
+
+    const isMatter = hasAttract && hasRepell;
+    const weightBoost = 1 + Math.min(n.weight - 1, 6) * 0.12;
+    ctx.fillStyle = isMatter ? "#EDEFF5" : "#5A5F72";
+    ctx.beginPath();
+    ctx.arc(p.x, p.y, Math.min(Math.max(cam.scale * (isMatter ? 0.075 : 0.05) * depth * weightBoost, 0.5), 16), 0, Math.PI * 2);
+    ctx.fill();
+  }
+}
+
+/* ---------------------------------------------------------------------
+ * Component
+ * ------------------------------------------------------------------- */
+
+export default function ExpandingUniverse() {
+  const canvasRef = useRef(null);
+  const simRef = useRef(null);
+  const camRef = useRef({ scale: 44, rot: 0, tilt: 0.6155, anchor: null, dist: null, distMult: 1.5, scaleMult: 1 });
+  const lastReadoutRef = useRef(0);
+
+  const [dim, setDim] = useState(2);
+  const [running, setRunning] = useState(true);
+  const [readout, setReadout] = useState({ tick: "0.0", factor: "1.00", nodes: 0, gridNodes: 0, ring: 1 });
+
+  const reset = useCallback((d) => {
+    simRef.current = nD_Expanding(d, 3);
+    camRef.current.rot = d === 3 ? Math.PI / 4 : 0;
+    camRef.current.tilt = 0.6155;
+    camRef.current.anchor = null;
+    camRef.current.distMult = 1.5;
+    camRef.current.scaleMult = 1;
+  }, []);
+
+  useEffect(() => {
+    reset(dim);
+  }, [dim, reset]);
+
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    const ctx = canvas.getContext("2d");
+    let raf;
+    let last = performance.now();
+
+    function resize() {
+      const parent = canvas.parentElement;
+      const w = parent.clientWidth, h = parent.clientHeight;
+      const ratio = window.devicePixelRatio || 1;
+      canvas.width = w * ratio;
+      canvas.height = h * ratio;
+      canvas.style.width = w + "px";
+      canvas.style.height = h + "px";
+      ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
+    }
+    resize();
+    window.addEventListener("resize", resize);
+
+    // Scroll to zoom. 2D: cursor-anchored zoom (screen-space, no depth to
+    // navigate) — modifies cam.scaleMult. 3D: real dolly — scrolling
+    // moves the camera closer/farther along the view axis, driving
+    // genuine perspective rather than a flat scale.
+    function onWheel(e) {
+      e.preventDefault();
+      const factor = Math.exp(-e.deltaY * 0.001);
+      const cam = camRef.current;
+
+      if (dim === 3) {
+        cam.distMult = Math.min(Math.max((cam.distMult || 1.5) / factor, 0.01), 200);
+        return;
+      }
+
+      const rect = canvas.getBoundingClientRect();
+      const rx = e.clientX - rect.left - rect.width / 2;
+      const ry = e.clientY - rect.top - rect.height / 2;
+      const curPanX = cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
+      const curPanY = cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
+      cam.anchor = {
+        worldX: (rx - curPanX) / cam.scale,
+        worldY: (ry - curPanY) / cam.scale,
+        screenX: rx,
+        screenY: ry,
+      };
+      cam.scaleMult = Math.min(Math.max((cam.scaleMult || 1) * factor, 1e-4), 1e4);
+    }
+    canvas.addEventListener("wheel", onWheel, { passive: false });
+
+    // Right-click drag to orbit (3D) — horizontal drag rotates, vertical
+    // drag adjusts tilt. Suppress the browser context menu so right-click
+    // is free to use as a drag button.
+    function onContextMenu(e) {
+      e.preventDefault();
+    }
+    canvas.addEventListener("contextmenu", onContextMenu);
+
+    let dragging = false;
+    let lastX = 0, lastY = 0;
+    function onMouseDown(e) {
+      if (e.button !== 2) return;
+      dragging = true;
+      lastX = e.clientX;
+      lastY = e.clientY;
+    }
+    function onMouseMove(e) {
+      if (!dragging) return;
+      const dx = e.clientX - lastX, dy = e.clientY - lastY;
+      lastX = e.clientX;
+      lastY = e.clientY;
+      const cam = camRef.current;
+      cam.rot += dx * 0.006;
+      cam.tilt = Math.min(Math.max(cam.tilt + dy * 0.006, -1.15), 1.15);
+    }
+    function onMouseUp(e) {
+      if (e.button === 2) dragging = false;
+    }
+    canvas.addEventListener("mousedown", onMouseDown);
+    window.addEventListener("mousemove", onMouseMove);
+    window.addEventListener("mouseup", onMouseUp);
+
+    function frame(now) {
+      const dt = Math.min((now - last) / 1000, 0.05);
+      last = now;
+      const sim = simRef.current;
+
+      if (sim && running) {
+        step(sim, dt * 1.3, dim);
+        sim.tick += dt;
+      }
+      draw(ctx, canvas, sim, dim, camRef.current, dt);
+
+      if (sim && now - lastReadoutRef.current > 200) {
+        lastReadoutRef.current = now;
+        setReadout({
+          tick: sim.tick.toFixed(1),
+          factor: sim.scaleFactor.toFixed(2),
+          nodes: sim.nodes.length,
+          gridNodes: sim.gridNodeCount || 0,
+          ring: sim.ringRadius,
+        });
+      }
+      raf = requestAnimationFrame(frame);
+    }
+    raf = requestAnimationFrame(frame);
+
+    return () => {
+      cancelAnimationFrame(raf);
+      window.removeEventListener("resize", resize);
+      canvas.removeEventListener("wheel", onWheel);
+      canvas.removeEventListener("contextmenu", onContextMenu);
+      canvas.removeEventListener("mousedown", onMouseDown);
+      window.removeEventListener("mousemove", onMouseMove);
+      window.removeEventListener("mouseup", onMouseUp);
+    };
+  }, [dim, running]);
+
+  const pillStyle = (active) => ({
+    padding: "6px 14px",
+    borderRadius: 999,
+    fontSize: 12,
+    letterSpacing: 0.5,
+    fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+    border: `1px solid ${active ? "#FF7A45" : "rgba(255,255,255,0.15)"}`,
+    background: active ? "rgba(255,122,69,0.14)" : "rgba(255,255,255,0.03)",
+    color: active ? "#FFD9A8" : "#9BA0B3",
+    cursor: "pointer",
+  });
+
+  return (
+    <div
+      style={{
+        position: "relative",
+        width: "100%",
+        height: "100%",
+        minHeight: 560,
+        background: "#06070c",
+        borderRadius: 16,
+        overflow: "hidden",
+        fontFamily: "Inter, system-ui, sans-serif",
+      }}
+    >
+      <div style={{ position: "absolute", inset: 0 }}>
+        <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%", cursor: "grab" }} />
+      </div>
+
+      <div style={{ position: "absolute", top: 16, left: 16, display: "flex", gap: 8 }}>
+        {[2, 3].map((d) => (
+          <button key={d} onClick={() => setDim(d)} style={pillStyle(dim === d)}>
+            {d}D
+          </button>
+        ))}
+        <button onClick={() => reset(dim)} style={pillStyle(false)}>
+          reset
+        </button>
+        <button onClick={() => setRunning((r) => !r)} style={pillStyle(false)}>
+          {running ? "pause" : "resume"}
+        </button>
+        <span
+          style={{
+            alignSelf: "center",
+            fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+            fontSize: 10,
+            color: "#4A4E5A",
+            marginLeft: 4,
+          }}
+        >
+          scroll to zoom · right-drag to orbit
+        </span>
+      </div>
+
+      <div
+        style={{
+          position: "absolute",
+          top: 16,
+          right: 16,
+          display: "flex",
+          gap: 12,
+          alignItems: "center",
+          fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+          fontSize: 10,
+          color: "#5A5F72",
+        }}
+      >
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FF7A45", boxShadow: "0 0 6px #FF7A45" }} />
+          repell
+        </span>
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#3DDCFF", boxShadow: "0 0 6px #3DDCFF" }} />
+          attract
+        </span>
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#EDEFF5", boxShadow: "0 0 6px #EDEFF5" }} />
+          matter
+        </span>
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#5A5F72" }} />
+          spark
+        </span>
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FFE9A8", boxShadow: "0 0 10px #FFE9A8" }} />
+          photon
+        </span>
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FFE9CE", boxShadow: "0 0 10px #FFE9CE" }} />
+          seed
+        </span>
+      </div>
+
+      <div
+        style={{
+          position: "absolute",
+          bottom: 14,
+          right: 16,
+          textAlign: "right",
+          fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+          fontSize: 11,
+          color: "#7B8093",
+          lineHeight: 1.7,
+        }}
+      >
+        <div>t = {readout.tick}</div>
+        <div>a(t) = {readout.factor}</div>
+        <div>
+          grid = {readout.gridNodes} · total = {readout.nodes} · ring = {readout.ring}
+        </div>
+        <div style={{ color: "#4A4E5A" }}>
+          random repell/attract/neutral per ray · matter annihilates → photons → pair-produces back
+        </div>
+      </div>
+    </div>
+  );
+}
\ No newline at end of file

From bdba5e8c4657ff1ff48975fd6b25b9b3ba70cfd6 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sun, 2 Aug 2026 23:48:15 +0200
Subject: [PATCH 02/47] Pre-XOR-space setup

---
 orbitmines.com/app/archive/[item]/page.tsx    |    1 +
 orbitmines.com/src/@ether/UI/data/articles.ts |    6 +
 orbitmines.com/src/routes/Archive.tsx         |    2 +
 orbitmines.com/src/routes/Minimap.tsx         |    4 +-
 .../archive/2026.RayCalculiAndPhysics.tsx     | 1254 ++++++++++
 .../src/routes/archive/2027.Physics.tsx       |   75 -
 .../src/routes/archive/Physics2.tsx           | 2090 +++++++++++++++++
 orbitmines.com/src/routes/references.tsx      |   17 +
 8 files changed, 3372 insertions(+), 77 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
 delete mode 100644 orbitmines.com/src/routes/archive/2027.Physics.tsx
 create mode 100644 orbitmines.com/src/routes/archive/Physics2.tsx

diff --git a/orbitmines.com/app/archive/[item]/page.tsx b/orbitmines.com/app/archive/[item]/page.tsx
index 9ecba5c..4c3699d 100644
--- a/orbitmines.com/app/archive/[item]/page.tsx
+++ b/orbitmines.com/app/archive/[item]/page.tsx
@@ -13,6 +13,7 @@ export const ITEM_SOURCES: Record<string, string> = {
   'on-orbits-equivalence-and-inconsistencies': 'src/routes/archive/2023.OnOrbits.tsx',
   'towards-a-universal-language': 'src/routes/archive/2025.TowardsAUniversalLanguage.tsx',
   'the-orbitmines-minecraft-server': 'src/routes/archive/2026.MinecraftArchive.tsx',
+  'ray-calculi-and-physics': 'src/routes/archive/2026.RayCalculiAndPhysics.tsx',
 };
 
 // Reads the reference object's `title` literal so the static <title> is owned
diff --git a/orbitmines.com/src/@ether/UI/data/articles.ts b/orbitmines.com/src/@ether/UI/data/articles.ts
index a356675..76c3624 100644
--- a/orbitmines.com/src/@ether/UI/data/articles.ts
+++ b/orbitmines.com/src/@ether/UI/data/articles.ts
@@ -51,6 +51,12 @@ const ARTICLES: Article[] = [
     fileName: '2025.towards-a-universal-language',
     modified: '2025',
   },
+  {
+    slug: 'ray-calculi-and-physics',
+    title: '2026 — Notes on Ray Calculi & Physics',
+    fileName: '2026.ray-calculi-and-physics',
+    modified: '2026',
+  },
   {
     slug: '2025-09-ngi-grant-proposal',
     title: '2025.09 — NGI Grant Proposal (3)',
diff --git a/orbitmines.com/src/routes/Archive.tsx b/orbitmines.com/src/routes/Archive.tsx
index e3f211a..a76fa77 100644
--- a/orbitmines.com/src/routes/Archive.tsx
+++ b/orbitmines.com/src/routes/Archive.tsx
@@ -6,6 +6,7 @@ import OnIntelligibility from "./archive/2022.OnIntelligibility";
 import OnOrbits from "./archive/2023.OnOrbits";
 import TowardsAUniversalLanguage from "./archive/2025.TowardsAUniversalLanguage";
 import MinecraftArchive from "./archive/2026.MinecraftArchive";
+import RayCalculiAndPhysics from './archive/2026.RayCalculiAndPhysics';
 
 const ITEMS: { [key: string]: any } = {
     '2024-02-orbitmines-as-a-game-project': _2024_02_OrbitMines_as_a_Game_Project,
@@ -13,6 +14,7 @@ const ITEMS: { [key: string]: any } = {
     'on-orbits-equivalence-and-inconsistencies': OnOrbits,
     'towards-a-universal-language': TowardsAUniversalLanguage,
     'the-orbitmines-minecraft-server': MinecraftArchive,
+    'ray-calculi-and-physics': RayCalculiAndPhysics,
 }
 
 const Archive = () => {
diff --git a/orbitmines.com/src/routes/Minimap.tsx b/orbitmines.com/src/routes/Minimap.tsx
index 0a7ee87..737f29e 100644
--- a/orbitmines.com/src/routes/Minimap.tsx
+++ b/orbitmines.com/src/routes/Minimap.tsx
@@ -6,11 +6,11 @@ import {Author, Col, CustomIcon, Layer, pageStyles, Reference, Row} from "../lib
 import {PROFILES} from "./profiles/profiles";
 import {Button} from "@blueprintjs/core";
 import {download, DownloadButton, LoginButton, os} from "../@orbitmines/ether/Ether";
-import {ON_INTELLIGIBILITY, ON_ORBITS, _2024_02_ORBITMINES_AS_A_GAME_PROJECT, TOWARDS_A_UNIVERSAL_LANGUAGE, ETHERS_ALMANAC, ORBITMINES_MINECRAFT_ARCHIVE} from "./references";
+import {ON_INTELLIGIBILITY, ON_ORBITS, _2024_02_ORBITMINES_AS_A_GAME_PROJECT, TOWARDS_A_UNIVERSAL_LANGUAGE, ETHERS_ALMANAC, ORBITMINES_MINECRAFT_ARCHIVE, RAY_CALCULI_AND_PHYSICS} from "./references";
 
 
 const Minimap = () => {
-  const papers = [ETHERS_ALMANAC.UPDATES[0], ORBITMINES_MINECRAFT_ARCHIVE, TOWARDS_A_UNIVERSAL_LANGUAGE, _2024_02_ORBITMINES_AS_A_GAME_PROJECT, ON_ORBITS, ON_INTELLIGIBILITY];
+  const papers = [ETHERS_ALMANAC.UPDATES[0], RAY_CALCULI_AND_PHYSICS, ORBITMINES_MINECRAFT_ARCHIVE, TOWARDS_A_UNIVERSAL_LANGUAGE, _2024_02_ORBITMINES_AS_A_GAME_PROJECT, ON_ORBITS, ON_INTELLIGIBILITY];
 
   const profile = ORGANIZATIONS.orbitmines_research.profile;
 
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
new file mode 100644
index 0000000..d37a27d
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -0,0 +1,1254 @@
+import { ON_INTELLIGIBILITY, RAY_CALCULI_AND_PHYSICS } from "../references";
+import REFERENCES from "../profiles/fadi-shawki/fadi_shawki";
+
+import { useNavigate } from "react-router-dom";
+import Post, {
+  BR,
+  PaperProps,
+  Reference,
+  Section,
+  useCounter,
+  CodeBlock,
+  Row,
+  JetBrainsMono, BlueprintIcons20, BlueprintIcons16,
+  Arc,
+  Block
+} from "../../lib/post/Post";
+import { useEffect, useRef, useState } from "react";
+import { Button } from "@blueprintjs/core";
+
+enum Op {
+  Repell,
+  Attract,
+  Neutral
+}
+
+class Universe {
+  static _2D = () => Universe.nD_Expanding(2);
+  static _3D = () => Universe.nD_Expanding(3);
+  static nD_Expanding = (d: number) => { }
+
+  //TODO Should probably be something occilating instead of random
+  static random<T>(arr: T[]): T {
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+
+  static randomOp() {
+    const r = Math.random();
+    if (r < 0.4) return Op.Repell;
+    if (r < 0.7) return Op.Attract;
+    return Op.Neutral;
+  }
+}
+
+function stepAway(from: number[], to: number[]): number[] {
+  return from.map((v, i) =>
+    v + Math.sign(to[i] - v)
+  );
+}
+
+class Graph {
+  buffer: node[] = []
+
+  nodes: node[] = []
+
+  coords = new Map<node, number[]>()
+
+  gridPos = new Map<node, number[]>();
+
+  // Lattice dimensionality and the current outermost Chebyshev ring — the
+  // repell dynamic walks this outward one shell per tick.
+  dims = 3;
+  ringRadius = 0;
+
+  // Transient per-tick state used by the repell expansion (Boundary.repell).
+  _tickId = 0;
+  _tickIndex?: Map<string, node>;
+
+  get edges(): [node, node][] {
+    const seen = new Set<string>();
+    const edges: [node, node][] = [];
+
+    for (const a of this.nodes) {
+      for (const ray of a) {
+        for (const boundary of ray.boundaries) {
+          const target = boundary.target;
+          if (!target) continue;
+
+          const b = target.at.node;
+          if (a === b) continue;
+
+          const ia = this.nodes.indexOf(a);
+          const ib = this.nodes.indexOf(b);
+
+          const key =
+            ia < ib
+              ? `${ia},${ib}`
+              : `${ib},${ia}`;
+
+          if (!seen.has(key)) {
+            seen.add(key);
+            edges.push([a, b]);
+          }
+        }
+      }
+    }
+
+    return edges;
+  }
+
+  connect(a: node, b: node) {
+    // Connect every boundary in a to the first boundary in b.
+    const target = b[0].boundaries[0];
+
+    for (const ray of a)
+      for (const boundary of ray.boundaries)
+        boundary.target = target;
+  }
+
+  tick() {
+    // One tick fires every boundary once. Repeller boundaries push their
+    // node outward (Boundary.repell), so the frontier grows the next shell.
+    // The boundary list is snapshotted first, so cells created this tick
+    // aren't fired until the next one — exactly one shell per tick.
+    this._tickId++;
+
+    const byCoord = new Map<string, node>();
+    for (const nd of this.nodes) {
+      const g = this.gridPos.get(nd);
+      if (g) byCoord.set(g.join(","), nd);
+    }
+    this._tickIndex = byCoord;
+
+    const buffer: Boundary[] = [];
+    for (const node of this.nodes) {
+      for (const ray of node) {
+        buffer.push(...ray.boundaries);
+      }
+    }
+
+    for (const boundary of buffer) {
+      boundary.tick();
+    }
+
+    this._tickIndex = undefined;
+    this.ringRadius += 1;
+    this.invalidateLayout();
+  }
+
+  static expandingGrid(dims: number, size = 3): Graph {
+    const graph = new Graph();
+    const center = Math.floor(size / 2);
+
+    const coords: number[][] = [];
+    (function build(prefix: number[]) {
+      if (prefix.length === dims) {
+        coords.push(prefix);
+        return;
+      }
+      for (let i = 0; i < size; i++)
+        build([...prefix, i]);
+    })([]);
+
+    const byCoord = new Map<string, node>();
+    const coordOf = new Map<node, number[]>();
+
+    const key = (c: number[]) => c.join(",");
+
+    // Create nodes.
+    for (const idx of coords) {
+      const coord = idx.map(v => v - center);
+      const isCenter = coord.every(v => v === 0);
+
+      const node: node = [];
+
+      if (isCenter) {
+        const ray = new Ray(node, graph);
+        ray.boundaries[0].repeller();
+      } else {
+        // Seed condition: one inward-pointing repeller per inward direction
+        // (one per non-zero coordinate axis), so a corner repels along ALL
+        // its axes — 3 in 3D, 2 in 2D, etc. — not just a fixed two. Ops
+        // only diverge from this later (as the graph grows), not on frame one.
+        const inwardDirs = coord.filter(v => v !== 0).length;
+        for (let i = 0; i < inwardDirs; i++) {
+          const ray = new Ray(node, graph);
+          ray.boundaries[0].repeller();
+        }
+      }
+
+      graph.nodes.push(node);
+
+      // remember where this lattice cell belongs
+      graph.gridPos.set(node, coord);
+
+      byCoord.set(key(coord), node);
+      coordOf.set(node, coord);
+    }
+
+    // Semantic lattice links.
+    // Every node connects to its orthogonal neighbours.
+    // Boundary.target is the source of truth for Graph.edges.
+    for (const node of graph.nodes) {
+      const coord = coordOf.get(node)!;
+
+      for (let axis = 0; axis < dims; axis++) {
+        for (const dir of [-1, 1]) {
+          const neighbourCoord = [...coord];
+          neighbourCoord[axis] += dir;
+
+          const currentDistance =
+            coord.reduce((s, v) => s + Math.abs(v), 0);
+          const neighbourDistance =
+            neighbourCoord.reduce((s, v) => s + Math.abs(v), 0);
+
+          if (neighbourDistance >= currentDistance)
+            continue;
+
+          const neighbour = byCoord.get(key(neighbourCoord));
+
+          if (!neighbour)
+            continue;
+
+          // Need one boundary per connection.
+          const ray = node[0];
+          const boundary = new Boundary(ray, graph);
+
+          boundary.target = neighbour[0].boundaries[0];
+          boundary.repeller();
+
+          ray.boundaries.push(boundary);
+        }
+      }
+    }
+
+    graph.dims = dims;
+    graph.ringRadius = center;
+
+    return graph;
+  }
+
+  private layoutCache?: Map<node, Vec>;
+  private dirty = true;
+
+  get layout(): Map<node, Vec> {
+    if (!this.layoutCache || this.dirty) {
+      this.layoutCache = this.sphereLayout({ scale: 50 });
+      this.dirty = false;
+    }
+
+    return this.layoutCache;
+  }
+
+  /**
+   * Deterministic cube→sphere layout.
+   *
+   * Each cell has a cube position (gridPos · scale — a crisp lattice, so
+   * the 3×3×3 seed reads as a clean cube) and a sphere position (the same
+   * direction but at a radius set by its Chebyshev ring, so corners get
+   * pulled in to share a shell). The two are blended by how far the graph
+   * has grown: pure cube at ring 1, easing to a pure sphere by MORPH_RINGS.
+   * So it starts as a nice cube and rounds into a sphere as it expands.
+   * Same graph => same output every run (no forces, no iteration).
+   */
+  sphereLayout({ scale = 50 }: { scale?: number } = {}): Map<node, Vec> {
+    const pos = new Map<node, Vec>();
+
+    const MORPH_RINGS = 6;
+    const raw = Math.min(Math.max((this.ringRadius - 1) / (MORPH_RINGS - 1), 0), 1);
+    const t = raw * raw * (3 - 2 * raw); // smoothstep cube→sphere
+
+    for (const node of this.nodes) {
+      const grid = this.gridPos.get(node);
+
+      if (!grid) {
+        pos.set(node, [0, 0, 0]);
+        continue;
+      }
+
+      const ring = Math.max(...grid.map(v => Math.abs(v)));
+
+      if (ring === 0) {
+        pos.set(node, grid.map(() => 0));
+        continue;
+      }
+
+      const euclidean = Math.hypot(...grid) || 1;
+      const sphereR = ring * scale;
+
+      pos.set(node, grid.map(v => {
+        const cube = v * scale;
+        const sphere = (v / euclidean) * sphereR;
+        return cube * (1 - t) + sphere * t;
+      }));
+    }
+
+    return pos;
+  }
+
+  invalidateLayout() {
+    this.dirty = true;
+  }
+
+  updateLayout() {
+    const layout = this.springLayout({
+      iterations: 50,
+      radius: 100,
+    });
+
+    for (const [node, pos] of layout) {
+      this.positions.set(node, pos);
+
+      if (!this.velocities.has(node)) {
+        this.velocities.set(node, [0, 0, 0]);
+      }
+    }
+
+    // remove deleted nodes
+    for (const node of [...this.positions.keys()]) {
+      if (!this.nodes.includes(node)) {
+        this.positions.delete(node);
+        this.velocities.delete(node);
+      }
+    }
+  }
+
+  /**
+   * Deterministic spring layout.
+   *
+   * Same graph => same output every run.
+   */
+  springLayout(
+    {
+      dims = 3,
+      iterations = 250,
+      radius = 100,
+      springK = 0.8,
+      rewiredSpringK = 0.2,
+      repulsionK = 300,
+      restLength = 50,
+      step = 0.01,
+    }: LayoutOptions = {},
+  ): Map<node, Vec> {
+    let nodes = this.nodes;
+    let edges = this.edges;
+
+    // Stable ordering
+    nodes = [...nodes].sort((a, b) => hashNode(a) - hashNode(b));
+
+    const index = new Map<Ray[], number>();
+
+    for (let i = 0; i < nodes.length; i++)
+      index.set(nodes[i], i);
+
+    const pos = new Map<node, Vec>();
+
+    for (const node of nodes) {
+      const grid = this.gridPos.get(node);
+
+      if (!grid) {
+        pos.set(node, Array(dims).fill(0));
+        continue;
+      }
+
+      pos.set(
+        node,
+        grid.map(v => v * restLength)
+      );
+    }
+
+    const forces: Vec[] = Array.from(
+      { length: nodes.length },
+      () => Array(dims).fill(0),
+    );
+
+    const delta = new Array(dims).fill(0);
+
+    for (let iter = 0; iter < iterations; iter++) {
+
+      // zero forces
+      for (const f of forces)
+        f.fill(0);
+
+      //
+      // REPULSION
+      //
+      for (let i = 0; i < nodes.length; i++) {
+        const pi = pos.get(nodes[i])!;
+
+        for (let j = i + 1; j < nodes.length; j++) {
+          const pj = pos.get(nodes[j])!;
+
+          let distSq = 0;
+
+          for (let k = 0; k < dims; k++) {
+            delta[k] = pj[k] - pi[k];
+            distSq += delta[k] * delta[k];
+          }
+
+          distSq = Math.max(distSq, 1e-6);
+
+          const dist = Math.sqrt(distSq);
+
+          const f = repulsionK / distSq;
+
+          for (let k = 0; k < dims; k++) {
+            const x = delta[k] / dist * f;
+
+            forces[i][k] -= x;
+            forces[j][k] += x;
+          }
+        }
+      }
+
+      //
+      // SPRINGS
+      //
+      for (const edge of edges) {
+
+        const ia = index.get(edge[0])!;
+        const ib = index.get(edge[1])!;
+
+        const pa = pos.get(edge[0])!;
+        const pb = pos.get(edge[1])!;
+
+        let distSq = 0;
+
+        for (let k = 0; k < dims; k++) {
+          delta[k] = pb[k] - pa[k];
+          distSq += delta[k] * delta[k];
+        }
+
+        const dist = Math.sqrt(Math.max(distSq, 1e-6));
+
+        const kSpring = false//edge.rewired
+          ? rewiredSpringK
+          : springK;
+
+        const f = kSpring * (dist - restLength);
+
+        for (let k = 0; k < dims; k++) {
+          const x = delta[k] / dist * f;
+
+          forces[ia][k] += x;
+          forces[ib][k] -= x;
+        }
+      }
+
+      //
+      // MOVE
+      //
+      for (let i = 0; i < nodes.length; i++) {
+
+        let magSq = 0;
+
+        for (let k = 0; k < dims; k++)
+          magSq += forces[i][k] * forces[i][k];
+
+        const maxForce = 300;
+
+        if (magSq > maxForce * maxForce) {
+          const s = maxForce / Math.sqrt(magSq);
+
+          for (let k = 0; k < dims; k++)
+            forces[i][k] *= s;
+        }
+
+        const p = pos.get(nodes[i])!;
+
+        for (let k = 0; k < dims; k++)
+          p[k] += step * forces[i][k];
+      }
+    }
+
+    return pos;
+  }
+
+}
+
+type node = Ray[]
+
+let NEXT_ID = 0;
+class Ray {
+  id: number;
+  boundaries: Boundary[] = [];
+
+  constructor(
+    public readonly node: node,
+    graph: Graph
+  ) {
+    this.id = NEXT_ID++;
+
+    node.push(this);
+
+    this.boundaries.push(
+      new Boundary(this, graph)
+    );
+  }
+
+
+  tick() {
+    for (const boundary of this.boundaries)
+      boundary.tick();
+  }
+}
+
+class Boundary {
+  op: Op = Op.Neutral
+
+  get source(): Boundary { return Universe.random(this.at.boundaries.filter(x => x !== this)); }
+  target?: Boundary
+
+  constructor(public at: Ray, private readonly graph: Graph) { }
+
+  repeller() { this.op = Op.Repell; }
+  attractor() { this.op = Op.Attract; }
+
+  tick() {
+    switch (this.op) {
+      case Op.Repell:
+        this.repell();
+        break;
+
+      case Op.Attract:
+        this.attract();
+        break;
+    }
+  }
+
+  repell() {
+    const graph = this.graph;
+    const node = this.at.node;
+
+    // A node's repellers act TOGETHER — their products are what make the
+    // diagonals — so the whole node repels once per tick, however many
+    // repeller boundaries it has. (Firing per-boundary would only give the
+    // single-axis directions, i.e. a diamond, not the filled square.)
+    if ((node as any)._repelledTick === graph._tickId) return;
+    (node as any)._repelledTick = graph._tickId;
+
+    const g = graph.gridPos.get(node);
+    const byCoord = graph._tickIndex;
+    if (!g || !byCoord) return;
+
+    const key = (c: number[]) => c.join(",");
+
+    // One outward push direction per repeller (per non-zero axis).
+    const dirs: number[][] = [];
+    for (let axis = 0; axis < g.length; axis++) {
+      if (g[axis] !== 0) {
+        const d = g.map(() => 0);
+        d[axis] = Math.sign(g[axis]);
+        dirs.push(d);
+      }
+    }
+    const k = dirs.length;
+    if (k === 0) return; // the center pushes nowhere
+
+    // The node pushes itself outward to the PRODUCT of all its directions
+    // (the diagonal). The cell it vacates, and the intermediate cells
+    // between (the "left" and "up" of a corner's "left, up, and product"),
+    // become new NEUTRAL space — sitting inward of the node, in the
+    // direction its boundaries face, and keeping the moved node connected to
+    // the lattice. The node itself stays a repeller.
+    const full = g.slice();
+    for (const d of dirs) for (let i = 0; i < full.length; i++) full[i] += d[i];
+    if (byCoord.has(key(full))) return; // boxed in by a cell already there
+
+    const makeNeutral = (pos: number[]) => {
+      const kk = key(pos);
+      if (byCoord.has(kk)) return;
+      const space: node = [];
+      new Ray(space, graph); // neutral — plain space, it doesn't repel
+      graph.nodes.push(space);
+      graph.gridPos.set(space, pos.slice());
+      byCoord.set(kk, space);
+    };
+
+    // Intermediate cells: every PROPER non-empty combination of the outward
+    // directions (all but the full product) — neutral space that keeps the
+    // moved node orthogonally connected.
+    for (let mask = 1; mask < (1 << k) - 1; mask++) {
+      const np = g.slice();
+      for (let b = 0; b < k; b++) {
+        if (mask & (1 << b)) {
+          for (let i = 0; i < np.length; i++) np[i] += dirs[b][i];
+        }
+      }
+      makeNeutral(np);
+    }
+
+    // Move the node out to the product cell; its vacated cell becomes neutral.
+    byCoord.delete(key(g));
+    graph.gridPos.set(node, full);
+    byCoord.set(key(full), node);
+    makeNeutral(g.slice());
+  }
+
+
+  attract() {
+    if (!this.target) return;
+
+    const consumed = this.target.at.node;
+
+
+    //
+    // Remove all boundaries pointing at the consumed node.
+    //
+    for (const node of this.graph.nodes) {
+      for (const ray of node) {
+
+        ray.boundaries =
+          ray.boundaries.filter(
+            b => b.target?.at.node !== consumed
+          );
+
+      }
+    }
+
+
+    //
+    // Remove the consumed spatial node.
+    //
+    this.graph.nodes =
+      this.graph.nodes.filter(
+        n => n !== consumed
+      );
+
+
+    //
+    // This connection has been consumed.
+    //
+    this.target = undefined;
+  }
+
+  annihilate() {
+
+  }
+
+}
+
+
+type Vec = number[];
+
+export interface LayoutOptions {
+  dims?: 2 | 3;
+  iterations?: number;
+  radius?: number;
+  springK?: number;
+  rewiredSpringK?: number;
+  repulsionK?: number;
+  restLength?: number;
+  step?: number;
+}
+
+function hashString(s: string): number {
+  let h = 2166136261;
+
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+
+  return h >>> 0;
+}
+
+function hashNode(node: node): number {
+  let h = 2166136261;
+
+  for (const ray of node) {
+    const x = hashString(String(ray.id));
+    h ^= x;
+    h = Math.imul(h, 16777619);
+  }
+
+  return h >>> 0;
+}
+
+function unit(h: number): number {
+  return (h >>> 0) / 4294967296;
+}
+
+function initialPosition(
+  node: node,
+  gridPos: number[],
+  scale: number
+): Vec {
+  return gridPos.map(v => v * scale);
+}
+
+const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) => {
+  const canvasRef = useRef(null);
+  const camRef = useRef({ scale: 44, rot: Math.PI / 4, tilt: 0.6155, anchor: null, dist: null, distMult: 1.5, scaleMult: 1 });
+
+  const [running, setRunning] = useState(false);
+  // Start as a bare 3×3 seed; the repell dynamic (Graph.tick → each cell's
+  // repellers pushing outward, driven by the frame loop while running) is
+  // what grows it outward one shell at a time.
+  const [graph, setGraph] = useState(() => Graph.expandingGrid(2));
+
+  // TODO Right click/left click cursor=grab
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    const ctx = canvas.getContext("2d");
+    let raf: number;
+    let last = performance.now();
+
+    function resize() {
+      const parent = canvas.parentElement;
+      const w = parent.clientWidth, h = parent.clientHeight;
+      const ratio = window.devicePixelRatio || 1;
+      canvas.width = w * ratio;
+      canvas.height = h * ratio;
+      canvas.style.width = w + "px";
+      canvas.style.height = h + "px";
+      ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
+    }
+    resize();
+    window.addEventListener("resize", resize);
+
+    // Scroll to zoom. 2D: cursor-anchored zoom (screen-space, no depth to
+    // navigate) — modifies cam.scaleMult. 3D: real dolly — scrolling
+    // moves the camera closer/farther along the view axis, driving
+    // genuine perspective rather than a flat scale.
+    // function onWheel(e) {
+    //   e.preventDefault();
+    //   const factor = Math.exp(-e.deltaY * 0.001);
+    //   const cam = camRef.current;
+
+    //   if (dim === 3) {
+    //     cam.distMult = Math.min(Math.max((cam.distMult || 1.5) / factor, 0.01), 200);
+    //     return;
+    //   }
+
+    //   const rect = canvas.getBoundingClientRect();
+    //   const rx = e.clientX - rect.left - rect.width / 2;
+    //   const ry = e.clientY - rect.top - rect.height / 2;
+    //   const curPanX = cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
+    //   const curPanY = cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
+    //   cam.anchor = {
+    //     worldX: (rx - curPanX) / cam.scale,
+    //     worldY: (ry - curPanY) / cam.scale,
+    //     screenX: rx,
+    //     screenY: ry,
+    //   };
+    //   cam.scaleMult = Math.min(Math.max((cam.scaleMult || 1) * factor, 1e-4), 1e4);
+    // }
+    // canvas.addEventListener("wheel", onWheel, { passive: false });
+
+    // // Right-click drag to orbit (3D) — horizontal drag rotates, vertical
+    // // drag adjusts tilt. Suppress the browser context menu so right-click
+    // // is free to use as a drag button.
+    // function onContextMenu(e) {
+    //   e.preventDefault();
+    // }
+    // canvas.addEventListener("contextmenu", onContextMenu);
+
+    // let dragging = false;
+    // let lastX = 0, lastY = 0;
+    // function onMouseDown(e) {
+    //   if (e.button !== 2) return;
+    //   dragging = true;
+    //   lastX = e.clientX;
+    //   lastY = e.clientY;
+    // }
+    // function onMouseMove(e) {
+    //   if (!dragging) return;
+    //   const dx = e.clientX - lastX, dy = e.clientY - lastY;
+    //   lastX = e.clientX;
+    //   lastY = e.clientY;
+    //   const cam = camRef.current;
+    //   cam.rot += dx * 0.006;
+    //   cam.tilt = Math.min(Math.max(cam.tilt + dy * 0.006, -1.15), 1.15);
+    // }
+    // function onMouseUp(e) {
+    //   if (e.button === 2) dragging = false;
+    // }
+    // canvas.addEventListener("mousedown", onMouseDown);
+    // window.addEventListener("mousemove", onMouseMove);
+    // window.addEventListener("mouseup", onMouseUp);
+
+    function project(pos, rot, tilt, camDist) {
+      const x = pos[0] || 0, y = pos[1] || 0, z = pos[2] || 0;
+      // if (dim === 2) return { x, y, depth: 1, clipped: false };
+      const cosR = Math.cos(rot), sinR = Math.sin(rot);
+      const x1 = x * cosR - z * sinR;
+      const z1 = x * sinR + z * cosR;
+      const cosT = Math.cos(tilt), sinT = Math.sin(tilt);
+      const y1 = y * cosT - z1 * sinT;
+      const z2 = y * sinT + z1 * cosT;
+      // True perspective: camera sits at distance camDist from the origin
+      // along the view axis. Points nearer the camera than that (denom small
+      // or negative) are behind/at the lens and get clipped. Convergence
+      // toward a vanishing point is now the CORRECT result of an actual
+      // camera, not a bug — it's what "moving the camera closer" means.
+      const denom = z2 + camDist;
+      if (denom < camDist * 0.02) return { x: 0, y: 0, depth: 0, clipped: true };
+      const persp = camDist / denom;
+      return { x: x1 * persp, y: y1 * persp, depth: Math.min(Math.max(persp, 0.15), 6), clipped: false };
+    }
+
+    function draw() {
+      const cam = camRef.current;
+
+      const w = canvas.clientWidth, h = canvas.clientHeight;
+
+      ctx.fillStyle = "#06070c";
+      ctx.fillRect(0, 0, w, h);
+      const vg = ctx.createRadialGradient(w / 2, h / 2, 0, w / 2, h / 2, Math.max(w, h) / 1.05);
+      vg.addColorStop(0, "rgba(20,22,34,0)");
+      vg.addColorStop(1, "rgba(0,0,0,0.55)");
+      ctx.fillStyle = vg;
+      ctx.fillRect(0, 0, w, h);
+
+      if (graph.nodes.length === 0) return;
+
+      const layout = graph.layout;
+
+      // Raw world extent (unprojected) — this is what the base pixel scale
+      // tracks, deliberately independent of camera distance/perspective, so
+      // there's no feedback loop between "how far the camera has dollied" and
+      // "how much of the grid fits on screen". A real camera doesn't refit
+      // its FOV to guarantee everything stays visible as it moves closer.
+      let worldExtent = 1e-6;
+      for (const [node, pos] of layout) {
+        const r = Math.hypot(...pos);
+        if (r > worldExtent) worldExtent = r;
+      }
+
+      // Auto-orient the camera to the effective dimensionality of what's
+      // actually on screen: measure the spread along each world axis and
+      // count how many are meaningfully populated. A 1D structure (one
+      // axis) lies flat as a horizontal line, a 2D structure (two axes) is
+      // viewed straight-on/top-down, and a 3D structure gets a ¾
+      // perspective. The camera eases toward the target so a change in
+      // dimensionality (e.g. a line thickening into a plane) animates
+      // rather than snapping.
+      const lo = [Infinity, Infinity, Infinity];
+      const hi = [-Infinity, -Infinity, -Infinity];
+      for (const [, pos] of layout) {
+        for (let k = 0; k < 3; k++) {
+          const v = pos[k] || 0;
+          if (v < lo[k]) lo[k] = v;
+          if (v > hi[k]) hi[k] = v;
+        }
+      }
+      const extent = [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]];
+      const maxExtent = Math.max(extent[0], extent[1], extent[2], 1e-6);
+      const effDims = extent.filter(e => e > maxExtent * 0.15).length;
+
+      const targetRot = effDims >= 3 ? Math.PI / 4 : 0;
+      const targetTilt = effDims >= 3 ? 0.6155 : 0;
+      const orientEase = 0.12;
+      cam.rot += (targetRot - cam.rot) * orientEase;
+      cam.tilt += (targetTilt - cam.tilt) * orientEase;
+
+      // Scale/distance are always exactly proportional to the grid's current
+      // size — recomputed directly every frame, not smoothed toward a target.
+      // That matters for two reasons: (1) no lerp means nothing ever "chases"
+      // a moving target, which is what read as unwanted drift; (2) being
+      // exactly proportional means the camera can never fall behind the
+      // grid's exponential physical growth, which a genuinely fixed distance
+      // eventually does — that falling-behind is what looked like runaway
+      // automatic zoom-in with no way to scroll back out. The user's zoom
+      // level (scaleMult / distMult) is a stable multiplier riding on top,
+      // changed only by scroll — never reset or overridden automatically.
+      cam.dist = worldExtent * (cam.distMult || 1.5);
+      // cam.scale is fit to the projected bounding box below (once every
+      // node has been projected), so the zoom matches the actual on-screen
+      // shape and the available width/height — see the fit step.
+
+      // Cursor-anchored pan only applies in 2D — there's no camera distance to
+      // dolly there, so screen-space zoom-toward-cursor is the natural
+      // control. In 3D the camera orbits/dollies toward the origin, which is
+      // the standard convention for an orbit camera.
+      // const panX = dim === 2 && cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
+      // const panY = dim === 2 && cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
+      const cx = w / 2 /*+ panX*/, cy = h / 2 /*+ panY*/;
+
+      const gridKey = (c: number[]) => c.join(",");
+      const projected = new Map();
+      const projByKey = new Map<string, any>();
+      for (const [n, pos] of layout) {
+        const pr = project(pos, cam.rot, cam.tilt, cam.dist || 1);
+        projected.set(n, pr);
+        const g = graph.gridPos.get(n);
+        if (g) projByKey.set(gridKey(g), pr);
+      }
+
+      // Fit-to-viewport zoom: size the structure from its actual PROJECTED
+      // extent against the available width and height. A horizontal line
+      // fills the width, a flat plane fills the frame, and a sphere sits
+      // inside the smaller dimension — each zoomed appropriately for its
+      // shape rather than assumed spherical. The bounding box includes the
+      // outward repell tick tips (which reach past the outermost nodes and,
+      // at low ring counts, are proportionally long) so nothing overhangs.
+      let maxAbsX = 1e-6, maxAbsY = 1e-6;
+      const consider = (x: number, y: number) => {
+        const ax = Math.abs(x), ay = Math.abs(y);
+        if (ax > maxAbsX) maxAbsX = ax;
+        if (ay > maxAbsY) maxAbsY = ay;
+      };
+      for (const [n, p] of projected) {
+        if (p.clipped) continue;
+        consider(p.x, p.y);
+        const g = graph.gridPos.get(n);
+        if (!g) continue;
+        let axis = -1, maxA = 0;
+        for (let i = 0; i < g.length; i++) {
+          const a = Math.abs(g[i]);
+          if (a > maxA) { maxA = a; axis = i; }
+        }
+        if (axis < 0) continue;
+        const nc = g.slice();
+        nc[axis] -= Math.sign(g[axis]);
+        const np = projByKey.get(gridKey(nc));
+        if (!np || np.clipped) continue;
+        // Outward repell tick reaches half the edge length past the node:
+        // tip = p + (p - neighbour) * 0.5.
+        consider(p.x + (p.x - np.x) * 0.5, p.y + (p.y - np.y) * 0.5);
+      }
+      const FIT_MARGIN = 0.9; // small gap at the edges
+      cam.scale = Math.min(
+        (w * 0.5 * FIT_MARGIN) / maxAbsX,
+        (h * 0.5 * FIT_MARGIN) / maxAbsY,
+      ) * (cam.scaleMult || 1);
+
+      const pts = new Map();
+      for (const [n, p] of projected) {
+        pts.set(n, { x: cx + p.x * cam.scale, y: cy + p.y * cam.scale, depth: p.depth, clipped: p.clipped });
+      }
+
+      const keyOf = (c: number[]) => c.join(",");
+
+      // Lattice-coordinate lookup so each node's colored op vectors can be
+      // drawn along the ACTUAL edge to its laid-out neighbour, rather than
+      // along an abstract stored axis direction that no longer matches
+      // where the neighbour ended up after layout. This is the fix — the
+      // vectors now sit exactly on the lattice.
+      const byCoord = new Map<string, node>();
+      for (const nd of graph.nodes) {
+        const g = graph.gridPos.get(nd);
+        if (g) byCoord.set(keyOf(g), nd);
+      }
+      const isCenterNode = (nd: node) => {
+        const g = graph.gridPos.get(nd);
+        return !!g && g.every(v => v === 0);
+      };
+      const ringOf = (nd: node) => {
+        const g = graph.gridPos.get(nd);
+        return g ? Math.max(...g.map(v => Math.abs(v))) : 0;
+      };
+      // The lattice neighbour one step inward along whichever axis is
+      // largest in magnitude — i.e. the one that actually set this cell's
+      // ring distance. Pointing the vector at THIS neighbour makes it run
+      // radially along the real lattice, which is the fix (the old
+      // renderer pointed vectors along an abstract world axis regardless
+      // of where the cell sat on the sphere).
+      const primaryInwardNeighbour = (nd: node): node | undefined => {
+        const g = graph.gridPos.get(nd);
+        if (!g) return undefined;
+        let axis = -1, maxAbs = 0;
+        for (let i = 0; i < g.length; i++) {
+          const a = Math.abs(g[i]);
+          if (a > maxAbs) { maxAbs = a; axis = i; }
+        }
+        if (axis < 0) return undefined;
+        const nc = g.slice();
+        nc[axis] -= Math.sign(g[axis]);
+        return byCoord.get(keyOf(nc));
+      };
+      let maxRing = 0;
+      for (const nd of graph.nodes) maxRing = Math.max(maxRing, ringOf(nd));
+
+      // Viewport culling: skip the detailed rendering work (ray projection,
+      // shadowBlur, stroke/fill calls) for anything clearly off-screen. Once
+      // zoomed into part of a large structure, most of the population isn't
+      // actually visible — this is what stops paying for it anyway. Margin
+      // is generous (a couple of scale-units of screen space) so a node just
+      // outside the canvas edge doesn't have its still-visible ray tip
+      // prematurely clipped.
+      const cullMargin = cam.scale * 2;
+      const onScreen = (p) => p.x > -cullMargin && p.x < w + cullMargin && p.y > -cullMargin && p.y < h + cullMargin;
+
+      // Lattice — full, connected edges (each drawn once, from a cell
+      // toward its +axis neighbour), so the mesh stays continuous with no
+      // gaps. The colored boundaries are drawn on top of these edges.
+      ctx.strokeStyle = "rgba(140,150,180,0.3)";
+      for (const nd of graph.nodes) {
+        const g = graph.gridPos.get(nd);
+        if (!g) continue;
+        const a = pts.get(nd);
+        if (!a || a.clipped || !onScreen(a)) continue;
+        const depth = Math.min(Math.max(a.depth, 0.4), 1.6);
+        ctx.lineWidth = 2.2 * depth;
+        for (let axis = 0; axis < g.length; axis++) {
+          const nc = g.slice();
+          nc[axis] += 1;
+          const nb = byCoord.get(keyOf(nc));
+          if (!nb) continue;
+          const b = pts.get(nb);
+          if (!b || b.clipped) continue;
+          ctx.beginPath();
+          ctx.moveTo(a.x, a.y);
+          ctx.lineTo(b.x, b.y);
+          ctx.stroke();
+        }
+      }
+
+      // Gravity-flow density cloud — the warm glow that fills the dense
+      // core. A continuous scalar potential sampled on a real 3D grid,
+      // colored on a dark→purple→orange→white ramp and blended additively
+      // so overlapping samples read as one smooth glow. Fully world-space:
+      // every sample is a real coordinate run through the same camera as
+      // the nodes, so it navigates identically.
+      const sources: { pos: Vec; sign: number; w: number }[] = [];
+      for (const nd of graph.nodes) {
+        let a = false, r = false;
+        for (const ray of nd) {
+          const op = ray.boundaries[0].op;
+          if (op === Op.Attract) a = true;
+          if (op === Op.Repell) r = true;
+        }
+        if (a && r) continue; // both at once cancel to net-neutral matter
+        const wpos = layout.get(nd);
+        if (!wpos) continue;
+        if (a) sources.push({ pos: wpos, sign: 1, w: 1 });
+        else if (r) sources.push({ pos: wpos, sign: -1, w: 1 });
+      }
+      const MAX_SOURCES = 220;
+      if (sources.length > MAX_SOURCES) {
+        sources.sort((x, y) => y.w - x.w);
+        sources.length = MAX_SOURCES;
+      }
+
+      if (sources.length > 0) {
+        const SOFTEN_SQ = (0.6 * worldExtent) ** 2 * 0.02 + 0.04;
+        const gridExtent = worldExtent * 1.05;
+        const RES = 7;
+        const stepG = (gridExtent * 2) / RES;
+        const depthStackCompensation = 1 / (RES * 0.45);
+
+        const densityColor = (t: number, alpha: number) => {
+          t = Math.min(Math.max(t, 0), 1);
+          let r: number, g: number, b: number;
+          if (t < 0.4) { const u = t / 0.4; r = u * 60; g = u * 20; b = u * 70; }
+          else if (t < 0.75) { const u = (t - 0.4) / 0.35; r = 60 + u * 195; g = 20 + u * 95; b = 70 - u * 30; }
+          else { const u = (t - 0.75) / 0.25; r = 255; g = 115 + u * 140; b = 40 + u * 215; }
+          return `rgba(${r | 0},${g | 0},${b | 0},${alpha})`;
+        };
+
+        const samples: { pos: Vec; mag: number }[] = [];
+        let maxMag = 0;
+        const sp: number[] = new Array(3);
+        const build = (axis: number) => {
+          if (axis === 3) {
+            let potential = 0;
+            for (const src of sources) {
+              let distSq = SOFTEN_SQ;
+              for (let k = 0; k < 3; k++) distSq += (src.pos[k] - sp[k]) ** 2;
+              potential += (src.w * src.sign) / distSq;
+            }
+            const mag = Math.max(potential, 0);
+            if (mag > maxMag) maxMag = mag;
+            samples.push({ pos: sp.slice(), mag });
+            return;
+          }
+          for (let i = 0; i < RES; i++) { sp[axis] = -gridExtent + i * stepG + stepG / 2; build(axis + 1); }
+        };
+        build(0);
+
+        const withDepth = samples
+          .map(s => ({ s, proj: project(s.pos, cam.rot, cam.tilt, cam.dist || 1) }))
+          .filter(x => !x.proj.clipped);
+        withDepth.sort((x, y) => y.proj.depth - x.proj.depth);
+
+        const prevComposite = ctx.globalCompositeOperation;
+        ctx.globalCompositeOperation = "lighter";
+        for (const { s, proj } of withDepth) {
+          const x = cx + proj.x * cam.scale, y = cy + proj.y * cam.scale;
+          if (!onScreen({ x, y })) continue;
+          const depthFactor = Math.min(Math.max(proj.depth, 0.3), 1.8);
+          const norm = maxMag > 0 ? Math.min(s.mag / maxMag, 1) : 0;
+          if (norm < 0.015) continue;
+          const radius = (stepG * cam.scale * 0.9 + norm * cam.scale * 0.5) * depthFactor;
+          if (radius < 1.5) continue;
+          const alpha = Math.min(0.05 + norm * 0.35, 0.4) * Math.min(depthFactor, 1) * depthStackCompensation;
+          const grad = ctx.createRadialGradient(x, y, 0, x, y, radius);
+          grad.addColorStop(0, densityColor(norm, alpha));
+          grad.addColorStop(1, densityColor(norm, 0));
+          ctx.fillStyle = grad;
+          ctx.beginPath();
+          ctx.arc(x, y, radius, 0, Math.PI * 2);
+          ctx.fill();
+        }
+        ctx.globalCompositeOperation = prevComposite;
+      }
+
+      for (const n of graph.nodes) {
+        const p = pts.get(n);
+        if (!p || p.clipped || !onScreen(p)) continue;
+        const depth = Math.min(Math.max(p.depth, 0.4), 1.6);
+
+        // Center seed: bright core with a soft glow.
+        if (isCenterNode(n)) {
+          const r = Math.min(Math.max(cam.scale * 0.16 * depth, 0.8), 26);
+          const g = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3);
+          g.addColorStop(0, "rgba(255,217,168,0.9)");
+          g.addColorStop(1, "rgba(255,217,168,0)");
+          ctx.fillStyle = g;
+          ctx.beginPath();
+          ctx.arc(p.x, p.y, r * 3, 0, Math.PI * 2);
+          ctx.fill();
+          ctx.fillStyle = "#FFE9CE";
+          ctx.beginPath();
+          ctx.arc(p.x, p.y, r, 0, Math.PI * 2);
+          ctx.fill();
+          continue;
+        }
+
+        // Existing orthogonal lattice neighbours, split into inward
+        // (closer to center) and outward. Boundaries are drawn along one of
+        // these REAL edges, so a highlight always overlaps a lattice line
+        // instead of pointing off into empty space.
+        const g = graph.gridPos.get(n);
+        const inwardNs: node[] = [];
+        const outwardNs: node[] = [];
+        if (g) {
+          const cur = g.reduce((s, v) => s + Math.abs(v), 0);
+          for (let axis = 0; axis < g.length; axis++) {
+            for (const dir of [-1, 1]) {
+              const nc = g.slice();
+              nc[axis] += dir;
+              const nb = byCoord.get(keyOf(nc));
+              if (!nb) continue;
+              const md = nc.reduce((s, v) => s + Math.abs(v), 0);
+              if (md < cur) inwardNs.push(nb); else outwardNs.push(nb);
+            }
+          }
+        }
+
+        // One boundary per inward direction: ray i is drawn along inward
+        // edge i (the counts match — a cell has one ray per inward axis), so
+        // a corner shows a boundary on every axis. Each starts exactly at
+        // the node and lies on its lattice edge (no offset), so where a cell
+        // has several they emanate cleanly from the same corner. The op only
+        // sets the colour.
+        const BOUNDARY_FRAC = 0.25;
+        // Round caps so the thick segments fill the shared corner at the
+        // node instead of leaving a square notch between them.
+        ctx.lineCap = "round";
+        n.forEach((ray, i) => {
+          const op = ray.boundaries[0].op;
+          if (op === Op.Neutral) return;
+
+          const pool = inwardNs.length ? inwardNs : outwardNs;
+          if (!pool.length) return;
+          const target = pool[i % pool.length];
+          if (!target) return;
+
+          const tp = pts.get(target);
+          if (!tp || tp.clipped) return;
+
+          const dx = tp.x - p.x, dy = tp.y - p.y;
+          const len = Math.hypot(dx, dy);
+          if (len < 1) return;
+          const ux = dx / len, uy = dy / len;
+          const L = len * BOUNDARY_FRAC;
+
+          ctx.strokeStyle = op === Op.Repell ? "#FF7A45" : "#3DDCFF";
+          ctx.lineWidth = 4 * depth;
+          ctx.beginPath();
+          ctx.moveTo(p.x, p.y);
+          ctx.lineTo(p.x + ux * L, p.y + uy * L);
+          ctx.stroke();
+        });
+        ctx.lineCap = "butt";
+      }
+    }
+
+    // Grow one full shell every GROW_INTERVAL seconds while running, out to
+    // MAX_RING — this is the dynamic that expands the 3×3×3 seed into a
+    // sphere, one deterministic ring at a time.
+    const GROW_INTERVAL = 0.45;
+    const MAX_RING = 9;
+    let growAccum = 0;
+
+    function frame(now) {
+      const dt = Math.min((now - last) / 1000, 0.05);
+      last = now;
+
+      if (running && graph.ringRadius < MAX_RING) {
+        growAccum += dt;
+        while (growAccum >= GROW_INTERVAL && graph.ringRadius < MAX_RING) {
+          growAccum -= GROW_INTERVAL;
+          graph.tick();
+        }
+      }
+
+      draw();
+
+      raf = requestAnimationFrame(frame);
+    }
+    raf = requestAnimationFrame(frame);
+
+    return () => {
+      cancelAnimationFrame(raf);
+      window.removeEventListener("resize", resize);
+      // canvas.removeEventListener("wheel", onWheel);
+      // canvas.removeEventListener("contextmenu", onContextMenu);
+      // canvas.removeEventListener("mousedown", onMouseDown);
+      // window.removeEventListener("mousemove", onMouseMove);
+      // window.removeEventListener("mouseup", onMouseUp);
+    };
+  }, [running]);
+
+
+  return <Block>
+    <Row center="xs">
+      <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%" }} />
+    </Row>
+    <Row end="xs" className="child-px-2">
+      {running
+        ? <>
+          <div style={{ width: '1em' }}></div>
+          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }} onClick={() => setRunning(false)}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M176 96C149.5 96 128 117.5 128 144L128 496C128 522.5 149.5 544 176 544L240 544C266.5 544 288 522.5 288 496L288 144C288 117.5 266.5 96 240 96L176 96zM400 96C373.5 96 352 117.5 352 144L352 496C352 522.5 373.5 544 400 544L464 544C490.5 544 512 522.5 512 496L512 144C512 117.5 490.5 96 464 96L400 96z" /></svg></Button>
+          <div style={{ width: '1em' }}></div>
+        </>
+        : <>
+          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M491 100.8C478.1 93.8 462.3 94.5 450 102.6L192 272.1L192 128C192 110.3 177.7 96 160 96C142.3 96 128 110.3 128 128L128 512C128 529.7 142.3 544 160 544C177.7 544 192 529.7 192 512L192 367.9L450 537.5C462.3 545.6 478 546.3 491 539.3C504 532.3 512 518.8 512 504.1L512 136.1C512 121.4 503.9 107.9 491 100.9z" /></svg></Button>
+          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }} onClick={() => setRunning(true)}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M187.2 100.9C174.8 94.1 159.8 94.4 147.6 101.6C135.4 108.8 128 121.9 128 136L128 504C128 518.1 135.5 531.2 147.6 538.4C159.7 545.6 174.8 545.9 187.2 539.1L523.2 355.1C536 348.1 544 334.6 544 320C544 305.4 536 291.9 523.2 284.9L187.2 100.9z" /></svg></Button>
+          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M149 100.8C161.9 93.8 177.7 94.5 190 102.6L448 272.1L448 128C448 110.3 462.3 96 480 96C497.7 96 512 110.3 512 128L512 512C512 529.7 497.7 544 480 544C462.3 544 448 529.7 448 512L448 367.9L190 537.5C177.7 545.6 162 546.3 149 539.3C136 532.3 128 518.7 128 504L128 136C128 121.3 136.1 107.8 149 100.8z" /></svg></Button>
+        </>
+      }
+    </Row>
+  </Block>
+}
+
+const RayCalculiAndPhysics = () => {
+  const navigate = useNavigate();
+
+  const referenceCounter = useCounter();
+
+  const paper: Omit<PaperProps, 'children'> = {
+    ...RAY_CALCULI_AND_PHYSICS.reference,
+    pdf: {
+      fonts: [JetBrainsMono, BlueprintIcons20, BlueprintIcons16],
+    },
+    Reference: (props: {}) => (<></>),
+    references: referenceCounter
+  }
+
+  return <Post {...paper}>
+    <Arc head="">
+      <Section head="">
+        <CalculusVisualization repeated>
+
+        </CalculusVisualization>
+
+      </Section>
+    </Arc>
+  </Post>;
+}
+
+export default RayCalculiAndPhysics;
\ No newline at end of file
diff --git a/orbitmines.com/src/routes/archive/2027.Physics.tsx b/orbitmines.com/src/routes/archive/2027.Physics.tsx
deleted file mode 100644
index 8f803af..0000000
--- a/orbitmines.com/src/routes/archive/2027.Physics.tsx
+++ /dev/null
@@ -1,75 +0,0 @@
-enum Op {
-  Repell,
-  Attract,
-  Neutral
-}
-
-class Universe {
-  static _2D = () => Universe.nD_Expanding(2);
-  static _3D = () => Universe.nD_Expanding(3);
-  static nD_Expanding = (d: number) => {}
-
-  //TODO Should probably be something occilating instead of random
-  static random<T>(arr: T[]): T {
-    return arr[Math.floor(Math.random() * arr.length)];
-  }
-}
-
-class Graph {
-  buffer: node[] = []
-  elements: node[] = []
-
-  tick() {
-    this.buffer = this.elements; //todo copy
-
-    for (const node of this.buffer) {
-      const selected = Universe.random(node)
-      selected.tick();
-    }
-  }
-}
-
-type node = Ray[]
-
-class Ray {
-  boundaries: Boundary[] = []
-
-  tick() {
-    for (const boundary of this.boundaries) {
-      switch(boundary.op) {
-        case Op.Repell: { boundary.repell(); break; }
-        case Op.Attract: { boundary.attract(); break; }
-      }
-    }
-  }
-}
-
-class Boundary {
-  op: Op = Op.Neutral
-  
-  get source(): Boundary { return Universe.random(this.at.boundaries.filter(x => x !== this)); }
-  target?: Boundary
-  
-  constructor(public at: Ray) {}
-
-  repeller() { this.op = Op.Repell; }
-  attractor() { this.op = Op.Attract; }
-
-  repell() {
-    
-  }
-  attract() {
-    if (!this.target) return; //TODO What to do at boundaries?
-    // if (this.target.op === Op.Attract) {
-    //   const source = this.source;
-    //   if (source.op === Op.Repell) return this.annihilate();
-    //   else return 
-    // }
-    
-  }
-
-  annihilate() {
-
-  }
-
-}
\ No newline at end of file
diff --git a/orbitmines.com/src/routes/archive/Physics2.tsx b/orbitmines.com/src/routes/archive/Physics2.tsx
new file mode 100644
index 0000000..3a372bb
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/Physics2.tsx
@@ -0,0 +1,2090 @@
+import { useEffect, useRef, useState, useCallback } from "react";
+
+/* ---------------------------------------------------------------------
+ * Core model — faithful port of Op / Boundary / Ray, plus a spatial
+ * GridNode wrapper (position + velocity) so the abstract graph can be
+ * laid out and drawn. Nothing here is React-specific.
+ * ------------------------------------------------------------------- */
+
+const Op = { Repell: "Repell", Attract: "Attract", Neutral: "Neutral" };
+
+class Boundary {
+  constructor(at) {
+    this.op = Op.Neutral;
+    this.at = at;
+    this.target = null;
+  }
+  repell() {
+    /* like repels like — no structural change, just displacement */
+  }
+  attract() {
+    /* unused by the expanding-grid seed: no Attract boundaries exist yet */
+  }
+}
+
+class Ray {
+  constructor(direction) {
+    this.direction = direction; // unit vector this Ray's Repell boundary faces
+    this.boundaries = [new Boundary(this)];
+  }
+}
+
+class GridNode {
+  // node = Ray[] in the original model; this wraps that with spatial state
+  // so the same graph can be force-laid-out and rendered. gridPos is null
+  // for nodes that don't belong to the lattice (repell-spawned space
+  // markers) — those are driven entirely by the generic physics in
+  // step(), never by the deterministic gridPos×scaleFactor placement.
+  constructor(pos, isCenter, gridPos = pos) {
+    this.gridPos = gridPos ? gridPos.slice() : null;
+    this.pos = pos.slice();
+    this.vel = pos.map(() => 0);
+    this.isCenter = isCenter;
+    this.isPhoton = false;
+    this.weight = 1; // accumulates when this node consumes another
+    this.rays = [];
+  }
+  get repelCount() {
+    let n = 0;
+    for (const ray of this.rays) {
+      for (const b of ray.boundaries) if (b.op === Op.Repell) n++;
+    }
+    return n;
+  }
+  hasOp(op) {
+    return this.rays.some((ray) => ray.boundaries[0].op === op);
+  }
+}
+
+// A ray's direction is one of the grid's own cardinal axes (±x, ±y, ±z —
+// exactly what a mesh-neighbor direction actually is), not an arbitrary
+// continuous direction. This is what makes tryConsume's alignment check
+// meaningful (dot product lands at exactly 1 when a ray really does point
+// at an occupied neighbor slot) and what makes rays render along the same
+// grid lines the mesh edges use, instead of at odd, unrelated angles.
+function randomDir(d) {
+  const axis = Math.floor(Math.random() * d);
+  const sign = Math.random() < 0.5 ? -1 : 1;
+  const v = new Array(d).fill(0);
+  v[axis] = sign;
+  return v;
+}
+
+// 40% Repell / 30% Attract / 30% Neutral — enough Repell to keep the
+// expansion-frontier glow visible, enough Attract density that adjacent
+// cells occasionally line up for an Attract ray to consume its neighbor.
+function randomOp() {
+  const r = Math.random();
+  if (r < 0.4) return Op.Repell;
+  if (r < 0.7) return Op.Attract;
+  return Op.Neutral;
+}
+
+// The axis-aligned direction that points toward center along whichever
+// coordinate is largest in magnitude — the one that actually put this
+// cell at its current ring distance. Used as the boundary's guaranteed
+// inward Repell ray (see below) rather than leaving it to random chance.
+function primaryInwardDir(gridPos, d) {
+  let axis = 0, maxAbs = -1;
+  for (let i = 0; i < d; i++) {
+    const a = Math.abs(gridPos[i]);
+    if (a > maxAbs) {
+      maxAbs = a;
+      axis = i;
+    }
+  }
+  const dir = new Array(d).fill(0);
+  dir[axis] = gridPos[axis] > 0 ? -1 : 1;
+  return dir;
+}
+
+// Where this cell belongs in the approximate-3D shell, given its gridPos
+// and the current scale factor: project onto gridPos's own direction,
+// but scale by the Chebyshev ring number rather than gridPos's own
+// Euclidean length — a corner cell like (3,3) and an edge-midpoint cell
+// like (3,0) are the same ring, but (3,3) has Euclidean length √18≈4.24
+// while (3,0) has exactly 3; this pulls corners in to match, which is
+// what makes the whole population a sphere/circle instead of a
+// square/cube. Shared by the seed position at creation and the ongoing
+// anchor force in step() — same formula, same target, so a newly-spawned
+// cell starts exactly where it's headed rather than lagging behind it.
+function sphereTargetPos(gridPos, scale) {
+  const ring = Math.max(...gridPos.map((v) => Math.abs(v)));
+  const euclideanLen = Math.hypot(...gridPos) || 1;
+  const targetR = ring * scale;
+  return gridPos.map((v) => (v / euclideanLen) * targetR);
+}
+
+/**
+ * Universe.nD_Expanding — seeds a (2·1+1)^d grid (3×3 for d=2, 3×3×3 for d=3).
+ * Every non-center cell gets two rays, both pointing inward (toward
+ * center along whichever axis is largest — see primaryInwardDir): that
+ * direction is deterministic, defining the cell's structural place in
+ * the lattice. Each ray's op (Repell/Attract/Neutral) is independently
+ * random. The grid's own structure carries the ops directly — there is
+ * no separate node holding them. The center cell gets a single Repell
+ * ray with no direction — it's the seed the rest of the grid expands
+ * from.
+ */
+function nD_Expanding(d, size = 3) {
+  const center = Math.floor(size / 2);
+  const coords = [];
+  (function build(prefix) {
+    if (prefix.length === d) {
+      coords.push(prefix);
+      return;
+    }
+    for (let i = 0; i < size; i++) build([...prefix, i]);
+  })([]);
+
+  const nodes = coords.map((idx) => {
+    const c = idx.map((v) => v - center);
+    const isCenter = c.every((v) => v === 0);
+    const node = new GridNode(c, isCenter);
+
+    if (isCenter) {
+      const seed = new Ray(c.map(() => 0));
+      seed.boundaries[0].op = Op.Repell;
+      node.rays.push(seed);
+    } else {
+      // Direction is deterministic (inward, defining this cell's place in
+      // the lattice); op is random. The grid's own structure carries the
+      // ops directly — there's no separate node holding them.
+      const inward = primaryInwardDir(c, d);
+      for (let k = 0; k < 2; k++) {
+        const ray = new Ray(inward.slice());
+        ray.boundaries[0].op = randomOp();
+        node.rays.push(ray);
+      }
+    }
+    return node;
+  });
+
+  const keyOf = (c) => c.join(",");
+  const byKey = new Map(nodes.map((n) => [keyOf(n.pos), n]));
+
+  // Boundary.target: both of a cell's Repell boundaries target the same
+  // inward neighbor (one step closer to center) — "superposed ... targeting
+  // inward". This is the semantic op-graph the Ray/Boundary model actually
+  // acts on, kept separate from the mesh below.
+  for (const n of nodes) {
+    if (n.isCenter) continue;
+    const parentPos = n.pos.map((v) => v - Math.sign(v));
+    const parent = byKey.get(keyOf(parentPos));
+    if (parent) {
+      for (const ray of n.rays) ray.boundaries[0].target = parent.rays[0].boundaries[0];
+    }
+  }
+
+  // Rendering/layout mesh: full orthogonal grid adjacency — every cell to
+  // its lattice neighbors — so what's on screen reads as an actual grid
+  // (squares in 2D, a cube lattice in 3D) rather than spokes to the center.
+  const edges = [];
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      const a = nodes[i], b = nodes[j];
+      const manhattan = a.pos.reduce((s, v, k) => s + Math.abs(v - b.pos[k]), 0);
+      if (manhattan === 1) edges.push([a, b]);
+    }
+  }
+
+  const initialMaxR = Math.max(...nodes.map((n) => Math.hypot(...n.pos)), 1e-6);
+  const byGridKey = new Map(nodes.map((n) => [keyOf(n.pos), n]));
+  return { nodes, edges, tick: 0, initialMaxR, ringRadius: 1, scaleFactor: 1, freeCount: 0, freeQueue: [], nextGlobalTick: 0, globalTickId: 0, gridNodeCount: nodes.length, byGridKey };
+}
+
+/**
+ * growShell — adds the next outer shell of the lattice (every cell at
+ * Chebyshev distance ringRadius+1 from center). Each new cell gets two
+ * rays, both pointing inward (see primaryInwardDir) — the deterministic
+ * structure that defines the grid's shape. Each ray's op is independently
+ * random (Repell/Attract/Neutral) — the grid's own structure carries the
+ * ops directly, there's no separate node holding them. Spawn position is
+ * exact (gridPos × current scaleFactor), so cells land in place
+ * immediately.
+ */
+// Creates one grid cell at gridPos if that position isn't already
+// occupied — no-op (returns null) otherwise. Shared by growShell's
+// systematic ring-filling and by Repell-triggered spawning below, so
+// both use the exact same cell structure and the exact same dedupe
+// check: whichever gets there first wins, the other is just a no-op.
+function createGridCell(sim, gridPos, d) {
+  const keyOf = (c) => c.join(",");
+  const byGridKey = sim.byGridKey;
+  const key = keyOf(gridPos);
+  if (byGridKey.has(key)) return null;
+
+  const parentGridPos = gridPos.map((v) => v - Math.sign(v));
+  const parent = byGridKey.get(keyOf(parentGridPos));
+
+  const node = new GridNode(gridPos, false);
+  // Seeded directly at the sphere-projected target position (see
+  // sphereTargetPos) — the same formula the ongoing anchor force in
+  // step() pulls toward. Previously this seeded near the parent's
+  // current position and relied on the anchor force to pull it out to
+  // its proper ring distance over several frames, which is what made
+  // freshly-spawned cells visibly cluster near center before migrating
+  // outward. Now it starts where 3D space says it belongs; a tiny
+  // deterministic offset (this cell's own inward direction) avoids two
+  // siblings landing at the exact same coordinate.
+  const seedDir = primaryInwardDir(gridPos, d).map((v) => -v);
+  const target = sphereTargetPos(gridPos, sim.scaleFactor);
+  node.pos = target.map((v, k) => v + seedDir[k] * 0.01);
+
+  // Direction is deterministic (inward); op is random. The grid's own
+  // structure carries the ops directly — no separate node holds them.
+  const inward = primaryInwardDir(gridPos, d);
+  for (let k = 0; k < 2; k++) {
+    const ray = new Ray(inward.slice());
+    ray.boundaries[0].op = randomOp();
+    node.rays.push(ray);
+  }
+
+  if (parent && parent.rays[0]) {
+    for (const ray of node.rays) ray.boundaries[0].target = parent.rays[0].boundaries[0];
+  }
+
+  byGridKey.set(key, node);
+  for (let axis = 0; axis < d; axis++) {
+    for (const step of [-1, 1]) {
+      const np = gridPos.slice();
+      np[axis] += step;
+      const neighbor = byGridKey.get(keyOf(np));
+      if (neighbor) sim.edges.push([node, neighbor]);
+    }
+  }
+
+  sim.nodes.push(node);
+  sim.gridNodeCount = (sim.gridNodeCount || 0) + 1;
+  const ring = Math.max(...gridPos.map((v) => Math.abs(v)));
+  if (ring > sim.ringRadius) sim.ringRadius = ring;
+
+  return node;
+}
+
+function growShell(sim, d) {
+  const newR = sim.ringRadius + 1;
+  const newGridCoords = [];
+  (function build(prefix) {
+    if (prefix.length === d) {
+      const maxAbs = Math.max(...prefix.map((v) => Math.abs(v)));
+      if (maxAbs === newR) newGridCoords.push(prefix);
+      return;
+    }
+    for (let i = -newR; i <= newR; i++) build([...prefix, i]);
+  })([]);
+
+  // Spawn position is exact, not estimated: gridPos × the current global
+  // scale factor — that's what createGridCell uses. Nodes with a gridPos
+  // skip the generic force-directed physics entirely (see step()) and
+  // are driven purely by this scale factor, so they can't drift,
+  // overlap, or destabilize regardless of grid size.
+  for (const gridPos of newGridCoords) createGridCell(sim, gridPos, d);
+
+  sim._forces = null; // resize physics buffers next step()
+  sweep(sim);
+}
+
+/**
+ * Reaction mechanics — the literal reading of repel/attract as space
+ * creation/destruction: a Repell ray periodically sprouts a new node
+ * ahead of itself (on a cooldown, so it's an ongoing trickle rather than
+ * a one-time burst or a permanent exhaustion). An Attract ray, aimed
+ * close enough at an actual neighbor, consumes it — the graph
+ * restructures rather than anything going flying: the target is removed
+ * and its other connections are inherited by the attacker, which is what
+ * accumulates weight over time. When the attacker and target are BOTH
+ * "matter" (an Attract ray and a Repell ray each), the encounter is an
+ * annihilation instead: both are replaced by two photons. Two photons
+ * that end up structurally connected pair-produce back into matter. None
+ * of this uses velocity or movement — it's all graph restructuring, so
+ * it can't reintroduce nodes "flying" anywhere.
+ */
+function markDead(sim, node) {
+  node._dead = true;
+  sim._anyDead = true;
+  if (node.gridPos) sim.gridNodeCount = Math.max((sim.gridNodeCount || 0) - 1, 0);
+  else sim.freeCount = Math.max((sim.freeCount || 0) - 1, 0);
+}
+
+function sweep(sim) {
+  if (!sim._anyDead) return;
+  sim.nodes = sim.nodes.filter((n) => !n._dead);
+  sim.edges = sim.edges.filter(([a, b]) => !a._dead && !b._dead);
+  if (sim.byGridKey) {
+    for (const [k, v] of sim.byGridKey) {
+      if (v._dead) sim.byGridKey.delete(k);
+    }
+  }
+  sim._anyDead = false;
+  sim._forces = null;
+}
+
+// Rewires target's OTHER edges (not the one to `keep`) onto `keep`,
+// skipping anything already connected or dead. Shared by consume and
+// annihilation — both replace a node but want its structure inherited.
+function rewireOnto(sim, keep, from) {
+  const keepNeighbors = new Set();
+  for (const [ea, eb] of sim.edges) {
+    if (ea === keep) keepNeighbors.add(eb);
+    else if (eb === keep) keepNeighbors.add(ea);
+  }
+  for (const [ea, eb] of sim.edges) {
+    let other = null;
+    if (ea === from && eb !== keep) other = eb;
+    else if (eb === from && ea !== keep) other = ea;
+    if (other && !other._dead && other !== keep && !keepNeighbors.has(other)) {
+      sim.edges.push([keep, other, true]);
+      keepNeighbors.add(other);
+    }
+  }
+}
+
+// Rolling window: instead of ever blocking creation once the free-node
+// budget is full, retire the oldest free node to make room first. Repel
+// (and photon/pair-production) creation should never be stoppable — a
+// hard cap that refuses new creation contradicts that, however generous
+// the number. This keeps total count bounded through turnover instead.
+function makeRoomForFreeNode(sim) {
+  while ((sim.freeCount || 0) >= FREE_NODE_CAP && sim.freeQueue.length) {
+    const oldest = sim.freeQueue.shift();
+    if (!oldest._dead) markDead(sim, oldest);
+  }
+}
+
+function spawnPhoton(sim, pos, dir) {
+  makeRoomForFreeNode(sim);
+  const node = new GridNode(pos, false, null);
+  node.isPhoton = true;
+  const ray = new Ray(dir.slice());
+  ray.boundaries[0].op = Op.Neutral;
+  node.rays.push(ray);
+  sim.nodes.push(node);
+  sim.freeQueue.push(node);
+  sim.freeCount = (sim.freeCount || 0) + 1;
+  return node;
+}
+
+function spawnMatter(sim, pos, dir, reversed) {
+  makeRoomForFreeNode(sim);
+  const node = new GridNode(pos, false, null);
+  const front = new Ray(dir.slice());
+  const back = new Ray(dir.map((v) => -v));
+  if (!reversed) {
+    front.boundaries[0].op = Op.Attract;
+    back.boundaries[0].op = Op.Repell;
+  } else {
+    front.boundaries[0].op = Op.Repell;
+    back.boundaries[0].op = Op.Attract;
+  }
+  node.rays.push(front, back);
+  sim.nodes.push(node);
+  sim.freeQueue.push(node);
+  sim.freeCount = (sim.freeCount || 0) + 1;
+  return node;
+}
+
+function isMatter(node) {
+  return node.hasOp(Op.Attract) && node.hasOp(Op.Repell);
+}
+
+// Both nodes are "matter" and aligned — annihilate into two photons
+// instead of a normal one-sided consume. Each photon inherits one side's
+// other connections and points away from the collision, back-to-back —
+// direction only, no velocity. Frontier nodes are exempt, same reasoning
+// as tryConsume.
+function isOnFrontier(sim, node) {
+  return node.gridPos && Math.max(...node.gridPos.map((v) => Math.abs(v))) === sim.ringRadius;
+}
+
+function tryAnnihilate(sim, a, b) {
+  if (a._dead || b._dead || a.isCenter || b.isCenter) return false;
+  if (a.isPhoton || b.isPhoton) return false;
+  if (isOnFrontier(sim, a) || isOnFrontier(sim, b)) return false;
+  if (!isMatter(a) || !isMatter(b)) return false;
+
+  const diff = a.pos.map((v, k) => v - b.pos[k]);
+  const len = Math.hypot(...diff) || 1e-6;
+  const dir = diff.map((v) => v / len);
+
+  const aligned = (n1, n2, d) =>
+    n1.rays.some((ray) => ray.boundaries[0].op === Op.Attract && ray.direction.reduce((s, v, k) => s + v * d[k], 0) > 0.75);
+  const negDir = dir.map((v) => -v);
+  if (!aligned(a, b, negDir) && !aligned(b, a, dir)) return false;
+
+  const mid = a.pos.map((v, k) => (v + b.pos[k]) / 2);
+  const p1 = spawnPhoton(sim, mid, dir);
+  const p2 = spawnPhoton(sim, mid, negDir);
+  rewireOnto(sim, p1, a);
+  rewireOnto(sim, p2, b);
+  markDead(sim, a);
+  markDead(sim, b);
+  return true;
+}
+
+// Two photons sharing an edge pair-produce back into matter, moving in
+// the reverse of their incoming directions — mirrors annihilation.
+function tryPairProduce(sim, a, b) {
+  if (a._dead || b._dead) return false;
+  if (!a.isPhoton || !b.isPhoton) return false;
+
+  const mid = a.pos.map((v, k) => (v + b.pos[k]) / 2);
+  const dirA = a.rays[0].direction.map((v) => -v);
+  const dirB = b.rays[0].direction.map((v) => -v);
+  const m1 = spawnMatter(sim, mid, dirA, false);
+  const m2 = spawnMatter(sim, mid, dirB, true);
+  rewireOnto(sim, m1, a);
+  rewireOnto(sim, m2, b);
+  markDead(sim, a);
+  markDead(sim, b);
+  return true;
+}
+
+// An Attract ray consumes whichever actual neighbor it's aimed closely
+// enough at (dot product of ray direction vs. direction-to-neighbor).
+// The target is removed, but its other edges are rewired onto the
+// attacker — if A/2 points at B/5 and B also has rays 4 and 6 connecting
+// it elsewhere, once B is consumed, 4 and 6 now connect to A instead of
+// dangling or vanishing. Weight transfers along with the structure. The
+// active frontier (the current outermost ring) is exempt — it's freshly
+// spawned and would otherwise get eaten before it ever gets a chance to
+// repel outward itself. It becomes a normal consumption target once a
+// newer shell grows past it.
+function tryConsume(sim, attacker, target) {
+  if (attacker._dead || target._dead || target.isCenter) return false;
+  if (attacker.isPhoton || target.isPhoton) return false;
+  if (isOnFrontier(sim, target)) return false;
+  const diff = target.pos.map((v, k) => v - attacker.pos[k]);
+  const len = Math.hypot(...diff) || 1e-6;
+  const dir = diff.map((v) => v / len);
+  for (const ray of attacker.rays) {
+    if (ray.boundaries[0].op !== Op.Attract) continue;
+    if (ray._lastConsumeTick === sim.globalTickId) continue; // already acted this tick
+    const dot = ray.direction.reduce((s, v, k) => s + v * dir[k], 0);
+    if (dot <= 0.75) continue;
+
+    rewireOnto(sim, attacker, target);
+    attacker.weight += target.weight;
+    ray._lastConsumeTick = sim.globalTickId;
+    markDead(sim, target);
+    return true;
+  }
+  return false;
+}
+
+/* ---------------------------------------------------------------------
+ * Generic force-directed physics — this is what makes the renderer work
+ * for "any arbitrary graph": mutual repulsion keeps nodes from
+ * overlapping, spring edges keep connected nodes near each other. Repell
+ * boundaries add one extra force on top: a push away from the origin,
+ * scaled by how many Repell boundaries a node carries — which is the
+ * literal mechanism of the expansion.
+ * ------------------------------------------------------------------- */
+
+const SPRING_K = 0.05; // almost nothing — just enough to keep connected pairs from drifting apart forever, not to hold any shape
+const REWIRED_SPRING_K = 4.0; // strong — a consumption-driven connection is real graph structure and should actually pull
+const REST_LEN = 1.0;
+const EXPANSION_K = 0.85;
+const DAMPING = 0.8;
+const EXPANSION_RATE = 0.18; // exponential growth rate for gridPos-node scaling
+const MAX_NODES = 10000;
+const FREE_NODE_CAP = 4000; // separate budget for repel/photon-spawned nodes, independent of grid growth
+const GLOBAL_TICK_INTERVAL = 0.9; // seconds between synchronized whole-graph repel/attract updates
+const REWIRED_SLOTS_GRID = 2; // rewired (consumption-driven) neighbor slots per grid cell — small, since most cells have none; mesh neighbors need zero slots at all now
+const REWIRED_SLOTS_FREE = 4; // free nodes carry a few more since they have no mesh edges of their own
+const GRID_ATLAS_PADDING = 8; // headroom rings before the atlas needs reallocating
+
+/* ---------------------------------------------------------------------
+ * GPU physics, v2 — grid cells are stored in a texture indexed directly
+ * by their own gridPos (offset to a non-negative atlas coordinate), not
+ * by an arbitrary flat index. A mesh neighbor is always exactly ±1 along
+ * one axis, so once a cell's own atlas texel IS its gridPos, finding a
+ * neighbor stops being "look up wherever this index points" (a
+ * data-dependent gather — slow, cache-hostile, and what made the
+ * previous design's dispatch cost dominate regardless of shader
+ * micro-optimization) and becomes "read the texel one step over" — a
+ * fixed, compile-time-known offset. That's the actual fix; every
+ * previous attempt (removing dynamic array indexing, removing
+ * large-argument sin(), halving the gather count) was optimizing
+ * *inside* the gather instead of removing it.
+ *
+ * For 3D, a true GPU 3D texture would need one draw call per Z-layer
+ * (framebuffers attach one 2D layer at a time) — real complexity for
+ * something unverifiable here without a GPU. Instead, Z-slices are
+ * tiled side by side into one larger 2D texture (an atlas): a step of
+ * ±1 in x or y stays within the current slice tile; a step of ±1 in z
+ * is a constant horizontal jump of exactly one slice-width. Single
+ * texture, single draw call, only fixed offsets — verified this
+ * round-trips correctly and that both neighbor directions reduce to
+ * constant offsets before writing any shader code.
+ *
+ * Free nodes (photons/matter — no gridPos, no mesh edges by
+ * construction) and rewired connections (consumption-driven, genuinely
+ * arbitrary/non-local — a heavily-consumed cell can inherit connections
+ * from anywhere) still need a gather. They get a second, separate,
+ * much smaller pass: free nodes are relatively few, and rewired links
+ * are the minority of edges compared to mesh — so the gather that
+ * remains is doing far less work than before, not just doing the same
+ * work faster.
+ * ------------------------------------------------------------------- */
+
+const GRID_VERTEX_SRC = `#version 300 es
+in vec2 aPos;
+void main() { gl_Position = vec4(aPos, 0.0, 1.0); }
+`;
+
+function buildGridFragmentSrc() {
+  return `#version 300 es
+precision highp float;
+
+uniform sampler2D uGridPos;      // atlas: xyz=pos, w=weight (0 = empty slot)
+uniform sampler2D uGridVel;      // atlas: xyz=vel, w=unused
+uniform sampler2D uGridRewired;  // atlas: x=idx0, y=idx1 (flat indices into uPoolPos, -1=none)
+uniform sampler2D uPoolPos;      // flat pool (grid cells mirrored + free nodes): xyz=pos, w=weight
+
+uniform float uScale;
+uniform float uDt;
+uniform float uTick;
+uniform float uDims;
+uniform float uAtlasW;
+uniform float uSliceSize;
+uniform float uGridOffset;
+uniform vec2 uPoolTexSize;
+
+layout(location = 0) out vec4 outPos;
+layout(location = 1) out vec4 outVel;
+
+vec4 fetchPoolByIndex(float idx) {
+  if (idx < -0.5) return vec4(0.0);
+  float w = uPoolTexSize.x;
+  float x = mod(idx, w);
+  float y = floor(idx / w);
+  return texelFetch(uPoolPos, ivec2(int(x), int(y)), 0);
+}
+
+void springTerm(inout vec3 force, vec3 pos, float weight, float restLen, vec4 otherData, float k) {
+  if (otherData.w < 0.5) return;
+  vec3 delta = otherData.xyz - pos;
+  float dist = max(length(delta), 1e-4);
+  float edgeWeight = (weight + otherData.w) * 0.5;
+  force += delta * (k * edgeWeight * (dist - restLen) / dist);
+}
+
+void main() {
+  ivec2 texel = ivec2(gl_FragCoord.xy);
+  vec4 posData = texelFetch(uGridPos, texel, 0);
+  float weight = posData.w;
+
+  if (weight < 0.5) {
+    outPos = posData;
+    outVel = texelFetch(uGridVel, texel, 0);
+    return;
+  }
+
+  vec3 pos = posData.xyz;
+  vec4 velData = texelFetch(uGridVel, texel, 0);
+  vec3 vel = velData.xyz;
+
+  // This cell's own gridPos is implicit in its atlas position — no
+  // lookup, just arithmetic on which texel we are.
+  float sliceSize = uSliceSize;
+  float sliceIndex = floor(float(texel.x) / sliceSize);
+  float localX = float(texel.x) - sliceIndex * sliceSize;
+  vec3 gridPos = vec3(localX - uGridOffset, float(texel.y) - uGridOffset, uDims > 2.5 ? (sliceIndex - uGridOffset) : 0.0);
+
+  bool isCenter = abs(gridPos.x) < 0.5 && abs(gridPos.y) < 0.5 && abs(gridPos.z) < 0.5;
+
+  vec3 force = vec3(0.0);
+  float restLen = uScale;
+  float meshK = ${SPRING_K.toFixed(4)};
+
+  // Mesh neighbors: fixed offsets, no gather, no branch on variable
+  // neighbor count — every occupied cell checks the exact same
+  // candidate set the exact same way.
+  springTerm(force, pos, weight, restLen, texelFetch(uGridPos, texel + ivec2(1, 0), 0), meshK);
+  springTerm(force, pos, weight, restLen, texelFetch(uGridPos, texel + ivec2(-1, 0), 0), meshK);
+  springTerm(force, pos, weight, restLen, texelFetch(uGridPos, texel + ivec2(0, 1), 0), meshK);
+  springTerm(force, pos, weight, restLen, texelFetch(uGridPos, texel + ivec2(0, -1), 0), meshK);
+  if (uDims > 2.5) {
+    int slice = int(sliceSize);
+    ivec2 zp = texel + ivec2(slice, 0);
+    if (zp.x < int(uAtlasW)) springTerm(force, pos, weight, restLen, texelFetch(uGridPos, zp, 0), meshK);
+    ivec2 zn = texel + ivec2(-slice, 0);
+    if (zn.x >= 0) springTerm(force, pos, weight, restLen, texelFetch(uGridPos, zn, 0), meshK);
+  }
+
+  // Rewired (consumption-driven) connections — genuinely arbitrary, so
+  // still a gather, but only 2 slots and only for cells that actually
+  // have any (most don't).
+  vec4 rew = texelFetch(uGridRewired, texel, 0);
+  springTerm(force, pos, weight, restLen, fetchPoolByIndex(rew.x), ${REWIRED_SPRING_K.toFixed(4)});
+  springTerm(force, pos, weight, restLen, fetchPoolByIndex(rew.y), ${REWIRED_SPRING_K.toFixed(4)});
+
+  if (!isCenter) {
+    float ring = max(max(abs(gridPos.x), abs(gridPos.y)), abs(gridPos.z));
+    float glen = max(length(gridPos), 1e-6);
+    vec3 target = (gridPos / glen) * ring * uScale;
+    force += (target - pos) * 3.5;
+
+    int h = 0;
+    h = h * 92821 + int(gridPos.x) * (-1640531535);
+    h = h * 92821 + int(gridPos.y) * (-1640531535);
+    h = h * 92821 + int(gridPos.z) * (-1640531535);
+    float phase = (float(uint(h)) / 4294967296.0) * 6.28318530718;
+    float wobbleK = restLen * 0.18;
+    force.x += sin(uTick * 1.6 + phase) * wobbleK;
+    force.y += sin(uTick * 1.6 + phase + 2.09) * wobbleK;
+    if (uDims > 2.5) force.z += sin(uTick * 1.6 + phase + 4.18) * wobbleK;
+  }
+
+  if (isCenter) {
+    outPos = vec4(pos, weight);
+    outVel = vec4(0.0, 0.0, 0.0, 0.0);
+    return;
+  }
+
+  float maxForce = 400.0;
+  float fMag = length(force);
+  if (fMag > maxForce) force *= (maxForce / fMag);
+
+  vec3 newVel = (vel + force * uDt) * ${DAMPING.toFixed(4)};
+  float maxVel = 150.0;
+  float vMag = length(newVel);
+  if (vMag > maxVel) newVel *= (maxVel / vMag);
+
+  vec3 newPos = pos + newVel * uDt;
+  if (!(newPos.x == newPos.x)) newPos = pos;
+  if (!(newPos.y == newPos.y)) newPos = pos;
+  if (!(newPos.z == newPos.z)) newPos = pos;
+
+  outPos = vec4(newPos, weight);
+  outVel = vec4(newVel, 0.0);
+}
+`;
+}
+
+const FREE_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+
+uniform sampler2D uFreePos;     // xyz=pos, w=weight
+uniform sampler2D uFreeVel;     // xyz=vel, w=repelCount
+uniform sampler2D uFreeRewiredA; // 4 rewired neighbor indices into uPoolPos
+uniform sampler2D uFreeRewiredB; // 4 more
+uniform sampler2D uPoolPos;     // combined pool (grid cells mirrored + free nodes)
+
+uniform float uDt;
+uniform float uDims;
+uniform vec2 uPoolTexSize;
+
+layout(location = 0) out vec4 outPos;
+layout(location = 1) out vec4 outVel;
+
+vec4 fetchPoolByIndex(float idx) {
+  if (idx < -0.5) return vec4(0.0);
+  float w = uPoolTexSize.x;
+  float x = mod(idx, w);
+  float y = floor(idx / w);
+  return texelFetch(uPoolPos, ivec2(int(x), int(y)), 0);
+}
+
+void springTerm(inout vec3 force, vec3 pos, float weight, vec4 otherData) {
+  if (otherData.w < 0.5) return;
+  vec3 delta = otherData.xyz - pos;
+  float dist = max(length(delta), 1e-4);
+  float edgeWeight = (weight + otherData.w) * 0.5;
+  force += delta * (${REWIRED_SPRING_K.toFixed(4)} * edgeWeight * (dist - 1.0) / dist);
+}
+
+void main() {
+  ivec2 texel = ivec2(gl_FragCoord.xy);
+  vec4 posData = texelFetch(uFreePos, texel, 0);
+  float weight = posData.w;
+  if (weight < 0.5) {
+    outPos = posData;
+    outVel = texelFetch(uFreeVel, texel, 0);
+    return;
+  }
+  vec3 pos = posData.xyz;
+  vec4 velData = texelFetch(uFreeVel, texel, 0);
+  vec3 vel = velData.xyz;
+  float repelCount = velData.w;
+
+  vec3 force = vec3(0.0);
+  float dimBoost = uDims > 2.5 ? 1.5 : 1.0;
+  force += pos * (repelCount * ${EXPANSION_K.toFixed(4)} * dimBoost);
+
+  vec4 rA = texelFetch(uFreeRewiredA, texel, 0);
+  vec4 rB = texelFetch(uFreeRewiredB, texel, 0);
+  springTerm(force, pos, weight, fetchPoolByIndex(rA.x));
+  springTerm(force, pos, weight, fetchPoolByIndex(rA.y));
+  springTerm(force, pos, weight, fetchPoolByIndex(rA.z));
+  springTerm(force, pos, weight, fetchPoolByIndex(rA.w));
+  springTerm(force, pos, weight, fetchPoolByIndex(rB.x));
+  springTerm(force, pos, weight, fetchPoolByIndex(rB.y));
+  springTerm(force, pos, weight, fetchPoolByIndex(rB.z));
+  springTerm(force, pos, weight, fetchPoolByIndex(rB.w));
+
+  float maxForce = 400.0;
+  float fMag = length(force);
+  if (fMag > maxForce) force *= (maxForce / fMag);
+
+  vec3 newVel = (vel + force * uDt) * ${DAMPING.toFixed(4)};
+  float maxVel = 150.0;
+  float vMag = length(newVel);
+  if (vMag > maxVel) newVel *= (maxVel / vMag);
+
+  vec3 newPos = pos + newVel * uDt;
+  if (!(newPos.x == newPos.x)) newPos = pos;
+  if (!(newPos.y == newPos.y)) newPos = pos;
+  if (!(newPos.z == newPos.z)) newPos = pos;
+
+  outPos = vec4(newPos, weight);
+  outVel = vec4(newVel, repelCount);
+}
+`;
+
+class GPUPhysics {
+  constructor(dims) {
+    this.available = false;
+    this.lastError = null;
+    this.frameCount = 0;
+    this.dims = dims;
+    this.gridCapacityRing = 0;
+    this.poolCapacity = 0;
+    this.freeCapacity = 0;
+    try {
+      let canvas;
+      let usedOffscreen = false;
+      if (typeof OffscreenCanvas !== "undefined") {
+        canvas = new OffscreenCanvas(1, 1);
+        usedOffscreen = true;
+      } else {
+        canvas = document.createElement("canvas");
+      }
+      let gl = canvas.getContext("webgl2");
+      if (!gl && usedOffscreen) {
+        canvas = document.createElement("canvas");
+        usedOffscreen = false;
+        gl = canvas.getContext("webgl2");
+      }
+      if (!gl) {
+        this.lastError = "WebGL2 not supported by this browser/device";
+        return;
+      }
+      this.usedOffscreenCanvas = usedOffscreen;
+      const ext = gl.getExtension("EXT_color_buffer_float");
+      if (!ext) {
+        this.lastError = "EXT_color_buffer_float extension unavailable";
+        return;
+      }
+      this.gl = gl;
+      this.canvas = canvas;
+
+      this.gridProgram = this._buildProgram(gl, GRID_VERTEX_SRC, buildGridFragmentSrc());
+      if (!this.gridProgram) {
+        this.lastError = this.lastError || "grid shader compile/link failed";
+        return;
+      }
+      this.freeProgram = this._buildProgram(gl, GRID_VERTEX_SRC, FREE_FRAGMENT_SRC);
+      if (!this.freeProgram) {
+        this.lastError = this.lastError || "free-node shader compile/link failed";
+        return;
+      }
+
+      const quad = gl.createBuffer();
+      gl.bindBuffer(gl.ARRAY_BUFFER, quad);
+      gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]), gl.STATIC_DRAW);
+      this.quad = quad;
+
+      this.gridUniforms = {};
+      for (const name of ["uGridPos", "uGridVel", "uGridRewired", "uPoolPos", "uScale", "uDt", "uTick", "uDims", "uAtlasW", "uSliceSize", "uGridOffset", "uPoolTexSize"]) {
+        this.gridUniforms[name] = gl.getUniformLocation(this.gridProgram, name);
+      }
+      this.gridAPos = gl.getAttribLocation(this.gridProgram, "aPos");
+
+      this.freeUniforms = {};
+      for (const name of ["uFreePos", "uFreeVel", "uFreeRewiredA", "uFreeRewiredB", "uPoolPos", "uDt", "uDims", "uPoolTexSize"]) {
+        this.freeUniforms[name] = gl.getUniformLocation(this.freeProgram, name);
+      }
+      this.freeAPos = gl.getAttribLocation(this.freeProgram, "aPos");
+
+      this._fbo = gl.createFramebuffer();
+      this.available = true;
+    } catch (e) {
+      this.available = false;
+      this.lastError = "exception during init: " + (e && e.message ? e.message : String(e));
+    }
+  }
+
+  _buildProgram(gl, vsSrc, fsSrc) {
+    const compile = (type, src) => {
+      const sh = gl.createShader(type);
+      gl.shaderSource(sh, src);
+      gl.compileShader(sh);
+      if (!gl.getShaderParameter(sh, gl.COMPILE_STATUS)) {
+        const info = gl.getShaderInfoLog(sh);
+        console.error("GPUPhysics shader compile error:", info);
+        this.lastError = "shader compile error: " + info;
+        gl.deleteShader(sh);
+        return null;
+      }
+      return sh;
+    };
+    const vs = compile(gl.VERTEX_SHADER, vsSrc);
+    const fs = compile(gl.FRAGMENT_SHADER, fsSrc);
+    if (!vs || !fs) return null;
+    const prog = gl.createProgram();
+    gl.attachShader(prog, vs);
+    gl.attachShader(prog, fs);
+    gl.linkProgram(prog);
+    if (!gl.getProgramParameter(prog, gl.LINK_STATUS)) {
+      const info = gl.getProgramInfoLog(prog);
+      console.error("GPUPhysics program link error:", info);
+      this.lastError = "program link error: " + info;
+      return null;
+    }
+    return prog;
+  }
+
+  _makeTexture(gl, w, h) {
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, w, h, 0, gl.RGBA, gl.FLOAT, null);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    return tex;
+  }
+
+  // Grid atlas sized to cover [-ringRadius, ringRadius] in every axis
+  // with headroom, so it doesn't need reallocating every single tick.
+  _ensureGridCapacity(ringRadius, dims) {
+    if (ringRadius <= this.gridCapacityRing && this.sliceSize) return;
+    const gl = this.gl;
+    const ring = ringRadius + GRID_ATLAS_PADDING;
+    this.gridCapacityRing = ring;
+    const sliceSize = 2 * ring + 1;
+    this.sliceSize = sliceSize;
+    this.gridOffset = ring;
+    const atlasW = dims === 3 ? sliceSize * sliceSize : sliceSize;
+    const atlasH = sliceSize;
+    this.atlasW = atlasW;
+    this.atlasH = atlasH;
+
+    for (const key of ["gridPos", "gridPos2", "gridVel", "gridVel2", "gridRewired"]) {
+      const cur = this["_tex_" + key];
+      if (cur) gl.deleteTexture(cur);
+    }
+    this._tex_gridPos = this._makeTexture(gl, atlasW, atlasH);
+    this._tex_gridPos2 = this._makeTexture(gl, atlasW, atlasH);
+    this._tex_gridVel = this._makeTexture(gl, atlasW, atlasH);
+    this._tex_gridVel2 = this._makeTexture(gl, atlasW, atlasH);
+    this._tex_gridRewired = this._makeTexture(gl, atlasW, atlasH);
+
+    this._gridBuf = {
+      pos: new Float32Array(atlasW * atlasH * 4),
+      vel: new Float32Array(atlasW * atlasH * 4),
+      rewired: new Float32Array(atlasW * atlasH * 4),
+      outPos: new Float32Array(atlasW * atlasH * 4),
+      outVel: new Float32Array(atlasW * atlasH * 4),
+    };
+  }
+
+  // Flat pool: mirrors every grid cell's pos/weight (so rewired gathers
+  // — from anyone, grid or free — can reach them) plus every free node.
+  _ensurePoolCapacity(n) {
+    if (n <= this.poolCapacity && this.poolTexW) return;
+    const gl = this.gl;
+    const texW = Math.max(1, Math.ceil(Math.sqrt(n * 1.15)));
+    const texH = Math.max(1, Math.ceil(n / texW) + 1);
+    this.poolTexW = texW;
+    this.poolTexH = texH;
+    this.poolCapacity = texW * texH;
+    if (this._tex_pool) this.gl.deleteTexture(this._tex_pool);
+    this._tex_pool = this._makeTexture(gl, texW, texH);
+    this._poolBuf = new Float32Array(this.poolCapacity * 4);
+  }
+
+  // Free-node flat texture — separate from the pool (which is read-only
+  // gather source for this pass), since free nodes need their own
+  // in/out ping-pong just like grid cells do.
+  _ensureFreeCapacity(n) {
+    if (n <= this.freeCapacity && this.freeTexW) return;
+    const gl = this.gl;
+    const texW = Math.max(1, Math.ceil(Math.sqrt(Math.max(n, 1) * 1.3)));
+    const texH = Math.max(1, Math.ceil(Math.max(n, 1) / texW) + 1);
+    this.freeTexW = texW;
+    this.freeTexH = texH;
+    this.freeCapacity = texW * texH;
+    for (const key of ["freePos", "freePos2", "freeVel", "freeVel2", "freeRewiredA", "freeRewiredB"]) {
+      const cur = this["_tex_" + key];
+      if (cur) gl.deleteTexture(cur);
+    }
+    this._tex_freePos = this._makeTexture(gl, texW, texH);
+    this._tex_freePos2 = this._makeTexture(gl, texW, texH);
+    this._tex_freeVel = this._makeTexture(gl, texW, texH);
+    this._tex_freeVel2 = this._makeTexture(gl, texW, texH);
+    this._tex_freeRewiredA = this._makeTexture(gl, texW, texH);
+    this._tex_freeRewiredB = this._makeTexture(gl, texW, texH);
+    this._freeBuf = {
+      pos: new Float32Array(this.freeCapacity * 4),
+      vel: new Float32Array(this.freeCapacity * 4),
+      rA: new Float32Array(this.freeCapacity * 4),
+      rB: new Float32Array(this.freeCapacity * 4),
+      outPos: new Float32Array(this.freeCapacity * 4),
+      outVel: new Float32Array(this.freeCapacity * 4),
+    };
+  }
+
+  update(sim, dt, dims) {
+    const nodes = sim.nodes;
+    const n = nodes.length;
+    if (n === 0) return true;
+    const __t0 = performance.now();
+    const gl = this.gl;
+
+    const gridNodes = [];
+    const freeNodes = [];
+    for (const node of nodes) {
+      if (node.gridPos) gridNodes.push(node);
+      else freeNodes.push(node);
+    }
+
+    this._ensureGridCapacity(sim.ringRadius || 0, dims);
+    this._ensurePoolCapacity(n);
+    this._ensureFreeCapacity(freeNodes.length);
+
+    const sliceSize = this.sliceSize, offset = this.gridOffset, atlasW = this.atlasW, atlasH = this.atlasH;
+    const gbuf = this._gridBuf;
+    const poolBuf = this._poolBuf;
+    const poolIndex = new Map(); // node -> flat pool index, for rewired-gather encoding
+    let poolCursor = 0;
+
+    const atlasTexelOf = (gridPos) => {
+      const gx = Math.round(gridPos[0]) + offset;
+      const gy = Math.round(gridPos[1]) + offset;
+      if (dims === 3) {
+        const gz = Math.round(gridPos[2] || 0) + offset;
+        return [gx + gz * sliceSize, gy];
+      }
+      return [gx, gy];
+    };
+
+    // Pass 1a: write every grid cell into BOTH the atlas (for mesh
+    // lookups) and the flat pool (for rewired-gather targets from
+    // anyone) — same underlying data, two access patterns.
+    for (const node of gridNodes) {
+      const [ax, ay] = atlasTexelOf(node.gridPos);
+      const off = (ay * atlasW + ax) * 4;
+      gbuf.pos[off] = node.pos[0] || 0;
+      gbuf.pos[off + 1] = node.pos[1] || 0;
+      gbuf.pos[off + 2] = node.pos[2] || 0;
+      gbuf.pos[off + 3] = node.weight;
+      gbuf.vel[off] = node.vel[0] || 0;
+      gbuf.vel[off + 1] = node.vel[1] || 0;
+      gbuf.vel[off + 2] = node.vel[2] || 0;
+      gbuf.vel[off + 3] = 0;
+
+      const pi = poolCursor++;
+      poolIndex.set(node, pi);
+      poolBuf[pi * 4] = node.pos[0] || 0;
+      poolBuf[pi * 4 + 1] = node.pos[1] || 0;
+      poolBuf[pi * 4 + 2] = node.pos[2] || 0;
+      poolBuf[pi * 4 + 3] = node.weight;
+    }
+    for (const node of freeNodes) {
+      const pi = poolCursor++;
+      poolIndex.set(node, pi);
+      poolBuf[pi * 4] = node.pos[0] || 0;
+      poolBuf[pi * 4 + 1] = node.pos[1] || 0;
+      poolBuf[pi * 4 + 2] = node.pos[2] || 0;
+      poolBuf[pi * 4 + 3] = node.weight;
+    }
+
+    // Rewired slots (grid): reset the whole rewired buffer only for
+    // occupied cells' worth of data — simplest correct approach is to
+    // clear indices to -1 across the buffer once, then fill.
+    gbuf.rewired.fill(-1);
+    const gridSlotCursor = new Map();
+    const freeBuf = this._freeBuf;
+    freeBuf.rA.fill(-1);
+    freeBuf.rB.fill(-1);
+    const freeIndexOf = new Map();
+    for (let i = 0; i < freeNodes.length; i++) freeIndexOf.set(freeNodes[i], i);
+    const freeSlotCursor = new Int8Array(freeNodes.length);
+
+    for (const edge of sim.edges) {
+      if (!edge[2]) continue; // mesh edges are handled by fixed atlas offsets — only rewired links need the gather
+      const a = edge[0], b = edge[1];
+      if (a._dead || b._dead) continue;
+      const pa = poolIndex.get(a), pb = poolIndex.get(b);
+      if (pa === undefined || pb === undefined) continue;
+
+      if (a.gridPos) {
+        const [ax, ay] = atlasTexelOf(a.gridPos);
+        const key = ay * atlasW + ax;
+        const slot = gridSlotCursor.get(key) || 0;
+        if (slot < REWIRED_SLOTS_GRID) {
+          gbuf.rewired[key * 4 + slot] = pb;
+          gridSlotCursor.set(key, slot + 1);
+        }
+      } else {
+        const fi = freeIndexOf.get(a);
+        if (fi !== undefined) {
+          const s = freeSlotCursor[fi]++;
+          if (s < REWIRED_SLOTS_FREE) {
+            const tex = s < 4 ? freeBuf.rA : freeBuf.rB;
+            tex[fi * 4 + (s % 4)] = pb;
+          }
+        }
+      }
+
+      if (b.gridPos) {
+        const [bx, by] = atlasTexelOf(b.gridPos);
+        const key = by * atlasW + bx;
+        const slot = gridSlotCursor.get(key) || 0;
+        if (slot < REWIRED_SLOTS_GRID) {
+          gbuf.rewired[key * 4 + slot] = pa;
+          gridSlotCursor.set(key, slot + 1);
+        }
+      } else {
+        const fi = freeIndexOf.get(b);
+        if (fi !== undefined) {
+          const s = freeSlotCursor[fi]++;
+          if (s < REWIRED_SLOTS_FREE) {
+            const tex = s < 4 ? freeBuf.rA : freeBuf.rB;
+            tex[fi * 4 + (s % 4)] = pa;
+          }
+        }
+      }
+    }
+
+    for (let i = 0; i < freeNodes.length; i++) {
+      const node = freeNodes[i];
+      freeBuf.pos[i * 4] = node.pos[0] || 0;
+      freeBuf.pos[i * 4 + 1] = node.pos[1] || 0;
+      freeBuf.pos[i * 4 + 2] = node.pos[2] || 0;
+      freeBuf.pos[i * 4 + 3] = node.weight;
+      freeBuf.vel[i * 4] = node.vel[0] || 0;
+      freeBuf.vel[i * 4 + 1] = node.vel[1] || 0;
+      freeBuf.vel[i * 4 + 2] = node.vel[2] || 0;
+      freeBuf.vel[i * 4 + 3] = node.repelCount;
+    }
+
+    const uploadTo = (tex, w, h, data) => {
+      gl.bindTexture(gl.TEXTURE_2D, tex);
+      gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, w, h, gl.RGBA, gl.FLOAT, data);
+    };
+    uploadTo(this._tex_gridPos, atlasW, atlasH, gbuf.pos);
+    uploadTo(this._tex_gridVel, atlasW, atlasH, gbuf.vel);
+    uploadTo(this._tex_gridRewired, atlasW, atlasH, gbuf.rewired);
+    uploadTo(this._tex_pool, this.poolTexW, this.poolTexH, poolBuf);
+    uploadTo(this._tex_freePos, this.freeTexW, this.freeTexH, freeBuf.pos);
+    uploadTo(this._tex_freeVel, this.freeTexW, this.freeTexH, freeBuf.vel);
+    uploadTo(this._tex_freeRewiredA, this.freeTexW, this.freeTexH, freeBuf.rA);
+    uploadTo(this._tex_freeRewiredB, this.freeTexW, this.freeTexH, freeBuf.rB);
+    const __t1 = performance.now();
+
+    // Pass A: grid cells.
+    gl.viewport(0, 0, atlasW, atlasH);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, this._fbo);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._tex_gridPos2, 0);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._tex_gridVel2, 0);
+    gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
+    if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) {
+      this.lastError = "grid framebuffer incomplete (status " + gl.checkFramebufferStatus(gl.FRAMEBUFFER) + ")";
+      return false;
+    }
+    gl.useProgram(this.gridProgram);
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.quad);
+    gl.enableVertexAttribArray(this.gridAPos);
+    gl.vertexAttribPointer(this.gridAPos, 2, gl.FLOAT, false, 0, 0);
+    const bindGrid = (unit, tex, uniform) => {
+      gl.activeTexture(gl.TEXTURE0 + unit);
+      gl.bindTexture(gl.TEXTURE_2D, tex);
+      gl.uniform1i(this.gridUniforms[uniform], unit);
+    };
+    bindGrid(0, this._tex_gridPos, "uGridPos");
+    bindGrid(1, this._tex_gridVel, "uGridVel");
+    bindGrid(2, this._tex_gridRewired, "uGridRewired");
+    bindGrid(3, this._tex_pool, "uPoolPos");
+    gl.uniform1f(this.gridUniforms.uScale, sim.scaleFactor);
+    gl.uniform1f(this.gridUniforms.uDt, dt);
+    gl.uniform1f(this.gridUniforms.uTick, sim.tick % (Math.PI * 2 / 1.6));
+    gl.uniform1f(this.gridUniforms.uDims, dims);
+    gl.uniform1f(this.gridUniforms.uAtlasW, atlasW);
+    gl.uniform1f(this.gridUniforms.uSliceSize, sliceSize);
+    gl.uniform1f(this.gridUniforms.uGridOffset, offset);
+    gl.uniform2f(this.gridUniforms.uPoolTexSize, this.poolTexW, this.poolTexH);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+    // Pass B: free nodes (only if any exist — skip an empty draw call).
+    if (freeNodes.length > 0) {
+      gl.viewport(0, 0, this.freeTexW, this.freeTexH);
+      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._tex_freePos2, 0);
+      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._tex_freeVel2, 0);
+      gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
+      if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) {
+        this.lastError = "free framebuffer incomplete (status " + gl.checkFramebufferStatus(gl.FRAMEBUFFER) + ")";
+        return false;
+      }
+      gl.useProgram(this.freeProgram);
+      gl.bindBuffer(gl.ARRAY_BUFFER, this.quad);
+      gl.enableVertexAttribArray(this.freeAPos);
+      gl.vertexAttribPointer(this.freeAPos, 2, gl.FLOAT, false, 0, 0);
+      const bindFree = (unit, tex, uniform) => {
+        gl.activeTexture(gl.TEXTURE0 + unit);
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.uniform1i(this.freeUniforms[uniform], unit);
+      };
+      bindFree(0, this._tex_freePos, "uFreePos");
+      bindFree(1, this._tex_freeVel, "uFreeVel");
+      bindFree(2, this._tex_freeRewiredA, "uFreeRewiredA");
+      bindFree(3, this._tex_freeRewiredB, "uFreeRewiredB");
+      bindFree(4, this._tex_pool, "uPoolPos");
+      gl.uniform1f(this.freeUniforms.uDt, dt);
+      gl.uniform1f(this.freeUniforms.uDims, dims);
+      gl.uniform2f(this.freeUniforms.uPoolTexSize, this.poolTexW, this.poolTexH);
+      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    }
+    const __t2 = performance.now();
+
+    gl.bindFramebuffer(gl.FRAMEBUFFER, this._fbo);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._tex_gridPos2, 0);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._tex_gridVel2, 0);
+    gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
+    gl.readBuffer(gl.COLOR_ATTACHMENT0);
+    gl.readPixels(0, 0, atlasW, atlasH, gl.RGBA, gl.FLOAT, gbuf.outPos);
+    gl.readBuffer(gl.COLOR_ATTACHMENT1);
+    gl.readPixels(0, 0, atlasW, atlasH, gl.RGBA, gl.FLOAT, gbuf.outVel);
+
+    if (freeNodes.length > 0) {
+      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._tex_freePos2, 0);
+      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._tex_freeVel2, 0);
+      gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
+      gl.readBuffer(gl.COLOR_ATTACHMENT0);
+      gl.readPixels(0, 0, this.freeTexW, this.freeTexH, gl.RGBA, gl.FLOAT, this._freeBuf.outPos);
+      gl.readBuffer(gl.COLOR_ATTACHMENT1);
+      gl.readPixels(0, 0, this.freeTexW, this.freeTexH, gl.RGBA, gl.FLOAT, this._freeBuf.outVel);
+    }
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    const __t3 = performance.now();
+
+    for (const node of gridNodes) {
+      if (node.isCenter) {
+        for (let k = 0; k < dims; k++) node.vel[k] = 0;
+        continue;
+      }
+      const [ax, ay] = atlasTexelOf(node.gridPos);
+      const off = (ay * atlasW + ax) * 4;
+      for (let k = 0; k < dims; k++) {
+        const val = gbuf.outPos[off + k];
+        node.pos[k] = Number.isFinite(val) ? val : node.pos[k];
+      }
+      for (let k = 0; k < dims; k++) {
+        const val = gbuf.outVel[off + k];
+        node.vel[k] = Number.isFinite(val) ? val : 0;
+      }
+    }
+    for (let i = 0; i < freeNodes.length; i++) {
+      const node = freeNodes[i];
+      for (let k = 0; k < dims; k++) {
+        const val = this._freeBuf.outPos[i * 4 + k];
+        node.pos[k] = Number.isFinite(val) ? val : node.pos[k];
+      }
+      for (let k = 0; k < dims; k++) {
+        const val = this._freeBuf.outVel[i * 4 + k];
+        node.vel[k] = Number.isFinite(val) ? val : 0;
+      }
+    }
+
+    this.frameCount++;
+    this.lastTiming = {
+      marshalUpload: __t1 - __t0,
+      drawDispatch: __t2 - __t1,
+      readback: __t3 - __t2,
+      total: performance.now() - __t0,
+    };
+    this.texW = atlasW; // reused by the UI's fragment-count readout
+    this.texH = atlasH;
+    return true;
+  }
+}
+
+function step(sim, dt, dim) {
+  const { nodes, edges } = sim;
+  const n = nodes.length;
+  const dims = nodes[0].pos.length;
+
+  // Deterministic scale factor for anything with a gridPos — exact
+  // self-similar growth (v ∝ r, applied exactly rather than integrated),
+  // so it can't drift, overlap, or destabilize no matter how large the
+  // grid gets. This replaces relying on the force-directed physics below
+  // to determine overall grid scale; that physics remains fully intact
+  // and generic for future non-grid nodes (graph rewrites).
+  sim.scaleFactor *= Math.exp(EXPANSION_RATE * dt);
+  const scale = sim.scaleFactor;
+
+  if (!sim._forces || sim._forces.length !== n) {
+    sim._forces = new Array(n);
+    for (let i = 0; i < n; i++) sim._forces[i] = new Array(dims).fill(0);
+  }
+  const forces = sim._forces;
+  for (let i = 0; i < n; i++) for (let k = 0; k < dims; k++) forces[i][k] = 0;
+
+  if (!sim._index) sim._index = new Map();
+  const index = sim._index;
+  index.clear();
+  for (let i = 0; i < n; i++) index.set(nodes[i], i);
+
+  const delta = new Array(dims);
+
+  // Generic force-directed physics — springs from every edge, including
+  // ones consumption has rewired into long-range connections. Rest length
+  // tracks the current scale factor rather than a fixed constant: grid
+  // spacing itself grows exponentially (scaleFactor), so a fixed rest
+  // length would leave springs permanently fighting to compress a graph
+  // that expansion is simultaneously stretching apart — that fight is
+  // what physics couldn't keep pace with. With rest length tracking
+  // scale, springs and expansion agree on target spacing, and spacing
+  // emerges from the springs themselves rather than needing any position
+  // reset, hard or soft.
+  const restLen = REST_LEN * scale;
+
+  if (sim._gpuPhysics === undefined) {
+    sim._gpuPhysics = new GPUPhysics(dims);
+  }
+  const gpuOk = sim._gpuPhysics.available && sim._gpuPhysics.update(sim, dt, dims);
+
+  if (!gpuOk) {
+    // CPU fallback — identical math to the GPU shader above, used only
+    // if WebGL2 (or a required extension) isn't available in this
+    // environment. Everything downstream (rendering, growth,
+    // consume/annihilate) is agnostic to which path computed the
+    // positions.
+    for (const edge of edges) {
+      const a = edge[0], b = edge[1];
+      const k_spring = edge[2] ? REWIRED_SPRING_K : SPRING_K;
+      const i = index.get(a), j = index.get(b);
+      let distSq = 0;
+      for (let k = 0; k < dims; k++) {
+        delta[k] = b.pos[k] - a.pos[k];
+        distSq += delta[k] * delta[k];
+      }
+      const dist = Math.sqrt(distSq) || 1e-4;
+      const f = (k_spring * (dist - restLen)) / dist;
+      for (let k = 0; k < dims; k++) {
+        const fk = delta[k] * f;
+        forces[i][k] += fk;
+        forces[j][k] -= fk;
+      }
+    }
+
+    const dimBoost = dims === 3 ? 1.5 : 1;
+    for (let i = 0; i < n; i++) {
+      const node = nodes[i];
+      if (node.isCenter || node.gridPos) continue;
+      const f = node.repelCount * EXPANSION_K * dimBoost;
+      for (let k = 0; k < dims; k++) forces[i][k] += node.pos[k] * f;
+    }
+
+    const SHELL_ANCHOR_K = 3.5;
+    for (let i = 0; i < n; i++) {
+      const node = nodes[i];
+      if (node.isCenter || !node.gridPos) continue;
+      const target = sphereTargetPos(node.gridPos, scale);
+      for (let k = 0; k < dims; k++) {
+        forces[i][k] += (target[k] - node.pos[k]) * SHELL_ANCHOR_K;
+      }
+    }
+
+    const WOBBLE_K = restLen * 0.18;
+    const WOBBLE_RATE = 1.6;
+    for (let i = 0; i < n; i++) {
+      const node = nodes[i];
+      if (node.isCenter || !node.gridPos) continue;
+      if (node._wobblePhase === undefined) {
+        let h = 0;
+        for (let k = 0; k < dims; k++) h = (h * 92821 + (node.gridPos[k] | 0) * 2654435761) | 0;
+        node._wobblePhase = ((h >>> 0) / 4294967296) * Math.PI * 2;
+      }
+      for (let k = 0; k < dims; k++) {
+        const axisPhase = node._wobblePhase + k * 2.09;
+        forces[i][k] += Math.sin(sim.tick * WOBBLE_RATE + axisPhase) * WOBBLE_K;
+      }
+    }
+
+    const MAX_FORCE = 400;
+    const MAX_VEL = 150;
+
+    for (let i = 0; i < n; i++) {
+      const node = nodes[i];
+
+      if (node.isCenter) {
+        for (let k = 0; k < dims; k++) node.vel[k] = 0;
+        continue;
+      }
+
+      let fMagSq = 0;
+      for (let k = 0; k < dims; k++) fMagSq += forces[i][k] * forces[i][k];
+      if (fMagSq > MAX_FORCE * MAX_FORCE) {
+        const s = MAX_FORCE / Math.sqrt(fMagSq);
+        for (let k = 0; k < dims; k++) forces[i][k] *= s;
+      }
+
+      let vMagSq = 0;
+      for (let k = 0; k < dims; k++) {
+        node.vel[k] = (node.vel[k] + forces[i][k] * dt) * DAMPING;
+        vMagSq += node.vel[k] * node.vel[k];
+      }
+      if (vMagSq > MAX_VEL * MAX_VEL) {
+        const s = MAX_VEL / Math.sqrt(vMagSq);
+        for (let k = 0; k < dims; k++) node.vel[k] *= s;
+      }
+
+      for (let k = 0; k < dims; k++) {
+        node.pos[k] += node.vel[k] * dt;
+        if (!Number.isFinite(node.pos[k])) node.pos[k] = 0;
+      }
+    }
+  }
+
+  // One synchronized global tick governs everything: grid growth (one new
+  // ring — 3×3 → 5×5 → 7×7, exactly one ring per tick) and every
+  // Repell/Attract boundary in the graph, together. Not independent
+  // timers. On each tick the whole graph is scanned: every un-consumed
+  // edge is checked for annihilation/pair-production/consumption, and
+  // every Repell ray fires. Repell is never spent and never individually
+  // throttled — a boundary keeps expanding on every single global tick,
+  // unconditionally.
+  const __tickT0 = performance.now();
+  if (sim.tick >= (sim.nextGlobalTick || 0)) {
+    sim.nextGlobalTick = sim.tick + GLOBAL_TICK_INTERVAL;
+    sim.globalTickId = (sim.globalTickId || 0) + 1;
+
+    // Snapshot the edge count first — rewireOnto (inside tryConsume/
+    // tryAnnihilate) pushes new edges onto this exact array. Iterating a
+    // live, growing array meant a newly-rewired edge got immediately
+    // reprocessed by this same loop, which could trigger further
+    // consumption on a different node's still-unspent ray, pushing more
+    // edges, reprocessed again — an unbounded same-tick cascade once it
+    // reached a high-weight, high-degree node. Newly-rewired edges now
+    // get their first chance on the NEXT tick instead, same as growShell.
+    const edgeCountAtTickStart = edges.length;
+    for (let ei = 0; ei < edgeCountAtTickStart; ei++) {
+      const [a, b] = edges[ei];
+      if (a._dead || b._dead) continue;
+      if (a.isPhoton && b.isPhoton) {
+        tryPairProduce(sim, a, b);
+        continue;
+      }
+      if (a.isPhoton || b.isPhoton) continue;
+      if (tryAnnihilate(sim, a, b)) continue;
+      tryConsume(sim, a, b);
+      tryConsume(sim, b, a);
+    }
+
+    // Repell-triggered spawning: any grid cell with a Repell-op ray tries
+    // to create a new cell one step further outward, using the exact
+    // same mechanism growShell uses (createGridCell). Most of these
+    // no-op — the target position is already filled by growShell's own
+    // systematic growth — except right at the frontier (genuinely empty)
+    // or over a gap left by consumption (regrows it). That self-limits
+    // the real work to roughly the frontier's surface area without
+    // needing an explicit frontier check. Bounded by n (the tick-start
+    // node count) so newly-created cells this tick aren't immediately
+    // rescanned — same reasoning as the edge-scan snapshot above.
+    if ((sim.gridNodeCount || 0) < MAX_NODES) {
+      for (let i = 0; i < n; i++) {
+        const cell = nodes[i];
+        if (cell._dead || cell.isCenter || !cell.gridPos) continue;
+        for (const ray of cell.rays) {
+          if (ray.boundaries[0].op !== Op.Repell) continue;
+          const outward = ray.direction.map((v) => -v);
+          const targetPos = cell.gridPos.map((v, k) => v + (outward[k] || 0));
+          createGridCell(sim, targetPos, dim);
+        }
+      }
+    }
+
+    if ((sim.gridNodeCount || 0) < MAX_NODES) growShell(sim, dim);
+  }
+  sim._lastTickMs = performance.now() - __tickT0;
+  sweep(sim);
+}
+
+/* ---------------------------------------------------------------------
+ * Projection + drawing
+ * ------------------------------------------------------------------- */
+
+function project(pos, dim, rot, tilt, camDist) {
+  const x = pos[0] || 0, y = pos[1] || 0, z = pos[2] || 0;
+  if (dim === 2) return { x, y, depth: 1, clipped: false };
+  const cosR = Math.cos(rot), sinR = Math.sin(rot);
+  const x1 = x * cosR - z * sinR;
+  const z1 = x * sinR + z * cosR;
+  const cosT = Math.cos(tilt), sinT = Math.sin(tilt);
+  const y1 = y * cosT - z1 * sinT;
+  const z2 = y * sinT + z1 * cosT;
+  // True perspective: camera sits at distance camDist from the origin
+  // along the view axis. Points nearer the camera than that (denom small
+  // or negative) are behind/at the lens and get clipped. Convergence
+  // toward a vanishing point is now the CORRECT result of an actual
+  // camera, not a bug — it's what "moving the camera closer" means.
+  const denom = z2 + camDist;
+  if (denom < camDist * 0.02) return { x: 0, y: 0, depth: 0, clipped: true };
+  const persp = camDist / denom;
+  return { x: x1 * persp, y: y1 * persp, depth: Math.min(Math.max(persp, 0.15), 6), clipped: false };
+}
+
+function draw(ctx, canvas, sim, dim, cam, dt, showGridLines) {
+  const w = canvas.clientWidth, h = canvas.clientHeight;
+
+  ctx.fillStyle = "#06070c";
+  ctx.fillRect(0, 0, w, h);
+  const vg = ctx.createRadialGradient(w / 2, h / 2, 0, w / 2, h / 2, Math.max(w, h) / 1.05);
+  vg.addColorStop(0, "rgba(20,22,34,0)");
+  vg.addColorStop(1, "rgba(0,0,0,0.55)");
+  ctx.fillStyle = vg;
+  ctx.fillRect(0, 0, w, h);
+
+  if (!sim) return;
+
+  // Raw world extent (unprojected) — this is what the base pixel scale
+  // tracks, deliberately independent of camera distance/perspective, so
+  // there's no feedback loop between "how far the camera has dollied" and
+  // "how much of the grid fits on screen". A real camera doesn't refit
+  // its FOV to guarantee everything stays visible as it moves closer.
+  let worldExtent = 1e-6;
+  for (const n of sim.nodes) {
+    const r = Math.hypot(...n.pos);
+    if (r > worldExtent) worldExtent = r;
+  }
+
+  // Scale/distance are always exactly proportional to the grid's current
+  // size — recomputed directly every frame, not smoothed toward a target.
+  // That matters for two reasons: (1) no lerp means nothing ever "chases"
+  // a moving target, which is what read as unwanted drift; (2) being
+  // exactly proportional means the camera can never fall behind the
+  // grid's exponential physical growth, which a genuinely fixed distance
+  // eventually does — that falling-behind is what looked like runaway
+  // automatic zoom-in with no way to scroll back out. The user's zoom
+  // level (scaleMult / distMult) is a stable multiplier riding on top,
+  // changed only by scroll — never reset or overridden automatically.
+  if (dim === 3) {
+    cam.dist = worldExtent * (cam.distMult || 1.5);
+    cam.scale = (Math.min(w, h) * 0.38) / worldExtent;
+  } else {
+    cam.scale = ((Math.min(w, h) * 0.38) / worldExtent) * (cam.scaleMult || 1);
+  }
+
+  // Cursor-anchored pan only applies in 2D — there's no camera distance to
+  // dolly there, so screen-space zoom-toward-cursor is the natural
+  // control. In 3D the camera orbits/dollies toward the origin, which is
+  // the standard convention for an orbit camera.
+  const panX = dim === 2 && cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
+  const panY = dim === 2 && cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
+  const cx = w / 2 + panX, cy = h / 2 + panY;
+
+  const projected = new Map();
+  for (const n of sim.nodes) {
+    projected.set(n, project(n.pos, dim, cam.rot, cam.tilt, cam.dist || 1));
+  }
+
+  const pts = new Map();
+  for (const [n, p] of projected) {
+    pts.set(n, { x: cx + p.x * cam.scale, y: cy + p.y * cam.scale, depth: p.depth, clipped: p.clipped });
+  }
+
+  // Viewport culling: skip the detailed rendering work (ray projection,
+  // shadowBlur, stroke/fill calls) for anything clearly off-screen. Once
+  // zoomed into part of a large structure, most of the population isn't
+  // actually visible — this is what stops paying for it anyway. Margin
+  // is generous (a couple of scale-units of screen space) so a node just
+  // outside the canvas edge doesn't have its still-visible ray tip
+  // prematurely clipped.
+  const cullMargin = cam.scale * 2;
+  const onScreen = (p) => p.x > -cullMargin && p.x < w + cullMargin && p.y > -cullMargin && p.y < h + cullMargin;
+
+  if (showGridLines) {
+    for (const [n, parent] of sim.edges) {
+      const a = pts.get(n), b = pts.get(parent);
+      if (a.clipped || b.clipped) continue;
+      if (!onScreen(a) && !onScreen(b)) continue;
+      const w = Math.max(n.weight, parent.weight);
+      if (w > 1) {
+        const boost = Math.min(w - 1, 6);
+        ctx.strokeStyle = `rgba(199,175,255,${Math.min(0.16 + boost * 0.1, 0.7)})`;
+        ctx.lineWidth = 1 + boost * 0.35;
+      } else {
+        ctx.strokeStyle = "rgba(120,130,160,0.16)";
+        ctx.lineWidth = 1;
+      }
+      ctx.beginPath();
+      ctx.moveTo(a.x, a.y);
+      ctx.lineTo(b.x, b.y);
+      ctx.stroke();
+    }
+  } else {
+    // Gravity flow: a continuous volumetric-style density cloud, not
+    // discrete particles or lines — sampled on a real 3D grid, colored
+    // by a dark→purple→orange→white intensity ramp, and blended
+    // additively so overlapping samples read as one smooth glow rather
+    // than visible individual blobs. Fully world-space: every sample
+    // point is a real 3D coordinate projected through the same camera
+    // pipeline as every node, so it's navigable exactly like the rest of
+    // the scene — rotate, zoom, or move through it and depth/perspective
+    // apply correctly, the same way they do for real structure.
+    const dims3 = sim.nodes[0].pos.length;
+    const sources = [];
+    for (const n of sim.nodes) {
+      if (n.isPhoton) continue;
+      if (isMatter(n)) continue; // both Attract and Repell at the same position/weight always cancel to zero net effect — neutral
+      for (const ray of n.rays) {
+        const op = ray.boundaries[0].op;
+        if (op === Op.Attract) sources.push({ pos: n.pos, sign: 1, w: n.weight });
+        else if (op === Op.Repell) sources.push({ pos: n.pos, sign: -1, w: n.weight });
+      }
+    }
+    const MAX_SOURCES = 220;
+    if (sources.length > MAX_SOURCES) {
+      sources.sort((a, b) => b.w - a.w);
+      sources.length = MAX_SOURCES;
+    }
+
+    if (sources.length > 0) {
+      const SOFTEN_SQ = (0.6 * worldExtent) ** 2 * 0.02 + 0.04;
+      const gridExtent = worldExtent * 1.05;
+      const RES = dims3 === 3 ? 7 : 18;
+      const step = (gridExtent * 2) / RES;
+      // With additive blending, up to RES samples can land at nearly the
+      // same screen position when stacked along the view ray — 2D has no
+      // such stacking (it's a flat plane), which is why 3D was reading
+      // dramatically brighter for the same underlying field strength.
+      const depthStackCompensation = dims3 === 3 ? 1 / (RES * 0.45) : 1;
+
+      // Intensity ramp: true black at low gravity through deep purple and
+      // orange to true white at high gravity — black is less, white is
+      // more.
+      function densityColor(t, alpha) {
+        t = Math.min(Math.max(t, 0), 1);
+        let r, g, b;
+        if (t < 0.4) {
+          const u = t / 0.4;
+          r = u * 60; g = u * 20; b = u * 70;
+        } else if (t < 0.75) {
+          const u = (t - 0.4) / 0.35;
+          r = 60 + u * 195; g = 20 + u * 95; b = 70 - u * 30;
+        } else {
+          const u = (t - 0.75) / 0.25;
+          r = 255; g = 115 + u * 140; b = 40 + u * 215;
+        }
+        return `rgba(${r | 0},${g | 0},${b | 0},${alpha})`;
+      }
+
+      const samples = [];
+      let maxMag = 0;
+      const pos = new Array(dims3);
+      const build = (axis) => {
+        if (axis === dims3) {
+          // Scalar potential, not a vector sum — sum of each source's
+          // weighted influence by magnitude (attract adds, repell
+          // subtracts), never letting opposite directions cancel out
+          // geometrically. A dense, symmetric cluster of attractors
+          // previously could read as near-zero here purely because their
+          // pull directions pointed every which way and summed to
+          // nothing as vectors — physically real for net force, but not
+          // what "concentrated attractors should look bright" means.
+          let potential = 0;
+          for (const src of sources) {
+            let distSq = SOFTEN_SQ;
+            for (let k = 0; k < dims3; k++) distSq += (src.pos[k] - pos[k]) ** 2;
+            potential += (src.w * src.sign) / distSq;
+          }
+          const mag = Math.max(potential, 0); // repell-dominated regions read as black, not negative
+          if (mag > maxMag) maxMag = mag;
+          samples.push({ pos: pos.slice(), mag });
+          return;
+        }
+        for (let i = 0; i < RES; i++) {
+          pos[axis] = -gridExtent + i * step + step / 2;
+          build(axis + 1);
+        }
+      };
+      build(0);
+
+      // Sort far-to-near so nearer glows layer on top — matters even
+      // with additive blending, for depth-based size/alpha falloff to
+      // read correctly.
+      const withDepth = samples.map((s) => {
+        const proj = project(s.pos, dim, cam.rot, cam.tilt, cam.dist || 1);
+        return { s, proj };
+      }).filter((x) => !x.proj.clipped);
+      withDepth.sort((x, y) => y.proj.depth - x.proj.depth);
+
+      const prevComposite = ctx.globalCompositeOperation;
+      ctx.globalCompositeOperation = "lighter";
+      for (const { s, proj } of withDepth) {
+        const x = cx + proj.x * cam.scale, y = cy + proj.y * cam.scale;
+        if (!onScreen({ x, y })) continue;
+        const depthFactor = dim === 3 ? Math.min(Math.max(proj.depth, 0.3), 1.8) : 1;
+        const norm = maxMag > 0 ? Math.min(s.mag / maxMag, 1) : 0;
+        if (norm < 0.015) continue; // relative, not absolute — adapts to whatever scale the field is currently at
+        const radius = (step * cam.scale * 0.9 + norm * cam.scale * 0.5) * depthFactor;
+        if (radius < 1.5) continue;
+        const alpha = Math.min(0.05 + norm * 0.35, 0.4) * Math.min(depthFactor, 1) * depthStackCompensation;
+        const grad = ctx.createRadialGradient(x, y, 0, x, y, radius);
+        grad.addColorStop(0, densityColor(norm, alpha));
+        grad.addColorStop(1, densityColor(norm, 0));
+        ctx.fillStyle = grad;
+        ctx.beginPath();
+        ctx.arc(x, y, radius, 0, Math.PI * 2);
+        ctx.fill();
+      }
+      ctx.globalCompositeOperation = prevComposite;
+    }
+  }
+
+  for (const n of sim.nodes) {
+    const p = pts.get(n);
+    if (p.clipped) continue;
+    if (!onScreen(p)) continue;
+    const depth = dim === 3 ? Math.min(Math.max(p.depth, 0.4), 1.6) : 1;
+
+    if (n.isCenter) {
+      const r = Math.min(Math.max(cam.scale * 0.16 * depth, 0.8), 26);
+      const g = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3);
+      g.addColorStop(0, "rgba(255,217,168,0.9)");
+      g.addColorStop(1, "rgba(255,217,168,0)");
+      ctx.fillStyle = g;
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, r * 3, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.fillStyle = "#FFE9CE";
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, r, 0, Math.PI * 2);
+      ctx.fill();
+      continue;
+    }
+
+    if (n.isPhoton) {
+      const dir = n.rays[0].direction;
+      const tipPos = n.pos.map((v, k) => v + (dir[k] || 0) * 0.5);
+      const tip = project(tipPos, dim, cam.rot, cam.tilt, cam.dist || 1);
+      const tx = cx + tip.x * cam.scale, ty = cy + tip.y * cam.scale;
+      const rayLen = Math.hypot(tx - p.x, ty - p.y);
+      if (!tip.clipped && Number.isFinite(tx) && Number.isFinite(ty) && rayLen < cam.scale * 6) {
+        ctx.strokeStyle = "#FFE9A8";
+        ctx.lineWidth = 2 * depth;
+        ctx.shadowColor = "#FFE9A8";
+        ctx.shadowBlur = Math.min(Math.max(cam.scale * 0.06, 2), 16);
+        ctx.beginPath();
+        ctx.moveTo(p.x, p.y);
+        ctx.lineTo(tx, ty);
+        ctx.stroke();
+        ctx.shadowBlur = 0;
+      }
+      ctx.fillStyle = "#FFF6DC";
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, Math.min(Math.max(cam.scale * 0.07 * depth, 0.6), 11), 0, Math.PI * 2);
+      ctx.fill();
+      continue;
+    }
+
+    // Draw each ray colored by its own op — Repell (amber) vs Attract
+    // (cyan) vs Neutral (not drawn). A node with both an Attract and a
+    // Repell ray gets a bright core, since it can both consume neighbors
+    // and sprout new structure.
+    let hasAttract = false, hasRepell = false;
+    for (const ray of n.rays) {
+      const op = ray.boundaries[0].op;
+      if (op === Op.Attract) hasAttract = true;
+      if (op === Op.Repell) hasRepell = true;
+      if (op === Op.Neutral) continue;
+
+      const dir = op === Op.Repell ? ray.direction.map((v) => -v) : ray.direction;
+      const tipPos = n.pos.map((v, k) => v + (dir[k] || 0) * 0.45);
+      const tip = project(tipPos, dim, cam.rot, cam.tilt, cam.dist || 1);
+      const tx = cx + tip.x * cam.scale, ty = cy + tip.y * cam.scale;
+      const rayLen = Math.hypot(tx - p.x, ty - p.y);
+      // The tip point sits farther from origin than the node itself, so
+      // under true perspective it can cross the near-clip plane (or blow
+      // up near it) even when the node doesn't — skip degenerate tips
+      // rather than draw a stray line to screen-center.
+      if (!(!tip.clipped && Number.isFinite(tx) && Number.isFinite(ty) && rayLen < cam.scale * 6)) continue;
+
+      // A Repell ray on an interior (non-frontier) cell still exists — it
+      // just stopped being "the active boundary". Rendered dim rather
+      // than hidden, so a node's true op composition (e.g. an attractor
+      // that also has a repell ray) is never visually lied about; only
+      // the frontier gets the bright glow.
+      const onFrontierNow = n.gridPos ? isOnFrontier(sim, n) : true;
+      const dim_ = op === Op.Repell && !onFrontierNow;
+      const color = op === Op.Repell ? "#FF7A45" : "#3DDCFF";
+      ctx.strokeStyle = dim_ ? "rgba(255,122,69,0.35)" : color;
+      ctx.lineWidth = (dim_ ? 1 : 1.6) * depth;
+      if (!dim_) {
+        ctx.shadowColor = color;
+        ctx.shadowBlur = Math.min(Math.max(cam.scale * 0.045, 1), 9);
+      }
+      ctx.beginPath();
+      ctx.moveTo(p.x, p.y);
+      ctx.lineTo(tx, ty);
+      ctx.stroke();
+      ctx.shadowBlur = 0;
+    }
+
+    const isMatter = hasAttract && hasRepell;
+    const weightBoost = 1 + Math.min(n.weight - 1, 6) * 0.12;
+    ctx.fillStyle = isMatter ? "#EDEFF5" : "#5A5F72";
+    ctx.beginPath();
+    ctx.arc(p.x, p.y, Math.min(Math.max(cam.scale * (isMatter ? 0.075 : 0.05) * depth * weightBoost, 0.5), 16), 0, Math.PI * 2);
+    ctx.fill();
+  }
+}
+
+/* ---------------------------------------------------------------------
+ * Component
+ * ------------------------------------------------------------------- */
+
+export default function ExpandingUniverse() {
+  const canvasRef = useRef(null);
+  const simRef = useRef(null);
+  const camRef = useRef({ scale: 44, rot: 0, tilt: 0.6155, anchor: null, dist: null, distMult: 1.5, scaleMult: 1 });
+  const lastReadoutRef = useRef(0);
+  const gpuFpsTrackRef = useRef({ count: 0, time: 0 });
+  const frameTimeRef = useRef({ step: null, draw: null });
+
+  const [dim, setDim] = useState(2);
+  const [running, setRunning] = useState(true);
+  const [showGridLines, setShowGridLines] = useState(false);
+  const [readout, setReadout] = useState({ tick: "0.0", factor: "1.00", nodes: 0, gridNodes: 0, ring: 1, gpuStatus: "checking...", gpuError: null, gpuTiming: null, frameBreakdown: null });
+
+  const reset = useCallback((d) => {
+    const prevGpu = simRef.current && simRef.current._gpuPhysics;
+    simRef.current = nD_Expanding(d, 3);
+    if (prevGpu) simRef.current._gpuPhysics = prevGpu; // reuse WebGL context/textures across resets
+    camRef.current.rot = d === 3 ? Math.PI / 4 : 0;
+    camRef.current.tilt = 0.6155;
+    camRef.current.anchor = null;
+    camRef.current.distMult = 1.5;
+    camRef.current.scaleMult = 1;
+  }, []);
+
+  useEffect(() => {
+    reset(dim);
+  }, [dim, reset]);
+
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    const ctx = canvas.getContext("2d");
+    let raf;
+    let last = performance.now();
+
+    function resize() {
+      const parent = canvas.parentElement;
+      const w = parent.clientWidth, h = parent.clientHeight;
+      const ratio = window.devicePixelRatio || 1;
+      canvas.width = w * ratio;
+      canvas.height = h * ratio;
+      canvas.style.width = w + "px";
+      canvas.style.height = h + "px";
+      ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
+    }
+    resize();
+    window.addEventListener("resize", resize);
+
+    // Scroll to zoom. 2D: cursor-anchored zoom (screen-space, no depth to
+    // navigate) — modifies cam.scaleMult. 3D: real dolly — scrolling
+    // moves the camera closer/farther along the view axis, driving
+    // genuine perspective rather than a flat scale.
+    function onWheel(e) {
+      e.preventDefault();
+      const factor = Math.exp(-e.deltaY * 0.001);
+      const cam = camRef.current;
+
+      if (dim === 3) {
+        cam.distMult = Math.min(Math.max((cam.distMult || 1.5) / factor, 0.01), 200);
+        return;
+      }
+
+      const rect = canvas.getBoundingClientRect();
+      const rx = e.clientX - rect.left - rect.width / 2;
+      const ry = e.clientY - rect.top - rect.height / 2;
+      const curPanX = cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
+      const curPanY = cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
+      cam.anchor = {
+        worldX: (rx - curPanX) / cam.scale,
+        worldY: (ry - curPanY) / cam.scale,
+        screenX: rx,
+        screenY: ry,
+      };
+      cam.scaleMult = Math.min(Math.max((cam.scaleMult || 1) * factor, 1e-4), 1e4);
+    }
+    canvas.addEventListener("wheel", onWheel, { passive: false });
+
+    // Right-click drag to orbit (3D) — horizontal drag rotates, vertical
+    // drag adjusts tilt. Suppress the browser context menu so right-click
+    // is free to use as a drag button.
+    function onContextMenu(e) {
+      e.preventDefault();
+    }
+    canvas.addEventListener("contextmenu", onContextMenu);
+
+    let dragging = false;
+    let lastX = 0, lastY = 0;
+    function onMouseDown(e) {
+      if (e.button !== 2) return;
+      dragging = true;
+      lastX = e.clientX;
+      lastY = e.clientY;
+    }
+    function onMouseMove(e) {
+      if (!dragging) return;
+      const dx = e.clientX - lastX, dy = e.clientY - lastY;
+      lastX = e.clientX;
+      lastY = e.clientY;
+      const cam = camRef.current;
+      cam.rot += dx * 0.006;
+      cam.tilt = Math.min(Math.max(cam.tilt + dy * 0.006, -1.15), 1.15);
+    }
+    function onMouseUp(e) {
+      if (e.button === 2) dragging = false;
+    }
+    canvas.addEventListener("mousedown", onMouseDown);
+    window.addEventListener("mousemove", onMouseMove);
+    window.addEventListener("mouseup", onMouseUp);
+
+    function frame(now) {
+      const dt = Math.min((now - last) / 1000, 0.05);
+      last = now;
+      const sim = simRef.current;
+
+      const __fStepStart = performance.now();
+      if (sim && running) {
+        step(sim, dt * 1.3, dim);
+        sim.tick += dt;
+      }
+      const __fStepEnd = performance.now();
+      draw(ctx, canvas, sim, dim, camRef.current, dt, showGridLines);
+      const __fDrawEnd = performance.now();
+
+      const stepMs = __fStepEnd - __fStepStart;
+      const drawMs = __fDrawEnd - __fStepEnd;
+      const t = frameTimeRef.current;
+      t.step = t.step === null ? stepMs : t.step * 0.9 + stepMs * 0.1;
+      t.draw = t.draw === null ? drawMs : t.draw * 0.9 + drawMs * 0.1;
+      t.stepRaw = stepMs;
+
+      if (sim && now - lastReadoutRef.current > 200) {
+        lastReadoutRef.current = now;
+        const gpu = sim._gpuPhysics;
+        let gpuStatus, gpuError, gpuTiming = null;
+        if (!gpu) {
+          gpuStatus = "initializing...";
+          gpuError = null;
+        } else if (gpu.available && gpu.frameCount > 0) {
+          const track = gpuFpsTrackRef.current;
+          const dCount = gpu.frameCount - track.count;
+          const dTime = now - track.time;
+          const fps = track.time > 0 && dTime > 0 ? (dCount / dTime) * 1000 : 0;
+          track.count = gpu.frameCount;
+          track.time = now;
+          gpuStatus = "GPU active (" + (track.time > 0 ? fps.toFixed(0) : "…") + " fps, " + (gpu.usedOffscreenCanvas ? "OffscreenCanvas" : "regular canvas") + ")";
+          gpuError = null;
+          if (gpu.lastTiming) {
+            const t = gpu.lastTiming;
+            const fragCount = (gpu.texW || 0) * (gpu.texH || 0);
+            gpuTiming = `upload ${t.marshalUpload.toFixed(1)}ms · dispatch ${t.drawDispatch.toFixed(1)}ms (${fragCount} fragments) · readback ${t.readback.toFixed(1)}ms · total ${t.total.toFixed(1)}ms`;
+          }
+        } else if (gpu.available) {
+          gpuStatus = "GPU ready, not yet run";
+          gpuError = null;
+        } else {
+          gpuStatus = "CPU fallback";
+          gpuError = gpu.lastError;
+        }
+        const stepMs = frameTimeRef.current.step || 0;
+        const drawMs = frameTimeRef.current.draw || 0;
+        const totalMs = stepMs + drawMs;
+        const tickMs = sim._lastTickMs || 0;
+        const stepRawMs = frameTimeRef.current.stepRaw || 0;
+        setReadout({
+          tick: sim.tick.toFixed(1),
+          factor: sim.scaleFactor.toFixed(2),
+          nodes: sim.nodes.length,
+          gridNodes: sim.gridNodeCount || 0,
+          ring: sim.ringRadius,
+          gpuStatus,
+          gpuError,
+          gpuTiming,
+          frameBreakdown: `frame: step ${stepMs.toFixed(1)}ms smoothed / ${stepRawMs.toFixed(1)}ms raw (tick-logic ${tickMs.toFixed(1)}ms) + draw ${drawMs.toFixed(1)}ms = ${totalMs.toFixed(1)}ms (~${totalMs > 0 ? (1000 / totalMs).toFixed(0) : "…"} fps)`,
+        });
+      }
+      raf = requestAnimationFrame(frame);
+    }
+    raf = requestAnimationFrame(frame);
+
+    return () => {
+      cancelAnimationFrame(raf);
+      window.removeEventListener("resize", resize);
+      canvas.removeEventListener("wheel", onWheel);
+      canvas.removeEventListener("contextmenu", onContextMenu);
+      canvas.removeEventListener("mousedown", onMouseDown);
+      window.removeEventListener("mousemove", onMouseMove);
+      window.removeEventListener("mouseup", onMouseUp);
+    };
+  }, [dim, running, showGridLines]);
+
+  const pillStyle = (active) => ({
+    padding: "6px 14px",
+    borderRadius: 999,
+    fontSize: 12,
+    letterSpacing: 0.5,
+    fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+    border: `1px solid ${active ? "#FF7A45" : "rgba(255,255,255,0.15)"}`,
+    background: active ? "rgba(255,122,69,0.14)" : "rgba(255,255,255,0.03)",
+    color: active ? "#FFD9A8" : "#9BA0B3",
+    cursor: "pointer",
+  });
+
+  return (
+    <div
+      style={{
+        position: "relative",
+        width: "100%",
+        height: "100%",
+        minHeight: 560,
+        background: "#06070c",
+        borderRadius: 16,
+        overflow: "hidden",
+        fontFamily: "Inter, system-ui, sans-serif",
+      }}
+    >
+      <div style={{ position: "absolute", inset: 0 }}>
+        <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%", cursor: "grab" }} />
+      </div>
+
+      <div style={{ position: "absolute", top: 16, left: 16, display: "flex", gap: 8 }}>
+        {[2, 3].map((d) => (
+          <button key={d} onClick={() => setDim(d)} style={pillStyle(dim === d)}>
+            {d}D
+          </button>
+        ))}
+        <button onClick={() => reset(dim)} style={pillStyle(false)}>
+          reset
+        </button>
+        <button onClick={() => setRunning((r) => !r)} style={pillStyle(false)}>
+          {running ? "pause" : "resume"}
+        </button>
+        <button onClick={() => setShowGridLines((v) => !v)} style={pillStyle(showGridLines)}>
+          {showGridLines ? "grid lines" : "gravity flow"}
+        </button>
+        <span
+          title={readout.gpuError || ""}
+          style={{
+            alignSelf: "center",
+            display: "flex",
+            alignItems: "center",
+            gap: 6,
+            padding: "5px 10px",
+            borderRadius: 999,
+            fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+            fontSize: 10,
+            border: "1px solid rgba(255,255,255,0.12)",
+            background: "rgba(255,255,255,0.03)",
+            color: readout.gpuStatus && readout.gpuStatus.startsWith("GPU active") ? "#8BF0A8" : "#E0B15A",
+            cursor: readout.gpuError ? "help" : "default",
+          }}
+        >
+          <span
+            style={{
+              width: 7,
+              height: 7,
+              borderRadius: 999,
+              background: readout.gpuStatus && readout.gpuStatus.startsWith("GPU active") ? "#4ADE80" : readout.gpuStatus === "initializing..." ? "#5A5F72" : "#E0B15A",
+              boxShadow: readout.gpuStatus && readout.gpuStatus.startsWith("GPU active") ? "0 0 6px #4ADE80" : "none",
+            }}
+          />
+          {readout.gpuStatus}
+          {readout.gpuError ? " (hover for reason)" : ""}
+        </span>
+        <span
+          style={{
+            alignSelf: "center",
+            fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+            fontSize: 10,
+            color: "#4A4E5A",
+            marginLeft: 4,
+          }}
+        >
+          scroll to zoom · right-drag to orbit
+        </span>
+      </div>
+
+      <div
+        style={{
+          position: "absolute",
+          top: 16,
+          right: 16,
+          display: "flex",
+          gap: 12,
+          alignItems: "center",
+          fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+          fontSize: 10,
+          color: "#5A5F72",
+        }}
+      >
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FF7A45", boxShadow: "0 0 6px #FF7A45" }} />
+          repell
+        </span>
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#3DDCFF", boxShadow: "0 0 6px #3DDCFF" }} />
+          attract
+        </span>
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#EDEFF5", boxShadow: "0 0 6px #EDEFF5" }} />
+          matter
+        </span>
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#5A5F72" }} />
+          spark
+        </span>
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FFE9A8", boxShadow: "0 0 10px #FFE9A8" }} />
+          photon
+        </span>
+        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
+          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FFE9CE", boxShadow: "0 0 10px #FFE9CE" }} />
+          seed
+        </span>
+      </div>
+
+      <div
+        style={{
+          position: "absolute",
+          bottom: 14,
+          right: 16,
+          textAlign: "right",
+          fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+          fontSize: 11,
+          color: "#7B8093",
+          lineHeight: 1.7,
+        }}
+      >
+        <div>t = {readout.tick}</div>
+        <div>a(t) = {readout.factor}</div>
+        <div>
+          grid = {readout.gridNodes} · total = {readout.nodes} · ring = {readout.ring}
+        </div>
+        {readout.frameBreakdown && <div>{readout.frameBreakdown}</div>}
+        {readout.gpuTiming && <div style={{ color: "#4A4E5A" }}>{readout.gpuTiming}</div>}
+        <div style={{ color: "#4A4E5A" }}>
+          random repell/attract/neutral per ray · matter annihilates → photons → pair-produces back
+        </div>
+      </div>
+    </div>
+  );
+}
\ No newline at end of file
diff --git a/orbitmines.com/src/routes/references.tsx b/orbitmines.com/src/routes/references.tsx
index 1e29252..8305d5e 100644
--- a/orbitmines.com/src/routes/references.tsx
+++ b/orbitmines.com/src/routes/references.tsx
@@ -208,3 +208,20 @@ export const ETHERS_ALMANAC: Content & { UPDATES: Content[] } = { reference: {
 
 }
 
+export const RAY_CALCULI_AND_PHYSICS: Content = { reference: {
+  title: "2026 Notes on Ray Calculi & Physics",
+  subtitle: "An initial look at a Ray Calculus for programs and physics.",
+  draft: true,
+  date: "2026-12-31",
+  year: "2026",
+  external: {
+    discord: {serverId: '1055502602365845534', channelId: '1463219913044005018', link: () => "https://discord.com/channels/1055502602365845534/1463219913044005018/1463219913044005018"}
+  },
+  organizations: [ORGANIZATIONS.orbitmines_research],
+  authors: [{
+    ...PROFILES.fadi_shawki,
+    external: PROFILES.fadi_shawki.external?.filter((profile) => PLATFORMS.includes(profile.organization.key))
+  }],
+  published: [ORGANIZATIONS.orbitmines_research],
+  link: "https://orbitmines.com/archive/ray-calculi-and-physics"
+}, status: Viewed.VIEWED, found_at: "2026", viewed_at: "December, 2026", }

From 8ee5bc4764c52dba773299fab780dc2b475259f1 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Mon, 3 Aug 2026 00:13:23 +0200
Subject: [PATCH 03/47] Attempt 1 XOR Space

---
 .../archive/2026.RayCalculiAndPhysics.tsx     | 563 ++++++++----------
 orbitmines.com/tsconfig.tsbuildinfo           |   1 +
 2 files changed, 262 insertions(+), 302 deletions(-)
 create mode 100644 orbitmines.com/tsconfig.tsbuildinfo

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index d37a27d..71c80f2 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -17,10 +17,10 @@ import Post, {
 import { useEffect, useRef, useState } from "react";
 import { Button } from "@blueprintjs/core";
 
-enum Op {
-  Repell,
-  Attract,
-  Neutral
+// A boundary now carries a polarity instead of an annihilation/creation op.
+enum Polarity {
+  Positive,
+  Negative
 }
 
 class Universe {
@@ -33,11 +33,8 @@ class Universe {
     return arr[Math.floor(Math.random() * arr.length)];
   }
 
-  static randomOp() {
-    const r = Math.random();
-    if (r < 0.4) return Op.Repell;
-    if (r < 0.7) return Op.Attract;
-    return Op.Neutral;
+  static randomPolarity() {
+    return Math.random() < 0.5 ? Polarity.Positive : Polarity.Negative;
   }
 }
 
@@ -56,14 +53,13 @@ class Graph {
 
   gridPos = new Map<node, number[]>();
 
-  // Lattice dimensionality and the current outermost Chebyshev ring — the
-  // repell dynamic walks this outward one shell per tick.
+  // Lattice dimensionality and the seed's initial radius (used only by the
+  // cube→sphere layout morph now).
   dims = 3;
   ringRadius = 0;
 
-  // Transient per-tick state used by the repell expansion (Boundary.repell).
+  // Monotonic tick counter.
   _tickId = 0;
-  _tickIndex?: Map<string, node>;
 
   get edges(): [node, node][] {
     const seen = new Set<string>();
@@ -106,38 +102,166 @@ class Graph {
         boundary.target = target;
   }
 
+  // A ray "turns around" to one of its OTHER boundaries (superposed — one
+  // chosen at random for now). Returns the current one if there's nothing
+  // else to turn to.
+  private otherBoundary(ray: Ray, exclude: Boundary): Boundary {
+    const others = ray.boundaries.filter(b => b !== exclude);
+    if (!others.length) return exclude;
+    return others[Math.floor(Math.random() * others.length)];
+  }
+
+  // Annihilate a single connection (the mutual boundaries a↔b) and MERGE the
+  // two nodes into one, keeping every other connection (spatial direction) of
+  // both. Only this one link is destroyed. The `removed` set records nodes
+  // that were merged away so the tick loop skips them.
+  private mergeConnection(rA: Ray, a: Boundary, rB: Ray, b: Boundary, removed: Set<node>) {
+    const A = rA.node, B = rB.node;
+
+    // Destroy just this connection.
+    rA.boundaries = rA.boundaries.filter(x => x !== a);
+    rB.boundaries = rB.boundaries.filter(x => x !== b);
+    if (rA.moving === a) rA.moving = rA.boundaries.length ? rA.boundaries[Math.floor(Math.random() * rA.boundaries.length)] : undefined;
+    if (rB.moving === b) rB.moving = rB.boundaries.length ? rB.boundaries[Math.floor(Math.random() * rB.boundaries.length)] : undefined;
+
+    if (A === B) return; // already the same node — the connection was internal
+
+    // Merge B's rays into A (every remaining boundary comes along; their
+    // targets still point at the same Boundary objects, now reachable via A).
+    for (const ray of B) {
+      ray.node = A;
+      A.push(ray);
+    }
+
+    this.gridPos.delete(B);
+    this.nodes = this.nodes.filter(n => n !== B);
+    removed.add(B);
+  }
+
   tick() {
-    // One tick fires every boundary once. Repeller boundaries push their
-    // node outward (Boundary.repell), so the frontier grows the next shell.
-    // The boundary list is snapshotted first, so cells created this tick
-    // aren't fired until the next one — exactly one shell per tick.
     this._tickId++;
 
-    const byCoord = new Map<string, node>();
-    for (const nd of this.nodes) {
-      const g = this.gridPos.get(nd);
-      if (g) byCoord.set(g.join(","), nd);
+    // Every node is evaluated, but each acts on only its single `moving`
+    // direction. Snapshot the rays first so structural changes (merges,
+    // new points) don't disturb iteration.
+    const rays: Ray[] = [];
+    for (const node of this.nodes)
+      for (const ray of node)
+        rays.push(ray);
+
+    const removed = new Set<node>();
+
+    for (const r of rays) {
+      if (removed.has(r.node)) continue;
+
+      const a = r.moving;              // the single direction this ray executes
+      if (!a) continue;
+
+      const b = a.target;              // the boundary it is moving towards
+      if (!b) continue;
+
+      const r2 = b.at;                 // the ray on the far side
+      if (removed.has(r2.node)) continue;
+      if (r.node === r2.node) continue; // already merged into one node
+
+      // Is the far side moving back towards us along this same connection?
+      const mutual = r2.moving === b && b.target === a;
+
+      if (mutual) {
+        if (a.polarity !== b.polarity) {
+          // Opposite polarities head-on → annihilate this connection and
+          // merge the two nodes (keeping their other spatial directions).
+          this.mergeConnection(r, a, r2, b, removed);
+        } else {
+          // Same polarity head-on → both turn around to (superposed) their
+          // other boundaries.
+          r.moving = this.otherBoundary(r, a);
+          r2.moving = this.otherBoundary(r2, b);
+        }
+      } else {
+        // One-sided: r is moving into b's node, but b isn't pointing back.
+        // Take the spatial structure of the node we're moving towards and
+        // place it on ourselves.
+        const from = this.gridPos.get(r2.node);
+        if (from) {
+          // TODO: decide what to do with my OWN previous spatial structure —
+          // for now it is simply overwritten by the one we moved into.
+          this.gridPos.set(r.node, from.slice());
+        }
+      }
     }
-    this._tickIndex = byCoord;
 
-    const buffer: Boundary[] = [];
+    // Space creation: a same-polarity connection whose two nodes are BOTH
+    // moving away from it (neither's single direction is this connection)
+    // sprouts a new spatial point in between.
+    const seen = new Set<Boundary>();
+    const toCreate: [Boundary, Boundary][] = [];
     for (const node of this.nodes) {
+      if (removed.has(node)) continue;
       for (const ray of node) {
-        buffer.push(...ray.boundaries);
+        for (const a of ray.boundaries) {
+          const b = a.target;
+          if (!b || seen.has(a) || seen.has(b)) continue;
+          seen.add(a); seen.add(b);
+          if (a.polarity !== b.polarity) continue;          // must be same polarity
+          const rA = a.at, rB = b.at;
+          if (!rA.moving || !rB.moving) continue;           // both must be moving
+          if (rA.moving === a || rB.moving === b) continue; // and moving AWAY, not into
+          toCreate.push([a, b]);
+        }
       }
     }
+    for (const [a, b] of toCreate) this.createSpaceBetween(a, b);
 
-    for (const boundary of buffer) {
-      boundary.tick();
-    }
-
-    this._tickIndex = undefined;
-    this.ringRadius += 1;
     this.invalidateLayout();
   }
 
-  static expandingGrid(dims: number, size = 3): Graph {
+  // Insert a fresh spatial point X between the nodes connected by a↔b, so
+  // A—X—B. X sits at their midpoint, with two boundaries (facing A and B) of
+  // random polarity, and a random movement direction.
+  private createSpaceBetween(a: Boundary, b: Boundary) {
+    const A = a.at.node, B = b.at.node;
+    const pA = this.gridPos.get(A), pB = this.gridPos.get(B);
+    if (!pA || !pB) return;
+    const mid = pA.map((v, i) => (v + pB[i]) / 2);
+
+    const x: node = [];
+    const rx = new Ray(x, this);
+    rx.boundaries = []; // drop the constructor's default
+
+    const xa = new Boundary(rx, this); // faces A
+    xa.polarity = Universe.randomPolarity();
+    xa.target = a;
+
+    const xb = new Boundary(rx, this); // faces B
+    xb.polarity = Universe.randomPolarity();
+    xb.target = b;
+
+    rx.boundaries.push(xa, xb);
+
+    // Splice X into the connection: A—X—B.
+    a.target = xa;
+    b.target = xb;
+
+    // Random initial movement direction.
+    rx.moving = Universe.random(rx.boundaries);
+
+    this.nodes.push(x);
+    this.gridPos.set(x, mid);
+  }
+
+  /**
+   * Seed an initial "expanding universe": a small connected patch of nodes,
+   * each a single ray with one boundary per orthogonal neighbour. Every
+   * boundary gets a random polarity, and every ray a random `moving`
+   * direction (one of its boundaries). From there the tick rules —
+   * annihilation (opposite polarities meeting head-on), turn-around (like
+   * polarities meeting head-on), and structure-absorption (one-sided
+   * approach) — drive the evolution.
+   */
+  static expandingGrid(dims: number, size = 10): Graph {
     const graph = new Graph();
+    graph.dims = dims;
     const center = Math.floor(size / 2);
 
     const coords: number[][] = [];
@@ -152,77 +276,64 @@ class Graph {
 
     const byCoord = new Map<string, node>();
     const coordOf = new Map<node, number[]>();
-
     const key = (c: number[]) => c.join(",");
 
-    // Create nodes.
+    // One node per cell — each is a single ray with no boundaries yet.
     for (const idx of coords) {
       const coord = idx.map(v => v - center);
-      const isCenter = coord.every(v => v === 0);
-
       const node: node = [];
-
-      if (isCenter) {
-        const ray = new Ray(node, graph);
-        ray.boundaries[0].repeller();
-      } else {
-        // Seed condition: one inward-pointing repeller per inward direction
-        // (one per non-zero coordinate axis), so a corner repels along ALL
-        // its axes — 3 in 3D, 2 in 2D, etc. — not just a fixed two. Ops
-        // only diverge from this later (as the graph grows), not on frame one.
-        const inwardDirs = coord.filter(v => v !== 0).length;
-        for (let i = 0; i < inwardDirs; i++) {
-          const ray = new Ray(node, graph);
-          ray.boundaries[0].repeller();
-        }
-      }
+      const ray = new Ray(node, graph);
+      ray.boundaries = []; // drop the constructor's default boundary
 
       graph.nodes.push(node);
-
-      // remember where this lattice cell belongs
       graph.gridPos.set(node, coord);
-
       byCoord.set(key(coord), node);
       coordOf.set(node, coord);
     }
 
-    // Semantic lattice links.
-    // Every node connects to its orthogonal neighbours.
-    // Boundary.target is the source of truth for Graph.edges.
+    // One boundary per orthogonal neighbour, each a random polarity. Remember
+    // which boundary of a node faces which neighbour, so the pair can be
+    // wired as mutual targets afterwards.
+    const facing = new Map<node, Map<node, Boundary>>();
     for (const node of graph.nodes) {
       const coord = coordOf.get(node)!;
+      const ray = node[0];
+      const m = new Map<node, Boundary>();
+      facing.set(node, m);
 
       for (let axis = 0; axis < dims; axis++) {
         for (const dir of [-1, 1]) {
-          const neighbourCoord = [...coord];
-          neighbourCoord[axis] += dir;
-
-          const currentDistance =
-            coord.reduce((s, v) => s + Math.abs(v), 0);
-          const neighbourDistance =
-            neighbourCoord.reduce((s, v) => s + Math.abs(v), 0);
-
-          if (neighbourDistance >= currentDistance)
-            continue;
-
-          const neighbour = byCoord.get(key(neighbourCoord));
-
-          if (!neighbour)
-            continue;
-
-          // Need one boundary per connection.
-          const ray = node[0];
-          const boundary = new Boundary(ray, graph);
-
-          boundary.target = neighbour[0].boundaries[0];
-          boundary.repeller();
-
-          ray.boundaries.push(boundary);
+          const nc = coord.slice();
+          nc[axis] += dir;
+          const neighbour = byCoord.get(key(nc));
+          if (!neighbour) continue;
+
+          const b = new Boundary(ray, graph);
+          b.polarity = Universe.randomPolarity();
+          ray.boundaries.push(b);
+          m.set(neighbour, b);
         }
       }
     }
 
-    graph.dims = dims;
+    // Wire mutual targets: this node's boundary facing a neighbour points at
+    // that neighbour's boundary facing back.
+    for (const node of graph.nodes) {
+      const m = facing.get(node)!;
+      for (const [neighbour, b] of m) {
+        const back = facing.get(neighbour)!.get(node);
+        if (back) b.target = back;
+      }
+    }
+
+    // Give every ray an initial movement direction — a random one of its
+    // boundaries.
+    for (const node of graph.nodes) {
+      const ray = node[0];
+      if (ray.boundaries.length)
+        ray.moving = ray.boundaries[Math.floor(Math.random() * ray.boundaries.length)];
+    }
+
     graph.ringRadius = center;
 
     return graph;
@@ -473,8 +584,13 @@ class Ray {
   id: number;
   boundaries: Boundary[] = [];
 
+  // The directional movement of this ray: the boundary (one of its own) it
+  // is currently moving towards. It heads towards the node on the far side
+  // of that boundary's connection (moving.target's node).
+  moving?: Boundary;
+
   constructor(
-    public readonly node: node,
+    public node: node, // reassignable: nodes merge on annihilation
     graph: Graph
   ) {
     this.id = NEXT_ID++;
@@ -485,147 +601,20 @@ class Ray {
       new Boundary(this, graph)
     );
   }
-
-
-  tick() {
-    for (const boundary of this.boundaries)
-      boundary.tick();
-  }
 }
 
 class Boundary {
-  op: Op = Op.Neutral
+  polarity: Polarity = Polarity.Positive;
 
   get source(): Boundary { return Universe.random(this.at.boundaries.filter(x => x !== this)); }
-  target?: Boundary
-
-  constructor(public at: Ray, private readonly graph: Graph) { }
 
-  repeller() { this.op = Op.Repell; }
-  attractor() { this.op = Op.Attract; }
+  // The boundary on the neighbouring node this one connects to / points at.
+  target?: Boundary;
 
-  tick() {
-    switch (this.op) {
-      case Op.Repell:
-        this.repell();
-        break;
-
-      case Op.Attract:
-        this.attract();
-        break;
-    }
-  }
-
-  repell() {
-    const graph = this.graph;
-    const node = this.at.node;
-
-    // A node's repellers act TOGETHER — their products are what make the
-    // diagonals — so the whole node repels once per tick, however many
-    // repeller boundaries it has. (Firing per-boundary would only give the
-    // single-axis directions, i.e. a diamond, not the filled square.)
-    if ((node as any)._repelledTick === graph._tickId) return;
-    (node as any)._repelledTick = graph._tickId;
-
-    const g = graph.gridPos.get(node);
-    const byCoord = graph._tickIndex;
-    if (!g || !byCoord) return;
-
-    const key = (c: number[]) => c.join(",");
-
-    // One outward push direction per repeller (per non-zero axis).
-    const dirs: number[][] = [];
-    for (let axis = 0; axis < g.length; axis++) {
-      if (g[axis] !== 0) {
-        const d = g.map(() => 0);
-        d[axis] = Math.sign(g[axis]);
-        dirs.push(d);
-      }
-    }
-    const k = dirs.length;
-    if (k === 0) return; // the center pushes nowhere
-
-    // The node pushes itself outward to the PRODUCT of all its directions
-    // (the diagonal). The cell it vacates, and the intermediate cells
-    // between (the "left" and "up" of a corner's "left, up, and product"),
-    // become new NEUTRAL space — sitting inward of the node, in the
-    // direction its boundaries face, and keeping the moved node connected to
-    // the lattice. The node itself stays a repeller.
-    const full = g.slice();
-    for (const d of dirs) for (let i = 0; i < full.length; i++) full[i] += d[i];
-    if (byCoord.has(key(full))) return; // boxed in by a cell already there
-
-    const makeNeutral = (pos: number[]) => {
-      const kk = key(pos);
-      if (byCoord.has(kk)) return;
-      const space: node = [];
-      new Ray(space, graph); // neutral — plain space, it doesn't repel
-      graph.nodes.push(space);
-      graph.gridPos.set(space, pos.slice());
-      byCoord.set(kk, space);
-    };
-
-    // Intermediate cells: every PROPER non-empty combination of the outward
-    // directions (all but the full product) — neutral space that keeps the
-    // moved node orthogonally connected.
-    for (let mask = 1; mask < (1 << k) - 1; mask++) {
-      const np = g.slice();
-      for (let b = 0; b < k; b++) {
-        if (mask & (1 << b)) {
-          for (let i = 0; i < np.length; i++) np[i] += dirs[b][i];
-        }
-      }
-      makeNeutral(np);
-    }
-
-    // Move the node out to the product cell; its vacated cell becomes neutral.
-    byCoord.delete(key(g));
-    graph.gridPos.set(node, full);
-    byCoord.set(key(full), node);
-    makeNeutral(g.slice());
-  }
-
-
-  attract() {
-    if (!this.target) return;
-
-    const consumed = this.target.at.node;
-
-
-    //
-    // Remove all boundaries pointing at the consumed node.
-    //
-    for (const node of this.graph.nodes) {
-      for (const ray of node) {
-
-        ray.boundaries =
-          ray.boundaries.filter(
-            b => b.target?.at.node !== consumed
-          );
-
-      }
-    }
-
-
-    //
-    // Remove the consumed spatial node.
-    //
-    this.graph.nodes =
-      this.graph.nodes.filter(
-        n => n !== consumed
-      );
-
-
-    //
-    // This connection has been consumed.
-    //
-    this.target = undefined;
-  }
-
-  annihilate() {
-
-  }
+  constructor(public at: Ray, private readonly graph: Graph) { }
 
+  positive() { this.polarity = Polarity.Positive; }
+  negative() { this.polarity = Polarity.Negative; }
 }
 
 
@@ -682,10 +671,9 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
   const camRef = useRef({ scale: 44, rot: Math.PI / 4, tilt: 0.6155, anchor: null, dist: null, distMult: 1.5, scaleMult: 1 });
 
   const [running, setRunning] = useState(false);
-  // Start as a bare 3×3 seed; the repell dynamic (Graph.tick → each cell's
-  // repellers pushing outward, driven by the frame loop while running) is
-  // what grows it outward one shell at a time.
-  const [graph, setGraph] = useState(() => Graph.expandingGrid(2));
+  // Seed the initial polarity universe; Graph.tick (annihilation /
+  // turn-around / structure-absorption) evolves it while running.
+  const [graph, setGraph] = useState(() => Graph.expandingGrid(3));
 
   // TODO Right click/left click cursor=grab
   useEffect(() => {
@@ -971,28 +959,33 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
       const cullMargin = cam.scale * 2;
       const onScreen = (p) => p.x > -cullMargin && p.x < w + cullMargin && p.y > -cullMargin && p.y < h + cullMargin;
 
-      // Lattice — full, connected edges (each drawn once, from a cell
-      // toward its +axis neighbour), so the mesh stays continuous with no
-      // gaps. The colored boundaries are drawn on top of these edges.
+      // Connections — one faint line per boundary link (deduped), following
+      // the actual graph structure, so merged and newly-created nodes read
+      // correctly wherever they sit.
       ctx.strokeStyle = "rgba(140,150,180,0.3)";
+      ctx.lineWidth = 2.2;
+      const idxOf = new Map<node, number>();
+      graph.nodes.forEach((nd, i) => idxOf.set(nd, i));
+      const drawnEdge = new Set<string>();
       for (const nd of graph.nodes) {
-        const g = graph.gridPos.get(nd);
-        if (!g) continue;
         const a = pts.get(nd);
-        if (!a || a.clipped || !onScreen(a)) continue;
-        const depth = Math.min(Math.max(a.depth, 0.4), 1.6);
-        ctx.lineWidth = 2.2 * depth;
-        for (let axis = 0; axis < g.length; axis++) {
-          const nc = g.slice();
-          nc[axis] += 1;
-          const nb = byCoord.get(keyOf(nc));
-          if (!nb) continue;
-          const b = pts.get(nb);
-          if (!b || b.clipped) continue;
-          ctx.beginPath();
-          ctx.moveTo(a.x, a.y);
-          ctx.lineTo(b.x, b.y);
-          ctx.stroke();
+        if (!a || a.clipped) continue;
+        for (const ray of nd) {
+          for (const bd of ray.boundaries) {
+            const other = bd.target?.at.node;
+            if (!other || other === nd) continue;
+            const ia = idxOf.get(nd)!, ib = idxOf.get(other)!;
+            const ek = ia < ib ? ia + "-" + ib : ib + "-" + ia;
+            if (drawnEdge.has(ek)) continue;
+            drawnEdge.add(ek);
+            const b = pts.get(other);
+            if (!b || b.clipped) continue;
+            if (!onScreen(a) && !onScreen(b)) continue;
+            ctx.beginPath();
+            ctx.moveTo(a.x, a.y);
+            ctx.lineTo(b.x, b.y);
+            ctx.stroke();
+          }
         }
       }
 
@@ -1004,17 +997,12 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
       // the nodes, so it navigates identically.
       const sources: { pos: Vec; sign: number; w: number }[] = [];
       for (const nd of graph.nodes) {
-        let a = false, r = false;
-        for (const ray of nd) {
-          const op = ray.boundaries[0].op;
-          if (op === Op.Attract) a = true;
-          if (op === Op.Repell) r = true;
-        }
-        if (a && r) continue; // both at once cancel to net-neutral matter
+        const mv = nd[0] && nd[0].moving;
+        if (!mv) continue;
         const wpos = layout.get(nd);
         if (!wpos) continue;
-        if (a) sources.push({ pos: wpos, sign: 1, w: 1 });
-        else if (r) sources.push({ pos: wpos, sign: -1, w: 1 });
+        // Positive polarity glows one way, Negative the other.
+        sources.push({ pos: wpos, sign: mv.polarity === Polarity.Positive ? 1 : -1, w: 1 });
       }
       const MAX_SOURCES = 220;
       if (sources.length > MAX_SOURCES) {
@@ -1107,81 +1095,52 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
           continue;
         }
 
-        // Existing orthogonal lattice neighbours, split into inward
-        // (closer to center) and outward. Boundaries are drawn along one of
-        // these REAL edges, so a highlight always overlaps a lattice line
-        // instead of pointing off into empty space.
-        const g = graph.gridPos.get(n);
-        const inwardNs: node[] = [];
-        const outwardNs: node[] = [];
-        if (g) {
-          const cur = g.reduce((s, v) => s + Math.abs(v), 0);
-          for (let axis = 0; axis < g.length; axis++) {
-            for (const dir of [-1, 1]) {
-              const nc = g.slice();
-              nc[axis] += dir;
-              const nb = byCoord.get(keyOf(nc));
-              if (!nb) continue;
-              const md = nc.reduce((s, v) => s + Math.abs(v), 0);
-              if (md < cur) inwardNs.push(nb); else outwardNs.push(nb);
-            }
-          }
-        }
-
-        // One boundary per inward direction: ray i is drawn along inward
-        // edge i (the counts match — a cell has one ray per inward axis), so
-        // a corner shows a boundary on every axis. Each starts exactly at
-        // the node and lies on its lattice edge (no offset), so where a cell
-        // has several they emanate cleanly from the same corner. The op only
-        // sets the colour.
-        const BOUNDARY_FRAC = 0.25;
-        // Round caps so the thick segments fill the shared corner at the
-        // node instead of leaving a square notch between them.
+        // Movement: draw each ray's selected `moving` direction as a thick
+        // segment towards the node it is heading into, coloured by that
+        // boundary's polarity (Positive amber, Negative cyan).
         ctx.lineCap = "round";
-        n.forEach((ray, i) => {
-          const op = ray.boundaries[0].op;
-          if (op === Op.Neutral) return;
-
-          const pool = inwardNs.length ? inwardNs : outwardNs;
-          if (!pool.length) return;
-          const target = pool[i % pool.length];
-          if (!target) return;
-
-          const tp = pts.get(target);
-          if (!tp || tp.clipped) return;
+        for (const ray of n) {
+          const mv = ray.moving;
+          if (!mv || !mv.target) continue;
+          const tp = pts.get(mv.target.at.node);
+          if (!tp || tp.clipped) continue;
 
           const dx = tp.x - p.x, dy = tp.y - p.y;
           const len = Math.hypot(dx, dy);
-          if (len < 1) return;
+          if (len < 1) continue;
           const ux = dx / len, uy = dy / len;
-          const L = len * BOUNDARY_FRAC;
+          const L = len * 0.4;
 
-          ctx.strokeStyle = op === Op.Repell ? "#FF7A45" : "#3DDCFF";
+          ctx.strokeStyle = mv.polarity === Polarity.Positive ? "#FF7A45" : "#3DDCFF";
           ctx.lineWidth = 4 * depth;
           ctx.beginPath();
           ctx.moveTo(p.x, p.y);
           ctx.lineTo(p.x + ux * L, p.y + uy * L);
           ctx.stroke();
-        });
+        }
         ctx.lineCap = "butt";
+
+        // Node dot.
+        ctx.fillStyle = "#EDEFF5";
+        ctx.beginPath();
+        ctx.arc(p.x, p.y, Math.max(1.5, 2.4 * depth), 0, Math.PI * 2);
+        ctx.fill();
       }
     }
 
-    // Grow one full shell every GROW_INTERVAL seconds while running, out to
-    // MAX_RING — this is the dynamic that expands the 3×3×3 seed into a
-    // sphere, one deterministic ring at a time.
-    const GROW_INTERVAL = 0.45;
-    const MAX_RING = 9;
-    let growAccum = 0;
+    // Step the polarity dynamics once every TICK_INTERVAL seconds while
+    // running — annihilation / turn-around / structure-absorption.
+    const TICK_INTERVAL = 0.45;
+    let tickAccum = 0;
 
     function frame(now) {
       const dt = Math.min((now - last) / 1000, 0.05);
       last = now;
 
-      if (running && graph.ringRadius < MAX_RING) {
-        growAccum += dt;
-        while (growAccum >= GROW_INTERVAL && graph.ringRadius < MAX_RING) {
-          growAccum -= GROW_INTERVAL;
+      if (running && graph.nodes.length > 0) {
+        tickAccum += dt;
+        while (tickAccum >= TICK_INTERVAL) {
+          tickAccum -= TICK_INTERVAL;
           graph.tick();
         }
       }
diff --git a/orbitmines.com/tsconfig.tsbuildinfo b/orbitmines.com/tsconfig.tsbuildinfo
new file mode 100644
index 0000000..acd6952
--- /dev/null
+++ b/orbitmines.com/tsconfig.tsbuildinfo
@@ -0,0 +1 @@
+{"fileNames":["./node_modules/typescript/lib/lib.es5.d.ts","./node_modules/typescript/lib/lib.es2015.d.ts","./node_modules/typescript/lib/lib.es2016.d.ts","./node_modules/typescript/lib/lib.es2017.d.ts","./node_modules/typescript/lib/lib.es2018.d.ts","./node_modules/typescript/lib/lib.es2019.d.ts","./node_modules/typescript/lib/lib.es2020.d.ts","./node_modules/typescript/lib/lib.es2021.d.ts","./node_modules/typescript/lib/lib.es2022.d.ts","./node_modules/typescript/lib/lib.es2023.d.ts","./node_modules/typescript/lib/lib.es2024.d.ts","./node_modules/typescript/lib/lib.esnext.d.ts","./node_modules/typescript/lib/lib.dom.d.ts","./node_modules/typescript/lib/lib.dom.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.core.d.ts","./node_modules/typescript/lib/lib.es2015.collection.d.ts","./node_modules/typescript/lib/lib.es2015.generator.d.ts","./node_modules/typescript/lib/lib.es2015.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.promise.d.ts","./node_modules/typescript/lib/lib.es2015.proxy.d.ts","./node_modules/typescript/lib/lib.es2015.reflect.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2016.array.include.d.ts","./node_modules/typescript/lib/lib.es2016.intl.d.ts","./node_modules/typescript/lib/lib.es2017.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2017.date.d.ts","./node_modules/typescript/lib/lib.es2017.object.d.ts","./node_modules/typescript/lib/lib.es2017.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2017.string.d.ts","./node_modules/typescript/lib/lib.es2017.intl.d.ts","./node_modules/typescript/lib/lib.es2017.typedarrays.d.ts","./node_modules/typescript/lib/lib.es2018.asyncgenerator.d.ts","./node_modules/typescript/lib/lib.es2018.asynciterable.d.ts","./node_modules/typescript/lib/lib.es2018.intl.d.ts","./node_modules/typescript/lib/lib.es2018.promise.d.ts","./node_modules/typescript/lib/lib.es2018.regexp.d.ts","./node_modules/typescript/lib/lib.es2019.array.d.ts","./node_modules/typescript/lib/lib.es2019.object.d.ts","./node_modules/typescript/lib/lib.es2019.string.d.ts","./node_modules/typescript/lib/lib.es2019.symbol.d.ts","./node_modules/typescript/lib/lib.es2019.intl.d.ts","./node_modules/typescript/lib/lib.es2020.bigint.d.ts","./node_modules/typescript/lib/lib.es2020.date.d.ts","./node_modules/typescript/lib/lib.es2020.promise.d.ts","./node_modules/typescript/lib/lib.es2020.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2020.string.d.ts","./node_modules/typescript/lib/lib.es2020.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2020.intl.d.ts","./node_modules/typescript/lib/lib.es2020.number.d.ts","./node_modules/typescript/lib/lib.es2021.promise.d.ts","./node_modules/typescript/lib/lib.es2021.string.d.ts","./node_modules/typescript/lib/lib.es2021.weakref.d.ts","./node_modules/typescript/lib/lib.es2021.intl.d.ts","./node_modules/typescript/lib/lib.es2022.array.d.ts","./node_modules/typescript/lib/lib.es2022.error.d.ts","./node_modules/typescript/lib/lib.es2022.intl.d.ts","./node_modules/typescript/lib/lib.es2022.object.d.ts","./node_modules/typescript/lib/lib.es2022.string.d.ts","./node_modules/typescript/lib/lib.es2022.regexp.d.ts","./node_modules/typescript/lib/lib.es2023.array.d.ts","./node_modules/typescript/lib/lib.es2023.collection.d.ts","./node_modules/typescript/lib/lib.es2023.intl.d.ts","./node_modules/typescript/lib/lib.es2024.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2024.collection.d.ts","./node_modules/typescript/lib/lib.es2024.object.d.ts","./node_modules/typescript/lib/lib.es2024.promise.d.ts","./node_modules/typescript/lib/lib.es2024.regexp.d.ts","./node_modules/typescript/lib/lib.es2024.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2024.string.d.ts","./node_modules/typescript/lib/lib.esnext.array.d.ts","./node_modules/typescript/lib/lib.esnext.collection.d.ts","./node_modules/typescript/lib/lib.esnext.intl.d.ts","./node_modules/typescript/lib/lib.esnext.disposable.d.ts","./node_modules/typescript/lib/lib.esnext.promise.d.ts","./node_modules/typescript/lib/lib.esnext.decorators.d.ts","./node_modules/typescript/lib/lib.esnext.iterator.d.ts","./node_modules/typescript/lib/lib.esnext.float16.d.ts","./node_modules/typescript/lib/lib.esnext.error.d.ts","./node_modules/typescript/lib/lib.esnext.sharedmemory.d.ts","./node_modules/typescript/lib/lib.decorators.d.ts","./node_modules/typescript/lib/lib.decorators.legacy.d.ts","./node_modules/@types/react/global.d.ts","./node_modules/csstype/index.d.ts","./node_modules/@types/react/index.d.ts","./node_modules/next/dist/styled-jsx/types/css.d.ts","./node_modules/next/dist/styled-jsx/types/macro.d.ts","./node_modules/next/dist/styled-jsx/types/style.d.ts","./node_modules/next/dist/styled-jsx/types/global.d.ts","./node_modules/next/dist/styled-jsx/types/index.d.ts","./node_modules/next/dist/server/get-page-files.d.ts","./node_modules/@types/node/compatibility/iterators.d.ts","./node_modules/@types/node/globals.typedarray.d.ts","./node_modules/@types/node/buffer.buffer.d.ts","./node_modules/@types/node/globals.d.ts","./node_modules/@types/node/web-globals/abortcontroller.d.ts","./node_modules/@types/node/web-globals/blob.d.ts","./node_modules/@types/node/web-globals/console.d.ts","./node_modules/@types/node/web-globals/crypto.d.ts","./node_modules/@types/node/web-globals/domexception.d.ts","./node_modules/@types/node/web-globals/encoding.d.ts","./node_modules/@types/node/web-globals/events.d.ts","./node_modules/undici-types/utility.d.ts","./node_modules/undici-types/header.d.ts","./node_modules/undici-types/readable.d.ts","./node_modules/undici-types/fetch.d.ts","./node_modules/undici-types/formdata.d.ts","./node_modules/undici-types/connector.d.ts","./node_modules/undici-types/client-stats.d.ts","./node_modules/undici-types/client.d.ts","./node_modules/undici-types/errors.d.ts","./node_modules/undici-types/dispatcher.d.ts","./node_modules/undici-types/global-dispatcher.d.ts","./node_modules/undici-types/global-origin.d.ts","./node_modules/undici-types/pool-stats.d.ts","./node_modules/undici-types/pool.d.ts","./node_modules/undici-types/handlers.d.ts","./node_modules/undici-types/balanced-pool.d.ts","./node_modules/undici-types/round-robin-pool.d.ts","./node_modules/undici-types/h2c-client.d.ts","./node_modules/undici-types/agent.d.ts","./node_modules/undici-types/mock-interceptor.d.ts","./node_modules/undici-types/mock-call-history.d.ts","./node_modules/undici-types/mock-agent.d.ts","./node_modules/undici-types/mock-client.d.ts","./node_modules/undici-types/mock-pool.d.ts","./node_modules/undici-types/snapshot-agent.d.ts","./node_modules/undici-types/mock-errors.d.ts","./node_modules/undici-types/proxy-agent.d.ts","./node_modules/undici-types/env-http-proxy-agent.d.ts","./node_modules/undici-types/retry-handler.d.ts","./node_modules/undici-types/retry-agent.d.ts","./node_modules/undici-types/api.d.ts","./node_modules/undici-types/cache-interceptor.d.ts","./node_modules/undici-types/interceptors.d.ts","./node_modules/undici-types/util.d.ts","./node_modules/undici-types/cookies.d.ts","./node_modules/undici-types/patch.d.ts","./node_modules/undici-types/websocket.d.ts","./node_modules/undici-types/eventsource.d.ts","./node_modules/undici-types/diagnostics-channel.d.ts","./node_modules/undici-types/content-type.d.ts","./node_modules/undici-types/cache.d.ts","./node_modules/undici-types/index.d.ts","./node_modules/@types/node/web-globals/fetch.d.ts","./node_modules/@types/node/web-globals/importmeta.d.ts","./node_modules/@types/node/web-globals/messaging.d.ts","./node_modules/@types/node/web-globals/navigator.d.ts","./node_modules/@types/node/web-globals/performance.d.ts","./node_modules/@types/node/web-globals/storage.d.ts","./node_modules/@types/node/web-globals/streams.d.ts","./node_modules/@types/node/web-globals/timers.d.ts","./node_modules/@types/node/web-globals/url.d.ts","./node_modules/@types/node/assert.d.ts","./node_modules/@types/node/assert/strict.d.ts","./node_modules/@types/node/async_hooks.d.ts","./node_modules/@types/node/buffer.d.ts","./node_modules/@types/node/child_process.d.ts","./node_modules/@types/node/cluster.d.ts","./node_modules/@types/node/console.d.ts","./node_modules/@types/node/constants.d.ts","./node_modules/@types/node/crypto.d.ts","./node_modules/@types/node/dgram.d.ts","./node_modules/@types/node/diagnostics_channel.d.ts","./node_modules/@types/node/dns.d.ts","./node_modules/@types/node/dns/promises.d.ts","./node_modules/@types/node/domain.d.ts","./node_modules/@types/node/events.d.ts","./node_modules/@types/node/fs.d.ts","./node_modules/@types/node/fs/promises.d.ts","./node_modules/@types/node/http.d.ts","./node_modules/@types/node/http2.d.ts","./node_modules/@types/node/https.d.ts","./node_modules/@types/node/inspector.d.ts","./node_modules/@types/node/inspector.generated.d.ts","./node_modules/@types/node/inspector/promises.d.ts","./node_modules/@types/node/module.d.ts","./node_modules/@types/node/net.d.ts","./node_modules/buffer/index.d.ts","./node_modules/@types/node/os.d.ts","./node_modules/@types/node/path.d.ts","./node_modules/@types/node/path/posix.d.ts","./node_modules/@types/node/path/win32.d.ts","./node_modules/@types/node/perf_hooks.d.ts","./node_modules/@types/node/process.d.ts","./node_modules/@types/node/punycode.d.ts","./node_modules/@types/node/querystring.d.ts","./node_modules/@types/node/quic.d.ts","./node_modules/@types/node/readline.d.ts","./node_modules/@types/node/readline/promises.d.ts","./node_modules/@types/node/repl.d.ts","./node_modules/@types/node/sea.d.ts","./node_modules/@types/node/sqlite.d.ts","./node_modules/@types/node/stream.d.ts","./node_modules/@types/node/stream/consumers.d.ts","./node_modules/@types/node/stream/promises.d.ts","./node_modules/@types/node/stream/web.d.ts","./node_modules/@types/node/string_decoder.d.ts","./node_modules/@types/node/test.d.ts","./node_modules/@types/node/test/reporters.d.ts","./node_modules/@types/node/timers.d.ts","./node_modules/@types/node/timers/promises.d.ts","./node_modules/@types/node/tls.d.ts","./node_modules/@types/node/trace_events.d.ts","./node_modules/@types/node/tty.d.ts","./node_modules/@types/node/url.d.ts","./node_modules/@types/node/util.d.ts","./node_modules/@types/node/util/types.d.ts","./node_modules/@types/node/v8.d.ts","./node_modules/@types/node/vm.d.ts","./node_modules/@types/node/wasi.d.ts","./node_modules/@types/node/worker_threads.d.ts","./node_modules/@types/node/zlib.d.ts","./node_modules/@types/node/index.d.ts","./node_modules/@types/react/canary.d.ts","./node_modules/@types/react/experimental.d.ts","./node_modules/@types/react-dom/index.d.ts","./node_modules/@types/react-dom/canary.d.ts","./node_modules/@types/react-dom/experimental.d.ts","./node_modules/next/dist/lib/fallback.d.ts","./node_modules/next/dist/compiled/webpack/webpack.d.ts","./node_modules/next/dist/shared/lib/modern-browserslist-target.d.ts","./node_modules/next/dist/shared/lib/entry-constants.d.ts","./node_modules/next/dist/shared/lib/constants.d.ts","./node_modules/next/dist/lib/bundler.d.ts","./node_modules/next/dist/server/config.d.ts","./node_modules/next/dist/lib/load-custom-routes.d.ts","./node_modules/next/dist/shared/lib/image-config.d.ts","./node_modules/next/dist/build/webpack/plugins/subresource-integrity-plugin.d.ts","./node_modules/next/dist/server/body-streams.d.ts","./node_modules/next/dist/server/request/search-params.d.ts","./node_modules/next/dist/shared/lib/segment-cache/vary-params-decoding.d.ts","./node_modules/next/dist/server/app-render/vary-params.d.ts","./node_modules/next/dist/server/request/params.d.ts","./node_modules/next/dist/server/route-kind.d.ts","./node_modules/next/dist/server/route-definitions/route-definition.d.ts","./node_modules/next/dist/server/route-matches/route-match.d.ts","./node_modules/next/dist/client/components/app-router-headers.d.ts","./node_modules/next/dist/server/lib/cache-control.d.ts","./node_modules/next/dist/shared/lib/app-router-types.d.ts","./node_modules/next/dist/server/lib/cache-handlers/types.d.ts","./node_modules/next/dist/server/use-cache/use-cache-wrapper.d.ts","./node_modules/next/dist/server/resume-data-cache/cache-store.d.ts","./node_modules/next/dist/server/resume-data-cache/resume-data-cache.d.ts","./node_modules/next/dist/lib/constants.d.ts","./node_modules/next/dist/server/render-result.d.ts","./node_modules/next/dist/server/response-cache/types.d.ts","./node_modules/next/dist/server/response-cache/index.d.ts","./node_modules/@types/react/jsx-runtime.d.ts","./node_modules/next/dist/next-devtools/userspace/pages/pages-dev-overlay-setup.d.ts","./node_modules/next/dist/build/static-paths/types.d.ts","./node_modules/next/dist/server/route-definitions/app-page-route-definition.d.ts","./node_modules/next/dist/build/adapter/setup-node-env.external.d.ts","./node_modules/next/dist/server/instrumentation/types.d.ts","./node_modules/next/dist/lib/setup-exception-listeners.d.ts","./node_modules/next/dist/lib/worker.d.ts","./node_modules/next/dist/server/lib/experimental/ppr.d.ts","./node_modules/next/dist/lib/page-types.d.ts","./node_modules/next/dist/build/segment-config/app/app-segment-config.d.ts","./node_modules/next/dist/build/segment-config/pages/pages-segment-config.d.ts","./node_modules/next/dist/build/analysis/get-page-static-info.d.ts","./node_modules/next/dist/build/webpack/loaders/get-module-build-info.d.ts","./node_modules/next/dist/build/webpack/plugins/middleware-plugin.d.ts","./node_modules/next/dist/server/require-hook.d.ts","./node_modules/next/dist/server/node-polyfill-crypto.d.ts","./node_modules/next/dist/server/node-environment-baseline.d.ts","./node_modules/next/dist/server/node-environment-extensions/error-inspect.d.ts","./node_modules/next/dist/server/node-environment-extensions/console-file.d.ts","./node_modules/next/dist/server/node-environment-extensions/console-exit.d.ts","./node_modules/next/dist/server/node-environment-extensions/console-dim.external.d.ts","./node_modules/next/dist/server/node-environment-extensions/unhandled-rejection.external.d.ts","./node_modules/next/dist/server/node-environment-extensions/random.d.ts","./node_modules/next/dist/server/node-environment-extensions/date.d.ts","./node_modules/next/dist/server/node-environment-extensions/web-crypto.d.ts","./node_modules/next/dist/server/node-environment-extensions/node-crypto.d.ts","./node_modules/next/dist/server/node-environment-extensions/fast-set-immediate.external.d.ts","./node_modules/next/dist/server/node-environment.d.ts","./node_modules/next/dist/build/page-extensions-type.d.ts","./node_modules/next/dist/server/route-modules/app-page/module.compiled.d.ts","./node_modules/next/dist/server/route-definitions/app-route-route-definition.d.ts","./node_modules/next/dist/server/lib/i18n-provider.d.ts","./node_modules/next/dist/server/web/next-url.d.ts","./node_modules/next/dist/compiled/@edge-runtime/cookies/index.d.ts","./node_modules/next/dist/server/web/spec-extension/cookies.d.ts","./node_modules/next/dist/server/web/spec-extension/request.d.ts","./node_modules/next/dist/shared/lib/deep-readonly.d.ts","./node_modules/next/dist/server/lib/incremental-cache/index.d.ts","./node_modules/next/dist/shared/lib/router/utils/middleware-route-matcher.d.ts","./node_modules/next/dist/build/webpack/plugins/flight-manifest-plugin.d.ts","./node_modules/next/dist/build/webpack/plugins/next-font-manifest-plugin.d.ts","./node_modules/next/dist/server/route-definitions/locale-route-definition.d.ts","./node_modules/next/dist/server/route-definitions/pages-route-definition.d.ts","./node_modules/next/dist/shared/lib/mitt.d.ts","./node_modules/next/dist/client/with-router.d.ts","./node_modules/next/dist/client/router.d.ts","./node_modules/next/dist/client/route-loader.d.ts","./node_modules/next/dist/client/page-loader.d.ts","./node_modules/next/dist/shared/lib/bloom-filter.d.ts","./node_modules/next/dist/shared/lib/router/router.d.ts","./node_modules/next/dist/shared/lib/router-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/loadable-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/loadable.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/image-config-context.shared-runtime.d.ts","./node_modules/next/dist/client/components/readonly-url-search-params.d.ts","./node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.d.ts","./node_modules/next/dist/client/flight-data-helpers.d.ts","./node_modules/next/dist/client/components/segment-cache/cache-key.d.ts","./node_modules/next/dist/client/components/router-reducer/fetch-server-response.d.ts","./node_modules/next/dist/client/components/segment-cache/types.d.ts","./node_modules/next/dist/shared/lib/segment-cache/segment-value-encoding.d.ts","./node_modules/next/dist/client/components/segment-cache/scheduler.d.ts","./node_modules/next/dist/client/components/segment-cache/cache-map.d.ts","./node_modules/next/dist/client/components/segment-cache/vary-path.d.ts","./node_modules/next/dist/client/components/segment-cache/cache.d.ts","./node_modules/next/dist/client/components/router-reducer/ppr-navigations.d.ts","./node_modules/next/dist/client/components/segment-cache/navigation.d.ts","./node_modules/next/dist/client/components/router-reducer/router-reducer-types.d.ts","./node_modules/next/dist/shared/lib/app-router-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/server-inserted-html.shared-runtime.d.ts","./node_modules/next/dist/server/route-modules/pages/vendored/contexts/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/pages/module.compiled.d.ts","./node_modules/next/dist/build/templates/pages.d.ts","./node_modules/next/dist/server/route-modules/pages/module.d.ts","./node_modules/next/dist/server/render.d.ts","./node_modules/next/dist/build/webpack/plugins/pages-manifest-plugin.d.ts","./node_modules/next/dist/server/route-definitions/pages-api-route-definition.d.ts","./node_modules/next/dist/server/route-matches/pages-api-route-match.d.ts","./node_modules/next/dist/server/route-matchers/route-matcher.d.ts","./node_modules/next/dist/server/route-matcher-providers/route-matcher-provider.d.ts","./node_modules/next/dist/server/route-matcher-managers/route-matcher-manager.d.ts","./node_modules/next/dist/server/normalizers/normalizer.d.ts","./node_modules/next/dist/server/normalizers/locale-route-normalizer.d.ts","./node_modules/next/dist/server/normalizers/request/pathname-normalizer.d.ts","./node_modules/next/dist/server/normalizers/request/suffix.d.ts","./node_modules/next/dist/server/normalizers/request/rsc.d.ts","./node_modules/next/dist/server/normalizers/request/next-data.d.ts","./node_modules/next/dist/server/after/builtin-request-context.d.ts","./node_modules/next/dist/server/normalizers/request/segment-prefix-rsc.d.ts","./node_modules/next/dist/server/route-modules/pages/builtin/_error.d.ts","./node_modules/next/dist/server/load-default-error-components.d.ts","./node_modules/next/dist/server/base-server.d.ts","./node_modules/next/dist/server/after/after.d.ts","./node_modules/next/dist/server/after/after-context.d.ts","./node_modules/next/dist/server/use-cache/cache-life.d.ts","./node_modules/next/dist/server/app-render/work-async-storage-instance.d.ts","./node_modules/next/dist/server/lib/lazy-result.d.ts","./node_modules/next/dist/server/app-render/create-error-handler.d.ts","./node_modules/next/dist/shared/lib/action-revalidation-kind.d.ts","./node_modules/next/dist/server/app-render/work-async-storage.external.d.ts","./node_modules/next/dist/server/async-storage/work-store.d.ts","./node_modules/next/dist/server/web/http.d.ts","./node_modules/next/dist/client/components/hooks-server-context.d.ts","./node_modules/next/dist/server/route-modules/app-route/shared-modules.d.ts","./node_modules/next/dist/client/components/redirect-status-code.d.ts","./node_modules/next/dist/client/components/redirect-error.d.ts","./node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.d.ts","./node_modules/next/dist/server/async-storage/draft-mode-provider.d.ts","./node_modules/next/dist/server/web/spec-extension/adapters/headers.d.ts","./node_modules/next/dist/server/app-render/cache-signal.d.ts","./node_modules/next/dist/server/app-render/instant-validation/boundary-tracking.d.ts","./node_modules/next/dist/server/app-render/instant-validation/instant-validation-error.d.ts","./node_modules/next/dist/shared/lib/router/utils/parse-relative-url.d.ts","./node_modules/next/dist/server/app-render/instant-validation/instant-samples.d.ts","./node_modules/next/dist/server/app-render/dynamic-rendering.d.ts","./node_modules/next/dist/server/app-render/work-unit-async-storage-instance.d.ts","./node_modules/next/dist/server/lib/implicit-tags.d.ts","./node_modules/next/dist/server/app-render/staged-rendering.d.ts","./node_modules/next/dist/server/app-render/work-unit-async-storage.external.d.ts","./node_modules/next/dist/build/templates/app-route.d.ts","./node_modules/next/dist/server/app-render/action-async-storage-instance.d.ts","./node_modules/next/dist/server/app-render/action-async-storage.external.d.ts","./node_modules/next/dist/server/route-modules/app-route/module.d.ts","./node_modules/next/dist/server/route-modules/app-route/module.compiled.d.ts","./node_modules/next/dist/build/segment-config/app/app-segments.d.ts","./node_modules/next/dist/build/get-supported-browsers.d.ts","./node_modules/next/dist/build/utils.d.ts","./node_modules/next/dist/build/rendering-mode.d.ts","./node_modules/next/dist/server/lib/router-utils/build-prefetch-segment-data-route.d.ts","./node_modules/next/dist/server/lib/cpu-profile.d.ts","./node_modules/next/dist/build/turborepo-access-trace/types.d.ts","./node_modules/next/dist/build/turborepo-access-trace/result.d.ts","./node_modules/next/dist/build/turborepo-access-trace/helpers.d.ts","./node_modules/next/dist/build/turborepo-access-trace/index.d.ts","./node_modules/next/dist/export/routes/types.d.ts","./node_modules/next/dist/export/types.d.ts","./node_modules/next/dist/export/worker.d.ts","./node_modules/next/dist/build/worker.d.ts","./node_modules/next/dist/build/index.d.ts","./node_modules/next/dist/lib/coalesced-function.d.ts","./node_modules/next/dist/server/lib/router-utils/types.d.ts","./node_modules/next/dist/trace/types.d.ts","./node_modules/next/dist/trace/trace.d.ts","./node_modules/next/dist/trace/shared.d.ts","./node_modules/next/dist/trace/index.d.ts","./node_modules/next/dist/build/load-jsconfig.d.ts","./node_modules/@next/env/dist/index.d.ts","./node_modules/next/dist/build/webpack/plugins/telemetry-plugin/use-cache-tracker-utils.d.ts","./node_modules/next/dist/build/webpack/plugins/telemetry-plugin/telemetry-plugin.d.ts","./node_modules/next/dist/telemetry/storage.d.ts","./node_modules/next/dist/build/build-context.d.ts","./node_modules/next/dist/build/webpack-config.d.ts","./node_modules/next/dist/build/swc/generated-native.d.ts","./node_modules/next/dist/build/define-env.d.ts","./node_modules/next/dist/build/swc/index.d.ts","./node_modules/next/dist/build/swc/types.d.ts","./node_modules/next/dist/server/dev/parse-version-info.d.ts","./node_modules/next/dist/next-devtools/shared/types.d.ts","./node_modules/next/dist/server/dev/dev-indicator-server-state.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/cache-indicator.d.ts","./node_modules/next/dist/server/lib/parse-stack.d.ts","./node_modules/next/dist/next-devtools/server/shared.d.ts","./node_modules/next/dist/next-devtools/shared/stack-frame.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/utils/get-error-by-type.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/container/runtime-error/render-error.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/shared.d.ts","./node_modules/next/dist/server/dev/debug-channel.d.ts","./node_modules/next/dist/server/dev/hot-reloader-types.d.ts","./node_modules/next/dist/server/web/spec-extension/fetch-event.d.ts","./node_modules/next/dist/server/web/spec-extension/response.d.ts","./node_modules/next/dist/build/segment-config/middleware/middleware-config.d.ts","./node_modules/next/dist/server/web/types.d.ts","./node_modules/next/dist/shared/lib/router/utils/parse-url.d.ts","./node_modules/next/dist/server/base-http/node.d.ts","./node_modules/next/dist/server/lib/async-callback-set.d.ts","./node_modules/next/dist/shared/lib/router/utils/route-regex.d.ts","./node_modules/next/dist/shared/lib/router/utils/route-matcher.d.ts","./node_modules/sharp/lib/index.d.ts","./node_modules/next/dist/server/image-optimizer.d.ts","./node_modules/next/dist/server/next-server.d.ts","./node_modules/next/dist/server/lib/types.d.ts","./node_modules/next/dist/server/lib/lru-cache.d.ts","./node_modules/next/dist/server/lib/dev-bundler-service.d.ts","./node_modules/next/dist/server/dev/static-paths-worker.d.ts","./node_modules/next/dist/server/dev/next-dev-server.d.ts","./node_modules/next/dist/server/next.d.ts","./node_modules/next/dist/server/lib/render-server.d.ts","./node_modules/next/dist/server/lib/router-server.d.ts","./node_modules/next/dist/shared/lib/router/utils/path-match.d.ts","./node_modules/next/dist/server/lib/router-utils/filesystem.d.ts","./node_modules/next/dist/server/lib/router-utils/setup-dev-bundler.d.ts","./node_modules/next/dist/server/lib/router-utils/router-server-context.d.ts","./node_modules/next/dist/server/route-modules/route-module.d.ts","./node_modules/next/dist/server/load-components.d.ts","./node_modules/next/dist/server/web/adapter.d.ts","./node_modules/next/dist/server/app-render/types.d.ts","./node_modules/next/dist/build/webpack/loaders/metadata/types.d.ts","./node_modules/next/dist/build/webpack/loaders/next-app-loader/index.d.ts","./node_modules/next/dist/server/lib/app-dir-module.d.ts","./node_modules/next/dist/server/app-render/app-render.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/contexts/entrypoints.d.ts","./node_modules/next/dist/client/components/error-boundary.d.ts","./node_modules/next/dist/client/components/layout-router.d.ts","./node_modules/next/dist/client/components/render-from-template-context.d.ts","./node_modules/next/dist/client/components/client-page.d.ts","./node_modules/next/dist/client/components/client-segment.d.ts","./node_modules/next/dist/client/components/http-access-fallback/error-boundary.d.ts","./node_modules/next/dist/lib/metadata/types/alternative-urls-types.d.ts","./node_modules/next/dist/lib/metadata/types/extra-types.d.ts","./node_modules/next/dist/lib/metadata/types/metadata-types.d.ts","./node_modules/next/dist/lib/metadata/types/manifest-types.d.ts","./node_modules/next/dist/lib/metadata/types/opengraph-types.d.ts","./node_modules/next/dist/lib/metadata/types/twitter-types.d.ts","./node_modules/next/dist/lib/metadata/types/metadata-interface.d.ts","./node_modules/next/dist/lib/metadata/types/resolvers.d.ts","./node_modules/next/dist/lib/metadata/types/icons.d.ts","./node_modules/next/dist/lib/metadata/resolve-metadata.d.ts","./node_modules/next/dist/lib/metadata/metadata.d.ts","./node_modules/next/dist/lib/framework/boundary-components.d.ts","./node_modules/next/dist/server/app-render/rsc/preloads.d.ts","./node_modules/next/dist/server/app-render/rsc/postpone.d.ts","./node_modules/next/dist/server/app-render/rsc/taint.d.ts","./node_modules/next/dist/server/app-render/collect-segment-data.d.ts","./node_modules/next/dist/server/app-render/instant-validation/instant-validation.d.ts","./node_modules/next/dist/next-devtools/userspace/app/segment-explorer-node.d.ts","./node_modules/next/dist/server/app-render/entry-base.d.ts","./node_modules/next/dist/build/templates/app-page.d.ts","./node_modules/next/dist/server/route-modules/app-page/helpers/prerender-manifest-matcher.d.ts","./node_modules/@types/react/jsx-dev-runtime.d.ts","./node_modules/@types/react/compiler-runtime.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/rsc/entrypoints.d.ts","./node_modules/@types/react-dom/client.d.ts","./node_modules/@types/react-dom/static.d.ts","./node_modules/@types/react-dom/server.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/ssr/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/app-page/module.d.ts","./node_modules/next/dist/server/request/fallback-params.d.ts","./node_modules/next/dist/server/web/spec-extension/image-response.d.ts","./node_modules/next/dist/server/web/spec-extension/user-agent.d.ts","./node_modules/next/dist/server/web/spec-extension/url-pattern.d.ts","./node_modules/next/dist/server/after/index.d.ts","./node_modules/next/dist/server/request/connection.d.ts","./node_modules/next/dist/server/web/exports/index.d.ts","./node_modules/next/dist/server/request-meta.d.ts","./node_modules/next/dist/cli/next-test.d.ts","./node_modules/next/dist/shared/lib/size-limit.d.ts","./node_modules/next/dist/server/config-shared.d.ts","./node_modules/next/dist/server/base-http/index.d.ts","./node_modules/next/dist/server/api-utils/index.d.ts","./node_modules/next/dist/build/adapter/build-complete.d.ts","./node_modules/next/dist/types.d.ts","./node_modules/next/dist/shared/lib/html-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/utils.d.ts","./node_modules/next/dist/pages/_app.d.ts","./node_modules/next/app.d.ts","./node_modules/next/dist/server/web/spec-extension/unstable-cache.d.ts","./node_modules/next/dist/server/web/spec-extension/revalidate.d.ts","./node_modules/next/dist/server/web/spec-extension/unstable-no-store.d.ts","./node_modules/next/dist/server/use-cache/cache-tag.d.ts","./node_modules/next/cache.d.ts","./node_modules/next/dist/pages/_document.d.ts","./node_modules/next/document.d.ts","./node_modules/next/dist/shared/lib/dynamic.d.ts","./node_modules/next/dynamic.d.ts","./node_modules/next/dist/pages/_error.d.ts","./node_modules/next/dist/client/components/catch-error.d.ts","./node_modules/next/dist/api/error.d.ts","./node_modules/next/error.d.ts","./node_modules/next/dist/shared/lib/head.d.ts","./node_modules/next/head.d.ts","./node_modules/next/dist/server/request/cookies.d.ts","./node_modules/next/dist/server/request/headers.d.ts","./node_modules/next/dist/server/request/draft-mode.d.ts","./node_modules/next/headers.d.ts","./node_modules/next/dist/shared/lib/get-img-props.d.ts","./node_modules/next/dist/client/image-component.d.ts","./node_modules/next/dist/shared/lib/image-external.d.ts","./node_modules/next/image.d.ts","./node_modules/next/dist/client/link.d.ts","./node_modules/next/link.d.ts","./node_modules/next/dist/client/components/unrecognized-action-error.d.ts","./node_modules/next/dist/client/components/redirect.d.ts","./node_modules/next/dist/client/components/not-found.d.ts","./node_modules/next/dist/client/components/forbidden.d.ts","./node_modules/next/dist/client/components/unauthorized.d.ts","./node_modules/next/dist/client/components/unstable-rethrow.server.d.ts","./node_modules/next/dist/client/components/unstable-rethrow.d.ts","./node_modules/next/dist/client/components/navigation.react-server.d.ts","./node_modules/next/dist/client/components/navigation.d.ts","./node_modules/next/navigation.d.ts","./node_modules/next/router.d.ts","./node_modules/next/dist/client/script.d.ts","./node_modules/next/script.d.ts","./node_modules/next/dist/compiled/@edge-runtime/primitives/url.d.ts","./node_modules/next/dist/compiled/@vercel/og/satori/index.d.ts","./node_modules/next/dist/compiled/@vercel/og/types.d.ts","./node_modules/next/server.d.ts","./node_modules/next/types/global.d.ts","./node_modules/next/types/compiled.d.ts","./node_modules/next/types.d.ts","./node_modules/next/index.d.ts","./.next/dev/types/routes.d.ts","./next-env.d.ts","./src/modules.d.ts","./src/@ether/UI/delay.ts","./src/@ether/UI/host.ts","./src/router/index.tsx","./src/@ether/UI/storage.ts","./node_modules/classnames/index.d.ts","./src/@ether/UI/CRTShell.tsx","./src/@ether/UI/Typewriter.tsx","./src/@ether/UI/Intro.tsx","./src/@ether/UI/MeButton.tsx","./src/@ether/UI/NameInput.tsx","./src/@ether/UI/CommandBar.tsx","./src/@ether/UI/EtherOverlay.tsx","./src/@ether/UI/index.ts","./src/@ether/UI/data/types.ts","./src/@ether/UI/data/EtherAPI.ts","./src/@ether/UI/data/articles.ts","./src/@ether/UI/data/profiles.ts","./src/@ether/UI/data/DummyBackend.ts","./src/@ether/UI/data/index.ts","./src/@ether/UI/icons/Svg.tsx","./src/@ether/UI/icons/FileIcons.tsx","./src/@ether/UI/icons/PRIcons.tsx","./src/@ether/UI/icons/ChatIcons.tsx","./src/@ether/UI/icons/index.ts","./src/@ether/UI/layout/types.ts","./src/@ether/UI/layout/tree.ts","./src/@ether/UI/layout/IDELayout.tsx","./src/@ether/UI/layout/index.ts","./src/@ether/UI/pages/language/types.ts","./src/@ether/UI/pages/language/modules.ts","./src/@ether/UI/pages/language/storage.ts","./src/@ether/UI/pages/language/validation.ts","./src/@ether/UI/pages/library/types.ts","./src/@ether/UI/pages/library/data.ts","./src/@ether/UI/pages/pullrequests/timeAgo.ts","./src/@ether/UI/router/types.ts","./src/@ether/UI/pages/pullrequests/urls.ts","./src/@ether/UI/pages/repository/paths.ts","./src/@ether/UI/pages/repository/icons.tsx","./src/@ether/UI/pages/repository/storage.ts","./src/@ether/UI/pages/repository/profileGroups.ts","./src/@ether/UI/pages/repository/Header.tsx","./src/@ether/UI/pages/repository/repoResolve.ts","./src/@ether/UI/pages/settings/types.ts","./src/@ether/UI/pages/settings/data.ts","./src/@ether/UI/pages/settings/calc.ts","./src/@ether/UI/pages/settings/storage.ts","./src/@ether/UI/router/matchRoute.ts","./src/@ether/UI/util/Markdown.ts","./src/@ether/UI/util/diff.ts","./src/@ether/UI/util/MarkdownView.tsx","./src/@ether/UI/util/DiffView.tsx","./src/@ether/UI/util/index.ts","./node_modules/@types/lodash/common/common.d.ts","./node_modules/@types/lodash/common/array.d.ts","./node_modules/@types/lodash/common/collection.d.ts","./node_modules/@types/lodash/common/date.d.ts","./node_modules/@types/lodash/common/function.d.ts","./node_modules/@types/lodash/common/lang.d.ts","./node_modules/@types/lodash/common/math.d.ts","./node_modules/@types/lodash/common/number.d.ts","./node_modules/@types/lodash/common/object.d.ts","./node_modules/@types/lodash/common/seq.d.ts","./node_modules/@types/lodash/common/string.d.ts","./node_modules/@types/lodash/common/util.d.ts","./node_modules/@types/lodash/index.d.ts","./src/@orbitmines/js/react/IEventListener.tsx","./src/@orbitmines/js/react/hooks/useHovering.ts","./src/lib/blueprintjs/hooks/hotkeys/hotkeyConfig.ts","./src/lib/blueprintjs/Classes.ts","./src/lib/blueprintjs/common.ts","./src/lib/blueprintjs/Icon.tsx","./src/lib/blueprintjs/Button.tsx","./src/lib/blueprintjs/Tag.tsx","./src/lib/blueprintjs/Divider.tsx","./src/lib/blueprintjs/Headings.tsx","./src/lib/blueprintjs/InputGroup.tsx","./src/lib/blueprintjs/Popover.tsx","./src/lib/blueprintjs/HotkeysProvider.tsx","./src/lib/blueprintjs/index.ts","./src/@orbitmines/js/react/hooks/useHotkeys.ts","./src/lib/post/sectionSlug.ts","./src/lib/post/section.ts","./src/lib/organizations/ORGANIZATIONS.ts","./node_modules/html-to-image/lib/types.d.ts","./node_modules/html-to-image/lib/index.d.ts","./src/routes/profiles/fadi-shawki/fadi_shawki.ts","./src/routes/profiles/profiles.ts","./node_modules/@types/prismjs/index.d.ts","./node_modules/prism-react-renderer/dist/index.d.ts","./src/routes/references.tsx","./node_modules/@types/three/src/constants.d.ts","./node_modules/@types/three/src/math/Vector2.d.ts","./node_modules/@types/three/src/math/Matrix3.d.ts","./node_modules/@types/three/src/core/BufferAttribute.d.ts","./node_modules/@types/three/src/core/InterleavedBuffer.d.ts","./node_modules/@types/three/src/core/InterleavedBufferAttribute.d.ts","./node_modules/@types/three/src/math/Quaternion.d.ts","./node_modules/@types/three/src/math/Euler.d.ts","./node_modules/@types/three/src/math/Matrix4.d.ts","./node_modules/@types/three/src/math/Vector4.d.ts","./node_modules/@types/three/src/cameras/Camera.d.ts","./node_modules/@types/three/src/math/ColorManagement.d.ts","./node_modules/@types/three/src/math/Color.d.ts","./node_modules/@types/three/src/math/Cylindrical.d.ts","./node_modules/@types/three/src/math/Spherical.d.ts","./node_modules/@types/three/src/math/Vector3.d.ts","./node_modules/@types/three/src/objects/Bone.d.ts","./node_modules/@types/three/src/math/Interpolant.d.ts","./node_modules/@types/three/src/math/interpolants/BezierInterpolant.d.ts","./node_modules/@types/three/src/math/interpolants/CubicInterpolant.d.ts","./node_modules/@types/three/src/math/interpolants/DiscreteInterpolant.d.ts","./node_modules/@types/three/src/math/interpolants/LinearInterpolant.d.ts","./node_modules/@types/three/src/animation/KeyframeTrack.d.ts","./node_modules/@types/three/src/animation/AnimationClip.d.ts","./node_modules/@types/three/src/extras/core/Curve.d.ts","./node_modules/@types/three/src/extras/core/CurvePath.d.ts","./node_modules/@types/three/src/extras/core/Path.d.ts","./node_modules/@types/three/src/extras/core/Shape.d.ts","./node_modules/@types/three/src/math/Line3.d.ts","./node_modules/@types/three/src/math/Sphere.d.ts","./node_modules/@types/three/src/math/Plane.d.ts","./node_modules/@types/three/src/math/Triangle.d.ts","./node_modules/@types/three/src/math/Box3.d.ts","./node_modules/@types/three/src/renderers/common/StorageBufferAttribute.d.ts","./node_modules/@types/three/src/renderers/common/IndirectStorageBufferAttribute.d.ts","./node_modules/@types/three/src/core/EventDispatcher.d.ts","./node_modules/@types/three/src/core/GLBufferAttribute.d.ts","./node_modules/@types/three/src/core/BufferGeometry.d.ts","./node_modules/@types/three/src/objects/Group.d.ts","./node_modules/@types/three/src/lights/Light.d.ts","./node_modules/@types/three/src/textures/DepthTexture.d.ts","./node_modules/@types/three/src/core/RenderTarget.d.ts","./node_modules/@types/three/src/textures/CompressedTexture.d.ts","./node_modules/@types/three/src/textures/CubeTexture.d.ts","./node_modules/@types/three/src/textures/Source.d.ts","./node_modules/@types/three/src/textures/Texture.d.ts","./node_modules/@types/three/src/scenes/Fog.d.ts","./node_modules/@types/three/src/scenes/FogExp2.d.ts","./node_modules/@types/three/src/scenes/Scene.d.ts","./node_modules/@types/three/src/renderers/shaders/UniformsLib.d.ts","./node_modules/@types/three/src/math/Box2.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLCapabilities.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLExtensions.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLUniforms.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLProgram.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLInfo.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLProperties.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLRenderLists.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLAttributes.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLBindingStates.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLGeometries.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLObjects.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLShadowMap.d.ts","./node_modules/@types/three/src/renderers/WebGLRenderTarget.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLState.d.ts","./node_modules/@types/webxr/index.d.ts","./node_modules/@types/three/src/cameras/PerspectiveCamera.d.ts","./node_modules/@types/three/src/cameras/ArrayCamera.d.ts","./node_modules/@types/three/src/objects/Mesh.d.ts","./node_modules/@webgpu/types/dist/index.d.ts","./node_modules/@types/three/src/textures/ExternalTexture.d.ts","./node_modules/@types/three/src/renderers/webxr/WebXRController.d.ts","./node_modules/@types/three/src/renderers/webxr/WebXRManager.d.ts","./node_modules/@types/three/src/renderers/WebGLRenderer.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLClipping.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLEnvironments.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLLights.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLPrograms.d.ts","./node_modules/@types/three/src/materials/Material.d.ts","./node_modules/@types/three/src/textures/DataTexture.d.ts","./node_modules/@types/three/src/objects/Skeleton.d.ts","./node_modules/@types/three/src/core/Layers.d.ts","./node_modules/@types/three/src/math/Ray.d.ts","./node_modules/@types/three/src/core/Raycaster.d.ts","./node_modules/@types/three/src/core/Object3D.d.ts","./node_modules/@types/three/src/animation/AnimationObjectGroup.d.ts","./node_modules/@types/three/src/animation/PropertyBinding.d.ts","./node_modules/@types/three/src/animation/PropertyMixer.d.ts","./node_modules/@types/three/src/animation/AnimationMixer.d.ts","./node_modules/@types/three/src/animation/AnimationAction.d.ts","./node_modules/@types/three/src/utils.d.ts","./node_modules/@types/three/src/animation/AnimationUtils.d.ts","./node_modules/@types/three/src/animation/tracks/BooleanKeyframeTrack.d.ts","./node_modules/@types/three/src/animation/tracks/ColorKeyframeTrack.d.ts","./node_modules/@types/three/src/animation/tracks/NumberKeyframeTrack.d.ts","./node_modules/@types/three/src/animation/tracks/QuaternionKeyframeTrack.d.ts","./node_modules/@types/three/src/animation/tracks/StringKeyframeTrack.d.ts","./node_modules/@types/three/src/animation/tracks/VectorKeyframeTrack.d.ts","./node_modules/@types/three/src/audio/AudioListener.d.ts","./node_modules/@types/three/src/audio/Audio.d.ts","./node_modules/@types/three/src/audio/AudioAnalyser.d.ts","./node_modules/@types/three/src/audio/AudioContext.d.ts","./node_modules/@types/three/src/audio/PositionalAudio.d.ts","./node_modules/@types/three/src/nodes/core/constants.d.ts","./node_modules/@types/three/src/nodes/core/TempNode.d.ts","./node_modules/@types/three/src/nodes/core/ArrayNode.d.ts","./node_modules/@types/three/src/nodes/core/AssignNode.d.ts","./node_modules/@types/three/src/nodes/core/AttributeNode.d.ts","./node_modules/@types/three/src/nodes/core/BypassNode.d.ts","./node_modules/@types/three/src/nodes/core/InputNode.d.ts","./node_modules/@types/three/src/nodes/core/ConstNode.d.ts","./node_modules/@types/three/src/nodes/core/IndexNode.d.ts","./node_modules/@types/three/src/nodes/core/InspectorNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeCache.d.ts","./node_modules/@types/three/src/nodes/core/IsolateNode.d.ts","./node_modules/@types/three/src/nodes/core/LightingModel.d.ts","./node_modules/@types/three/src/renderers/common/BlendMode.d.ts","./node_modules/@types/three/src/nodes/core/OutputStructNode.d.ts","./node_modules/@types/three/src/nodes/core/MRTNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeAttribute.d.ts","./node_modules/@types/three/src/nodes/core/NodeCode.d.ts","./node_modules/@types/three/src/nodes/core/StackTrace.d.ts","./node_modules/@types/three/src/nodes/core/NodeError.d.ts","./node_modules/@types/three/src/nodes/core/NodeFrame.d.ts","./node_modules/@types/three/src/nodes/core/NodeFunctionInput.d.ts","./node_modules/@types/three/src/nodes/core/UniformGroupNode.d.ts","./node_modules/@types/three/src/math/Matrix2.d.ts","./node_modules/@types/three/src/nodes/core/UniformNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeUniform.d.ts","./node_modules/@types/three/src/nodes/core/NodeVar.d.ts","./node_modules/@types/three/src/nodes/core/NodeVarying.d.ts","./node_modules/@types/three/src/nodes/core/PropertyNode.d.ts","./node_modules/@types/three/src/nodes/core/ParameterNode.d.ts","./node_modules/@types/three/src/nodes/core/StackNode.d.ts","./node_modules/@types/three/src/nodes/core/StructTypeNode.d.ts","./node_modules/@types/three/src/nodes/core/StructNode.d.ts","./node_modules/@types/three/src/nodes/core/SubBuildNode.d.ts","./node_modules/@types/three/src/nodes/core/VarNode.d.ts","./node_modules/@types/three/src/nodes/core/VaryingNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeUtils.d.ts","./node_modules/@types/three/src/objects/BatchedMesh.d.ts","./node_modules/@types/three/src/nodes/accessors/BatchNode.d.ts","./node_modules/@types/three/src/nodes/accessors/BufferAttributeNode.d.ts","./node_modules/@types/three/src/nodes/accessors/BufferNode.d.ts","./node_modules/@types/three/src/nodes/accessors/BuiltinNode.d.ts","./node_modules/@types/three/src/nodes/accessors/ClippingNode.d.ts","./node_modules/@types/three/src/nodes/accessors/TextureNode.d.ts","./node_modules/@types/three/src/nodes/accessors/CubeTextureNode.d.ts","./node_modules/@types/three/src/core/InstancedBufferAttribute.d.ts","./node_modules/@types/three/src/objects/InstancedMesh.d.ts","./node_modules/@types/three/src/core/InstancedInterleavedBuffer.d.ts","./node_modules/@types/three/src/renderers/common/StorageInstancedBufferAttribute.d.ts","./node_modules/@types/three/src/nodes/accessors/InstanceNode.d.ts","./node_modules/@types/three/src/nodes/accessors/InstancedMeshNode.d.ts","./node_modules/@types/three/src/nodes/accessors/MaterialNode.d.ts","./node_modules/@types/three/src/nodes/tsl/TSLCore.d.ts","./node_modules/@types/three/src/nodes/accessors/ReferenceNode.d.ts","./node_modules/@types/three/src/nodes/accessors/MaterialReferenceNode.d.ts","./node_modules/@types/three/src/nodes/accessors/Object3DNode.d.ts","./node_modules/@types/three/src/nodes/accessors/ModelNode.d.ts","./node_modules/@types/three/src/nodes/accessors/MorphNode.d.ts","./node_modules/@types/three/src/nodes/accessors/PointUVNode.d.ts","./node_modules/@types/three/src/nodes/accessors/ReferenceBaseNode.d.ts","./node_modules/@types/three/src/nodes/accessors/RendererReferenceNode.d.ts","./node_modules/@types/three/src/objects/SkinnedMesh.d.ts","./node_modules/@types/three/src/nodes/accessors/SkinningNode.d.ts","./node_modules/@types/three/src/nodes/utils/ArrayElementNode.d.ts","./node_modules/@types/three/src/nodes/utils/StorageArrayElementNode.d.ts","./node_modules/@types/three/src/nodes/accessors/StorageBufferNode.d.ts","./node_modules/@types/three/src/nodes/accessors/StorageTextureNode.d.ts","./node_modules/@types/three/src/nodes/accessors/Texture3DNode.d.ts","./node_modules/@types/three/src/nodes/accessors/TextureSizeNode.d.ts","./node_modules/@types/three/src/nodes/accessors/UniformArrayNode.d.ts","./node_modules/@types/three/src/nodes/accessors/UserDataNode.d.ts","./node_modules/@types/three/src/nodes/accessors/VelocityNode.d.ts","./node_modules/@types/three/src/nodes/accessors/VertexColorNode.d.ts","./node_modules/@types/three/src/nodes/code/CodeNode.d.ts","./node_modules/@types/three/src/nodes/code/ExpressionNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeFunction.d.ts","./node_modules/@types/three/src/nodes/code/FunctionNode.d.ts","./node_modules/@types/three/src/nodes/code/FunctionCallNode.d.ts","./node_modules/@types/three/src/nodes/display/BumpMapNode.d.ts","./node_modules/@types/three/src/nodes/display/ColorSpaceNode.d.ts","./node_modules/@types/three/src/nodes/display/FrontFacingNode.d.ts","./node_modules/@types/three/src/nodes/display/NormalMapNode.d.ts","./node_modules/@types/three/src/nodes/display/PassNode.d.ts","./node_modules/@types/three/src/nodes/display/RenderOutputNode.d.ts","./node_modules/@types/three/src/nodes/display/ScreenNode.d.ts","./node_modules/@types/three/src/nodes/display/ToneMappingNode.d.ts","./node_modules/@types/three/src/nodes/display/ToonOutlinePassNode.d.ts","./node_modules/@types/three/src/nodes/display/ViewportDepthNode.d.ts","./node_modules/@types/three/src/textures/FramebufferTexture.d.ts","./node_modules/@types/three/src/nodes/display/ViewportTextureNode.d.ts","./node_modules/@types/three/src/nodes/display/ViewportDepthTextureNode.d.ts","./node_modules/@types/three/src/nodes/display/ViewportSharedTextureNode.d.ts","./node_modules/@types/three/src/nodes/geometry/RangeNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/AtomicFunctionNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/BarrierNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/ComputeBuiltinNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/ComputeNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/SubgroupFunctionNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/WorkgroupInfoNode.d.ts","./node_modules/@types/three/src/lights/AmbientLight.d.ts","./node_modules/@types/three/src/nodes/lighting/LightingNode.d.ts","./node_modules/@types/three/src/materials/LineBasicMaterial.d.ts","./node_modules/@types/three/src/materials/LineDashedMaterial.d.ts","./node_modules/@types/three/src/materials/MeshBasicMaterial.d.ts","./node_modules/@types/three/src/materials/MeshDepthMaterial.d.ts","./node_modules/@types/three/src/materials/MeshDistanceMaterial.d.ts","./node_modules/@types/three/src/materials/MeshLambertMaterial.d.ts","./node_modules/@types/three/src/materials/MeshMatcapMaterial.d.ts","./node_modules/@types/three/src/materials/MeshNormalMaterial.d.ts","./node_modules/@types/three/src/materials/MeshPhongMaterial.d.ts","./node_modules/@types/three/src/materials/MeshStandardMaterial.d.ts","./node_modules/@types/three/src/materials/MeshPhysicalMaterial.d.ts","./node_modules/@types/three/src/materials/MeshToonMaterial.d.ts","./node_modules/@types/three/src/materials/PointsMaterial.d.ts","./node_modules/@types/three/src/core/Uniform.d.ts","./node_modules/@types/three/src/core/UniformsGroup.d.ts","./node_modules/@types/three/src/materials/ShaderMaterial.d.ts","./node_modules/@types/three/src/materials/RawShaderMaterial.d.ts","./node_modules/@types/three/src/materials/ShadowMaterial.d.ts","./node_modules/@types/three/src/materials/SpriteMaterial.d.ts","./node_modules/@types/three/src/materials/Materials.d.ts","./node_modules/@types/three/src/objects/Sprite.d.ts","./node_modules/@types/three/src/math/Frustum.d.ts","./node_modules/@types/three/src/lights/LightShadow.d.ts","./node_modules/@types/three/src/objects/ClippingGroup.d.ts","./node_modules/@types/three/src/renderers/common/ClippingContext.d.ts","./node_modules/@types/three/src/nodes/lighting/ShadowBaseNode.d.ts","./node_modules/@types/three/src/nodes/lighting/ShadowNode.d.ts","./node_modules/@types/three/src/nodes/lighting/AnalyticLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/AmbientLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/AONode.d.ts","./node_modules/@types/three/src/nodes/lighting/BasicEnvironmentNode.d.ts","./node_modules/@types/three/src/nodes/lighting/BasicLightMapNode.d.ts","./node_modules/@types/three/src/cameras/OrthographicCamera.d.ts","./node_modules/@types/three/src/lights/DirectionalLightShadow.d.ts","./node_modules/@types/three/src/lights/DirectionalLight.d.ts","./node_modules/@types/three/src/nodes/lighting/DirectionalLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/EnvironmentNode.d.ts","./node_modules/@types/three/src/lights/HemisphereLight.d.ts","./node_modules/@types/three/src/nodes/lighting/HemisphereLightNode.d.ts","./node_modules/@types/three/src/lights/SpotLightShadow.d.ts","./node_modules/@types/three/src/lights/SpotLight.d.ts","./node_modules/@types/three/src/nodes/lighting/SpotLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/IESSpotLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/IrradianceNode.d.ts","./node_modules/@types/three/src/nodes/lighting/LightingContextNode.d.ts","./node_modules/@types/three/src/math/SphericalHarmonics3.d.ts","./node_modules/@types/three/src/lights/LightProbe.d.ts","./node_modules/@types/three/src/nodes/lighting/LightProbeNode.d.ts","./node_modules/@types/three/src/lights/PointLightShadow.d.ts","./node_modules/@types/three/src/lights/PointLight.d.ts","./node_modules/@types/three/src/nodes/lighting/PointShadowNode.d.ts","./node_modules/@types/three/src/nodes/lighting/PointLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/ProjectorLightNode.d.ts","./node_modules/@types/three/src/lights/RectAreaLight.d.ts","./node_modules/@types/three/src/nodes/lighting/RectAreaLightNode.d.ts","./node_modules/@types/three/src/nodes/math/BitcastNode.d.ts","./node_modules/@types/three/src/nodes/math/MathNode.d.ts","./node_modules/@types/three/src/nodes/math/BitcountNode.d.ts","./node_modules/@types/three/src/nodes/math/ConditionalNode.d.ts","./node_modules/@types/three/src/nodes/math/OperatorNode.d.ts","./node_modules/@types/three/src/nodes/math/PackFloatNode.d.ts","./node_modules/@types/three/src/nodes/math/UnpackFloatNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeParser.d.ts","./node_modules/@types/three/src/nodes/parsers/GLSLNodeFunction.d.ts","./node_modules/@types/three/src/nodes/parsers/GLSLNodeParser.d.ts","./node_modules/@types/three/src/nodes/pmrem/PMREMNode.d.ts","./node_modules/@types/three/src/nodes/utils/ConvertNode.d.ts","./node_modules/@types/three/src/nodes/utils/CubeMapNode.d.ts","./node_modules/@types/three/src/nodes/utils/DebugNode.d.ts","./node_modules/@types/three/src/nodes/utils/EventNode.d.ts","./node_modules/@types/three/src/nodes/utils/FlipNode.d.ts","./node_modules/@types/three/src/nodes/utils/FunctionOverloadingNode.d.ts","./node_modules/@types/three/src/nodes/utils/JoinNode.d.ts","./node_modules/@types/three/src/nodes/utils/LoopNode.d.ts","./node_modules/@types/three/src/nodes/utils/MaxMipLevelNode.d.ts","./node_modules/@types/three/src/nodes/utils/MemberNode.d.ts","./node_modules/@types/three/src/nodes/utils/ReflectorNode.d.ts","./node_modules/@types/three/src/nodes/utils/RemapNode.d.ts","./node_modules/@types/three/src/nodes/utils/RotateNode.d.ts","./node_modules/@types/three/src/nodes/utils/RTTNode.d.ts","./node_modules/@types/three/src/nodes/utils/SampleNode.d.ts","./node_modules/@types/three/src/nodes/utils/SetNode.d.ts","./node_modules/@types/three/src/nodes/utils/SplitNode.d.ts","./node_modules/@types/three/src/nodes/functions/BasicLightingModel.d.ts","./node_modules/@types/three/src/nodes/functions/PhongLightingModel.d.ts","./node_modules/@types/three/src/nodes/functions/PhysicalLightingModel.d.ts","./node_modules/@types/three/src/nodes/Nodes.d.ts","./node_modules/@types/three/src/nodes/lighting/LightsNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeBuilder.d.ts","./node_modules/@types/three/src/nodes/core/Node.d.ts","./node_modules/@types/three/src/nodes/core/ContextNode.d.ts","./node_modules/@types/three/src/renderers/common/Backend.d.ts","./node_modules/@types/three/src/renderers/common/CanvasTarget.d.ts","./node_modules/@types/three/src/renderers/common/Color4.d.ts","./node_modules/@types/three/src/renderers/common/Info.d.ts","./node_modules/@types/three/src/renderers/common/InspectorBase.d.ts","./node_modules/@types/three/src/renderers/common/Lighting.d.ts","./node_modules/@types/three/src/renderers/common/Binding.d.ts","./node_modules/@types/three/src/renderers/common/BindGroup.d.ts","./node_modules/@types/three/src/renderers/common/BundleGroup.d.ts","./node_modules/@types/three/src/renderers/common/DataMap.d.ts","./node_modules/@types/three/src/renderers/common/Attributes.d.ts","./node_modules/@types/three/src/renderers/common/Constants.d.ts","./node_modules/@types/three/src/renderers/common/Geometries.d.ts","./node_modules/@types/three/src/renderers/common/nodes/NodeBuilderState.d.ts","./node_modules/@types/three/src/renderers/common/ChainMap.d.ts","./node_modules/@types/three/src/renderers/common/Uniform.d.ts","./node_modules/@types/three/src/renderers/common/nodes/NodeUniform.d.ts","./node_modules/@types/three/src/renderers/common/Buffer.d.ts","./node_modules/@types/three/src/renderers/common/UniformBuffer.d.ts","./node_modules/@types/three/src/renderers/common/UniformsGroup.d.ts","./node_modules/@types/three/src/renderers/common/nodes/NodeUniformsGroup.d.ts","./node_modules/@types/three/src/renderers/common/nodes/NodeManager.d.ts","./node_modules/@types/three/src/renderers/common/RenderContext.d.ts","./node_modules/@types/three/src/renderers/common/RenderPipeline.d.ts","./node_modules/@types/three/src/renderers/common/RenderObject.d.ts","./node_modules/@types/three/src/materials/nodes/manager/NodeMaterialObserver.d.ts","./node_modules/@types/three/src/materials/nodes/NodeMaterial.d.ts","./node_modules/@types/three/src/renderers/common/nodes/NodeLibrary.d.ts","./node_modules/@types/three/src/renderers/common/RenderList.d.ts","./node_modules/@types/three/src/geometries/CylinderGeometry.d.ts","./node_modules/@types/three/src/geometries/PlaneGeometry.d.ts","./node_modules/@types/three/src/renderers/common/QuadMesh.d.ts","./node_modules/@types/three/src/renderers/common/XRRenderTarget.d.ts","./node_modules/@types/three/src/renderers/common/XRManager.d.ts","./node_modules/@types/three/src/renderers/common/Renderer.d.ts","./node_modules/@types/three/src/renderers/common/CubeRenderTarget.d.ts","./node_modules/@types/three/src/renderers/WebGLCubeRenderTarget.d.ts","./node_modules/@types/three/src/cameras/CubeCamera.d.ts","./node_modules/@types/three/src/cameras/StereoCamera.d.ts","./node_modules/@types/three/src/core/Clock.d.ts","./node_modules/@types/three/src/core/InstancedBufferGeometry.d.ts","./node_modules/@types/three/src/core/RenderTarget3D.d.ts","./node_modules/@types/three/src/core/Timer.d.ts","./node_modules/@types/three/src/extras/Controls.d.ts","./node_modules/@types/three/src/extras/core/ShapePath.d.ts","./node_modules/@types/three/src/extras/curves/EllipseCurve.d.ts","./node_modules/@types/three/src/extras/curves/ArcCurve.d.ts","./node_modules/@types/three/src/extras/curves/CatmullRomCurve3.d.ts","./node_modules/@types/three/src/extras/curves/CubicBezierCurve.d.ts","./node_modules/@types/three/src/extras/curves/CubicBezierCurve3.d.ts","./node_modules/@types/three/src/extras/curves/LineCurve.d.ts","./node_modules/@types/three/src/extras/curves/LineCurve3.d.ts","./node_modules/@types/three/src/extras/curves/QuadraticBezierCurve.d.ts","./node_modules/@types/three/src/extras/curves/QuadraticBezierCurve3.d.ts","./node_modules/@types/three/src/extras/curves/SplineCurve.d.ts","./node_modules/@types/three/src/extras/curves/Curves.d.ts","./node_modules/@types/three/src/extras/DataUtils.d.ts","./node_modules/@types/three/src/extras/ImageUtils.d.ts","./node_modules/@types/three/src/extras/ShapeUtils.d.ts","./node_modules/@types/three/src/extras/TextureUtils.d.ts","./node_modules/@types/three/src/geometries/BoxGeometry.d.ts","./node_modules/@types/three/src/geometries/CapsuleGeometry.d.ts","./node_modules/@types/three/src/geometries/CircleGeometry.d.ts","./node_modules/@types/three/src/geometries/ConeGeometry.d.ts","./node_modules/@types/three/src/geometries/PolyhedronGeometry.d.ts","./node_modules/@types/three/src/geometries/DodecahedronGeometry.d.ts","./node_modules/@types/three/src/geometries/EdgesGeometry.d.ts","./node_modules/@types/three/src/geometries/ExtrudeGeometry.d.ts","./node_modules/@types/three/src/geometries/IcosahedronGeometry.d.ts","./node_modules/@types/three/src/geometries/LatheGeometry.d.ts","./node_modules/@types/three/src/geometries/OctahedronGeometry.d.ts","./node_modules/@types/three/src/geometries/RingGeometry.d.ts","./node_modules/@types/three/src/geometries/ShapeGeometry.d.ts","./node_modules/@types/three/src/geometries/SphereGeometry.d.ts","./node_modules/@types/three/src/geometries/TetrahedronGeometry.d.ts","./node_modules/@types/three/src/geometries/TorusGeometry.d.ts","./node_modules/@types/three/src/geometries/TorusKnotGeometry.d.ts","./node_modules/@types/three/src/geometries/TubeGeometry.d.ts","./node_modules/@types/three/src/geometries/WireframeGeometry.d.ts","./node_modules/@types/three/src/geometries/Geometries.d.ts","./node_modules/@types/three/src/objects/Line.d.ts","./node_modules/@types/three/src/helpers/ArrowHelper.d.ts","./node_modules/@types/three/src/objects/LineSegments.d.ts","./node_modules/@types/three/src/helpers/AxesHelper.d.ts","./node_modules/@types/three/src/helpers/Box3Helper.d.ts","./node_modules/@types/three/src/helpers/BoxHelper.d.ts","./node_modules/@types/three/src/helpers/CameraHelper.d.ts","./node_modules/@types/three/src/helpers/DirectionalLightHelper.d.ts","./node_modules/@types/three/src/helpers/GridHelper.d.ts","./node_modules/@types/three/src/helpers/HemisphereLightHelper.d.ts","./node_modules/@types/three/src/helpers/PlaneHelper.d.ts","./node_modules/@types/three/src/helpers/PointLightHelper.d.ts","./node_modules/@types/three/src/helpers/PolarGridHelper.d.ts","./node_modules/@types/three/src/helpers/SkeletonHelper.d.ts","./node_modules/@types/three/src/helpers/SpotLightHelper.d.ts","./node_modules/@types/three/src/loaders/LoadingManager.d.ts","./node_modules/@types/three/src/loaders/Loader.d.ts","./node_modules/@types/three/src/loaders/AnimationLoader.d.ts","./node_modules/@types/three/src/loaders/AudioLoader.d.ts","./node_modules/@types/three/src/loaders/BufferGeometryLoader.d.ts","./node_modules/@types/three/src/loaders/Cache.d.ts","./node_modules/@types/three/src/loaders/CompressedTextureLoader.d.ts","./node_modules/@types/three/src/loaders/CubeTextureLoader.d.ts","./node_modules/@types/three/src/loaders/DataTextureLoader.d.ts","./node_modules/@types/three/src/loaders/FileLoader.d.ts","./node_modules/@types/three/src/loaders/ImageBitmapLoader.d.ts","./node_modules/@types/three/src/loaders/ImageLoader.d.ts","./node_modules/@types/three/src/loaders/LoaderUtils.d.ts","./node_modules/@types/three/src/loaders/MaterialLoader.d.ts","./node_modules/@types/three/src/loaders/ObjectLoader.d.ts","./node_modules/@types/three/src/loaders/TextureLoader.d.ts","./node_modules/@types/three/src/math/FrustumArray.d.ts","./node_modules/@types/three/src/math/interpolants/QuaternionLinearInterpolant.d.ts","./node_modules/@types/three/src/math/MathUtils.d.ts","./node_modules/@types/three/src/objects/LineLoop.d.ts","./node_modules/@types/three/src/objects/LOD.d.ts","./node_modules/@types/three/src/objects/Points.d.ts","./node_modules/@types/three/src/textures/Data3DTexture.d.ts","./node_modules/@types/three/src/renderers/WebGL3DRenderTarget.d.ts","./node_modules/@types/three/src/textures/DataArrayTexture.d.ts","./node_modules/@types/three/src/renderers/WebGLArrayRenderTarget.d.ts","./node_modules/@types/three/src/textures/CanvasTexture.d.ts","./node_modules/@types/three/src/textures/CompressedArrayTexture.d.ts","./node_modules/@types/three/src/textures/CompressedCubeTexture.d.ts","./node_modules/@types/three/src/textures/VideoTexture.d.ts","./node_modules/@types/three/src/textures/VideoFrameTexture.d.ts","./node_modules/@types/three/src/Three.Core.d.ts","./node_modules/@types/three/src/extras/PMREMGenerator.d.ts","./node_modules/@types/three/src/renderers/shaders/ShaderChunk.d.ts","./node_modules/@types/three/src/renderers/shaders/ShaderLib.d.ts","./node_modules/@types/three/src/renderers/shaders/UniformsUtils.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLBufferRenderer.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLIndexedBufferRenderer.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLShader.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLUtils.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLTextures.d.ts","./node_modules/@types/three/src/renderers/webxr/WebXRDepthSensing.d.ts","./node_modules/@types/three/src/Three.d.ts","./node_modules/@types/three/build/three.module.d.ts","./node_modules/utility-types/dist/aliases-and-guards.d.ts","./node_modules/utility-types/dist/mapped-types.d.ts","./node_modules/utility-types/dist/utility-types.d.ts","./node_modules/utility-types/dist/functional-helpers.d.ts","./node_modules/utility-types/dist/index.d.ts","./node_modules/@react-three/fiber/dist/declarations/react-reconciler/index.d.ts","./node_modules/zustand/esm/vanilla.d.mts","./node_modules/zustand/esm/react.d.mts","./node_modules/zustand/esm/index.d.mts","./node_modules/zustand/esm/traditional.d.mts","./node_modules/@react-three/fiber/dist/declarations/src/core/store.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/reconciler.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/utils.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/events.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/hooks.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/loop.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/renderer.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/index.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/three-types.d.ts","./node_modules/react-use-measure/dist/index.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/web/Canvas.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/web/events.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/index.d.ts","./node_modules/@react-three/fiber/dist/react-three-fiber.cjs.d.ts","./node_modules/@react-three/drei/helpers/ts-utils.d.ts","./node_modules/@react-three/drei/web/Html.d.ts","./node_modules/@react-three/drei/web/CycleRaycast.d.ts","./node_modules/@react-three/drei/web/useCursor.d.ts","./node_modules/@react-three/drei/web/Loader.d.ts","./node_modules/@react-three/drei/web/ScrollControls.d.ts","./node_modules/@react-three/drei/web/PresentationControls.d.ts","./node_modules/@react-three/drei/web/KeyboardControls.d.ts","./node_modules/@react-three/drei/web/Select.d.ts","./node_modules/@react-three/drei/core/Billboard.d.ts","./node_modules/@react-three/drei/core/ScreenSpace.d.ts","./node_modules/@react-three/drei/core/ScreenSizer.d.ts","./node_modules/three-stdlib/misc/MD2CharacterComplex.d.ts","./node_modules/three-stdlib/misc/ConvexObjectBreaker.d.ts","./node_modules/three-stdlib/misc/MorphBlendMesh.d.ts","./node_modules/three-stdlib/misc/GPUComputationRenderer.d.ts","./node_modules/three-stdlib/misc/Gyroscope.d.ts","./node_modules/three-stdlib/misc/MorphAnimMesh.d.ts","./node_modules/three-stdlib/misc/RollerCoaster.d.ts","./node_modules/three-stdlib/misc/Timer.d.ts","./node_modules/three-stdlib/misc/WebGL.d.ts","./node_modules/three-stdlib/misc/MD2Character.d.ts","./node_modules/three-stdlib/misc/Volume.d.ts","./node_modules/three-stdlib/misc/VolumeSlice.d.ts","./node_modules/three-stdlib/misc/TubePainter.d.ts","./node_modules/three-stdlib/misc/ProgressiveLightmap.d.ts","./node_modules/three-stdlib/renderers/CSS2DRenderer.d.ts","./node_modules/three-stdlib/renderers/CSS3DRenderer.d.ts","./node_modules/three-stdlib/renderers/Projector.d.ts","./node_modules/three-stdlib/renderers/SVGRenderer.d.ts","./node_modules/three-stdlib/textures/FlakesTexture.d.ts","./node_modules/three-stdlib/modifiers/CurveModifier.d.ts","./node_modules/three-stdlib/modifiers/SimplifyModifier.d.ts","./node_modules/three-stdlib/modifiers/EdgeSplitModifier.d.ts","./node_modules/three-stdlib/modifiers/TessellateModifier.d.ts","./node_modules/three-stdlib/exporters/GLTFExporter.d.ts","./node_modules/three-stdlib/exporters/USDZExporter.d.ts","./node_modules/three-stdlib/exporters/PLYExporter.d.ts","./node_modules/three-stdlib/exporters/DRACOExporter.d.ts","./node_modules/three-stdlib/exporters/ColladaExporter.d.ts","./node_modules/three-stdlib/exporters/MMDExporter.d.ts","./node_modules/three-stdlib/exporters/STLExporter.d.ts","./node_modules/three-stdlib/exporters/OBJExporter.d.ts","./node_modules/three-stdlib/environments/RoomEnvironment.d.ts","./node_modules/three-stdlib/animation/AnimationClipCreator.d.ts","./node_modules/three-stdlib/animation/CCDIKSolver.d.ts","./node_modules/three-stdlib/animation/MMDPhysics.d.ts","./node_modules/three-stdlib/animation/MMDAnimationHelper.d.ts","./node_modules/three-stdlib/objects/BatchedMesh.d.ts","./node_modules/three-stdlib/types/shared.d.ts","./node_modules/three-stdlib/objects/Reflector.d.ts","./node_modules/three-stdlib/objects/Refractor.d.ts","./node_modules/three-stdlib/objects/ShadowMesh.d.ts","./node_modules/three-stdlib/objects/Lensflare.d.ts","./node_modules/three-stdlib/objects/Water.d.ts","./node_modules/three-stdlib/objects/MarchingCubes.d.ts","./node_modules/three-stdlib/geometries/LightningStrike.d.ts","./node_modules/three-stdlib/objects/LightningStorm.d.ts","./node_modules/three-stdlib/objects/ReflectorRTT.d.ts","./node_modules/three-stdlib/objects/ReflectorForSSRPass.d.ts","./node_modules/three-stdlib/objects/Sky.d.ts","./node_modules/three-stdlib/objects/Water2.d.ts","./node_modules/three-stdlib/objects/GroundProjectedEnv.d.ts","./node_modules/three-stdlib/utils/SceneUtils.d.ts","./node_modules/three-stdlib/utils/UVsDebug.d.ts","./node_modules/three-stdlib/utils/GeometryUtils.d.ts","./node_modules/three-stdlib/utils/RoughnessMipmapper.d.ts","./node_modules/three-stdlib/utils/SkeletonUtils.d.ts","./node_modules/three-stdlib/utils/ShadowMapViewer.d.ts","./node_modules/three-stdlib/utils/BufferGeometryUtils.d.ts","./node_modules/three-stdlib/utils/GeometryCompressionUtils.d.ts","./node_modules/three-stdlib/shaders/BokehShader2.d.ts","./node_modules/three-stdlib/cameras/CinematicCamera.d.ts","./node_modules/three-stdlib/math/ConvexHull.d.ts","./node_modules/three-stdlib/math/MeshSurfaceSampler.d.ts","./node_modules/three-stdlib/math/SimplexNoise.d.ts","./node_modules/three-stdlib/math/OBB.d.ts","./node_modules/three-stdlib/math/Capsule.d.ts","./node_modules/three-stdlib/math/ColorConverter.d.ts","./node_modules/three-stdlib/math/ImprovedNoise.d.ts","./node_modules/three-stdlib/math/Octree.d.ts","./node_modules/three-stdlib/math/Lut.d.ts","./node_modules/three-stdlib/controls/EventDispatcher.d.ts","./node_modules/three-stdlib/controls/experimental/CameraControls.d.ts","./node_modules/three-stdlib/controls/FirstPersonControls.d.ts","./node_modules/three-stdlib/controls/TransformControls.d.ts","./node_modules/three-stdlib/controls/DragControls.d.ts","./node_modules/three-stdlib/controls/PointerLockControls.d.ts","./node_modules/three-stdlib/controls/StandardControlsEventMap.d.ts","./node_modules/three-stdlib/controls/DeviceOrientationControls.d.ts","./node_modules/three-stdlib/controls/TrackballControls.d.ts","./node_modules/three-stdlib/controls/OrbitControls.d.ts","./node_modules/three-stdlib/controls/ArcballControls.d.ts","./node_modules/three-stdlib/controls/FlyControls.d.ts","./node_modules/three-stdlib/postprocessing/Pass.d.ts","./node_modules/three-stdlib/shaders/types.d.ts","./node_modules/three-stdlib/postprocessing/ShaderPass.d.ts","./node_modules/three-stdlib/postprocessing/LUTPass.d.ts","./node_modules/three-stdlib/postprocessing/ClearPass.d.ts","./node_modules/three-stdlib/shaders/DigitalGlitch.d.ts","./node_modules/three-stdlib/postprocessing/GlitchPass.d.ts","./node_modules/three-stdlib/postprocessing/HalftonePass.d.ts","./node_modules/three-stdlib/postprocessing/SMAAPass.d.ts","./node_modules/three-stdlib/shaders/FilmShader.d.ts","./node_modules/three-stdlib/postprocessing/FilmPass.d.ts","./node_modules/three-stdlib/postprocessing/OutlinePass.d.ts","./node_modules/three-stdlib/postprocessing/SSAOPass.d.ts","./node_modules/three-stdlib/postprocessing/SavePass.d.ts","./node_modules/three-stdlib/postprocessing/BokehPass.d.ts","./node_modules/three-stdlib/postprocessing/TexturePass.d.ts","./node_modules/three-stdlib/postprocessing/AdaptiveToneMappingPass.d.ts","./node_modules/three-stdlib/postprocessing/UnrealBloomPass.d.ts","./node_modules/three-stdlib/postprocessing/CubeTexturePass.d.ts","./node_modules/three-stdlib/postprocessing/SAOPass.d.ts","./node_modules/three-stdlib/shaders/AfterimageShader.d.ts","./node_modules/three-stdlib/postprocessing/AfterimagePass.d.ts","./node_modules/three-stdlib/postprocessing/MaskPass.d.ts","./node_modules/three-stdlib/postprocessing/EffectComposer.d.ts","./node_modules/three-stdlib/shaders/DotScreenShader.d.ts","./node_modules/three-stdlib/postprocessing/DotScreenPass.d.ts","./node_modules/three-stdlib/postprocessing/SSRPass.d.ts","./node_modules/three-stdlib/postprocessing/SSAARenderPass.d.ts","./node_modules/three-stdlib/postprocessing/TAARenderPass.d.ts","./node_modules/three-stdlib/postprocessing/RenderPass.d.ts","./node_modules/three-stdlib/postprocessing/RenderPixelatedPass.d.ts","./node_modules/three-stdlib/shaders/ConvolutionShader.d.ts","./node_modules/three-stdlib/postprocessing/BloomPass.d.ts","./node_modules/three-stdlib/postprocessing/WaterPass.d.ts","./node_modules/three-stdlib/webxr/ARButton.d.ts","./node_modules/three-stdlib/webxr/XRHandMeshModel.d.ts","./node_modules/three-stdlib/webxr/OculusHandModel.d.ts","./node_modules/three-stdlib/webxr/OculusHandPointerModel.d.ts","./node_modules/three-stdlib/webxr/Text2D.d.ts","./node_modules/three-stdlib/webxr/VRButton.d.ts","./node_modules/three-stdlib/loaders/DRACOLoader.d.ts","./node_modules/three-stdlib/loaders/KTX2Loader.d.ts","./node_modules/three-stdlib/loaders/GLTFLoader.d.ts","./node_modules/three-stdlib/libs/MotionControllers.d.ts","./node_modules/three-stdlib/webxr/XRControllerModelFactory.d.ts","./node_modules/three-stdlib/webxr/XREstimatedLight.d.ts","./node_modules/three-stdlib/webxr/XRHandPrimitiveModel.d.ts","./node_modules/three-stdlib/webxr/XRHandModelFactory.d.ts","./node_modules/three-stdlib/geometries/ParametricGeometry.d.ts","./node_modules/three-stdlib/geometries/ParametricGeometries.d.ts","./node_modules/three-stdlib/geometries/ConvexGeometry.d.ts","./node_modules/three-stdlib/geometries/RoundedBoxGeometry.d.ts","./node_modules/three-stdlib/geometries/BoxLineGeometry.d.ts","./node_modules/three-stdlib/geometries/DecalGeometry.d.ts","./node_modules/three-stdlib/geometries/TeapotGeometry.d.ts","./node_modules/three-stdlib/loaders/FontLoader.d.ts","./node_modules/three-stdlib/geometries/TextGeometry.d.ts","./node_modules/three-stdlib/csm/CSMFrustum.d.ts","./node_modules/three-stdlib/csm/CSM.d.ts","./node_modules/three-stdlib/csm/CSMHelper.d.ts","./node_modules/three-stdlib/csm/CSMShader.d.ts","./node_modules/three-stdlib/shaders/ACESFilmicToneMappingShader.d.ts","./node_modules/three-stdlib/shaders/BasicShader.d.ts","./node_modules/three-stdlib/shaders/BleachBypassShader.d.ts","./node_modules/three-stdlib/shaders/BlendShader.d.ts","./node_modules/three-stdlib/shaders/BokehShader.d.ts","./node_modules/three-stdlib/shaders/BrightnessContrastShader.d.ts","./node_modules/three-stdlib/shaders/ColorCorrectionShader.d.ts","./node_modules/three-stdlib/shaders/ColorifyShader.d.ts","./node_modules/three-stdlib/shaders/CopyShader.d.ts","./node_modules/three-stdlib/shaders/DOFMipMapShader.d.ts","./node_modules/three-stdlib/shaders/DepthLimitedBlurShader.d.ts","./node_modules/three-stdlib/shaders/FXAAShader.d.ts","./node_modules/three-stdlib/shaders/FocusShader.d.ts","./node_modules/three-stdlib/shaders/FreiChenShader.d.ts","./node_modules/three-stdlib/shaders/FresnelShader.d.ts","./node_modules/three-stdlib/shaders/GammaCorrectionShader.d.ts","./node_modules/three-stdlib/shaders/GodRaysShader.d.ts","./node_modules/three-stdlib/shaders/HalftoneShader.d.ts","./node_modules/three-stdlib/shaders/HorizontalBlurShader.d.ts","./node_modules/three-stdlib/shaders/HorizontalTiltShiftShader.d.ts","./node_modules/three-stdlib/shaders/HueSaturationShader.d.ts","./node_modules/three-stdlib/shaders/KaleidoShader.d.ts","./node_modules/three-stdlib/shaders/LuminosityHighPassShader.d.ts","./node_modules/three-stdlib/shaders/LuminosityShader.d.ts","./node_modules/three-stdlib/shaders/MirrorShader.d.ts","./node_modules/three-stdlib/shaders/NormalMapShader.d.ts","./node_modules/three-stdlib/shaders/ParallaxShader.d.ts","./node_modules/three-stdlib/shaders/PixelShader.d.ts","./node_modules/three-stdlib/shaders/RGBShiftShader.d.ts","./node_modules/three-stdlib/shaders/SAOShader.d.ts","./node_modules/three-stdlib/shaders/SMAAShader.d.ts","./node_modules/three-stdlib/shaders/SSAOShader.d.ts","./node_modules/three-stdlib/shaders/SSRShader.d.ts","./node_modules/three-stdlib/shaders/SepiaShader.d.ts","./node_modules/three-stdlib/shaders/SobelOperatorShader.d.ts","./node_modules/three-stdlib/shaders/SubsurfaceScatteringShader.d.ts","./node_modules/three-stdlib/shaders/TechnicolorShader.d.ts","./node_modules/three-stdlib/shaders/ToneMapShader.d.ts","./node_modules/three-stdlib/shaders/ToonShader.d.ts","./node_modules/three-stdlib/shaders/TriangleBlurShader.d.ts","./node_modules/three-stdlib/shaders/UnpackDepthRGBAShader.d.ts","./node_modules/three-stdlib/shaders/VerticalBlurShader.d.ts","./node_modules/three-stdlib/shaders/VerticalTiltShiftShader.d.ts","./node_modules/three-stdlib/shaders/VignetteShader.d.ts","./node_modules/three-stdlib/shaders/VolumeShader.d.ts","./node_modules/three-stdlib/shaders/WaterRefractionShader.d.ts","./node_modules/three-stdlib/interactive/HTMLMesh.d.ts","./node_modules/three-stdlib/interactive/InteractiveGroup.d.ts","./node_modules/three-stdlib/interactive/SelectionBox.d.ts","./node_modules/three-stdlib/interactive/SelectionHelper.d.ts","./node_modules/three-stdlib/physics/AmmoPhysics.d.ts","./node_modules/three-stdlib/effects/ParallaxBarrierEffect.d.ts","./node_modules/three-stdlib/effects/PeppersGhostEffect.d.ts","./node_modules/three-stdlib/effects/OutlineEffect.d.ts","./node_modules/three-stdlib/effects/AnaglyphEffect.d.ts","./node_modules/three-stdlib/effects/AsciiEffect.d.ts","./node_modules/three-stdlib/effects/StereoEffect.d.ts","./node_modules/three-stdlib/loaders/FBXLoader.d.ts","./node_modules/three-stdlib/loaders/TGALoader.d.ts","./node_modules/three-stdlib/loaders/LUTCubeLoader.d.ts","./node_modules/three-stdlib/loaders/NRRDLoader.d.ts","./node_modules/three-stdlib/loaders/STLLoader.d.ts","./node_modules/three-stdlib/loaders/MTLLoader.d.ts","./node_modules/three-stdlib/loaders/XLoader.d.ts","./node_modules/three-stdlib/loaders/BVHLoader.d.ts","./node_modules/three-stdlib/loaders/ColladaLoader.d.ts","./node_modules/three-stdlib/loaders/KMZLoader.d.ts","./node_modules/three-stdlib/loaders/VRMLoader.d.ts","./node_modules/three-stdlib/loaders/VRMLLoader.d.ts","./node_modules/three-stdlib/loaders/LottieLoader.d.ts","./node_modules/three-stdlib/loaders/TTFLoader.d.ts","./node_modules/three-stdlib/loaders/RGBELoader.d.ts","./node_modules/three-stdlib/loaders/AssimpLoader.d.ts","./node_modules/three-stdlib/loaders/MDDLoader.d.ts","./node_modules/three-stdlib/loaders/EXRLoader.d.ts","./node_modules/three-stdlib/loaders/3MFLoader.d.ts","./node_modules/three-stdlib/loaders/XYZLoader.d.ts","./node_modules/three-stdlib/loaders/VTKLoader.d.ts","./node_modules/three-stdlib/loaders/LUT3dlLoader.d.ts","./node_modules/three-stdlib/loaders/DDSLoader.d.ts","./node_modules/three-stdlib/loaders/PVRLoader.d.ts","./node_modules/three-stdlib/loaders/GCodeLoader.d.ts","./node_modules/three-stdlib/loaders/BasisTextureLoader.d.ts","./node_modules/three-stdlib/loaders/TDSLoader.d.ts","./node_modules/three-stdlib/loaders/LDrawLoader.d.ts","./node_modules/three-stdlib/loaders/SVGLoader.d.ts","./node_modules/three-stdlib/loaders/3DMLoader.d.ts","./node_modules/three-stdlib/loaders/OBJLoader.d.ts","./node_modules/three-stdlib/loaders/AMFLoader.d.ts","./node_modules/three-stdlib/loaders/MMDLoader.d.ts","./node_modules/three-stdlib/loaders/MD2Loader.d.ts","./node_modules/three-stdlib/loaders/KTXLoader.d.ts","./node_modules/three-stdlib/loaders/TiltLoader.d.ts","./node_modules/three-stdlib/loaders/HDRCubeTextureLoader.d.ts","./node_modules/three-stdlib/loaders/PDBLoader.d.ts","./node_modules/three-stdlib/loaders/PRWMLoader.d.ts","./node_modules/three-stdlib/loaders/RGBMLoader.d.ts","./node_modules/three-stdlib/loaders/VOXLoader.d.ts","./node_modules/three-stdlib/loaders/PCDLoader.d.ts","./node_modules/three-stdlib/loaders/LWOLoader.d.ts","./node_modules/three-stdlib/loaders/PLYLoader.d.ts","./node_modules/three-stdlib/lines/LineSegmentsGeometry.d.ts","./node_modules/three-stdlib/lines/LineGeometry.d.ts","./node_modules/three-stdlib/lines/LineMaterial.d.ts","./node_modules/three-stdlib/lines/Wireframe.d.ts","./node_modules/three-stdlib/lines/WireframeGeometry2.d.ts","./node_modules/three-stdlib/lines/LineSegments2.d.ts","./node_modules/three-stdlib/lines/Line2.d.ts","./node_modules/three-stdlib/helpers/LightProbeHelper.d.ts","./node_modules/three-stdlib/helpers/RaycasterHelper.d.ts","./node_modules/three-stdlib/helpers/VertexTangentsHelper.d.ts","./node_modules/three-stdlib/helpers/PositionalAudioHelper.d.ts","./node_modules/three-stdlib/helpers/VertexNormalsHelper.d.ts","./node_modules/three-stdlib/helpers/RectAreaLightHelper.d.ts","./node_modules/three-stdlib/lights/RectAreaLightUniformsLib.d.ts","./node_modules/three-stdlib/lights/LightProbeGenerator.d.ts","./node_modules/three-stdlib/curves/NURBSUtils.d.ts","./node_modules/three-stdlib/curves/NURBSCurve.d.ts","./node_modules/three-stdlib/curves/NURBSSurface.d.ts","./node_modules/three-stdlib/curves/CurveExtras.d.ts","./node_modules/three-stdlib/deprecated/Geometry.d.ts","./node_modules/three-stdlib/libs/MeshoptDecoder.d.ts","./node_modules/three-stdlib/index.d.ts","./node_modules/@react-three/drei/core/Line.d.ts","./node_modules/@react-three/drei/core/QuadraticBezierLine.d.ts","./node_modules/@react-three/drei/core/CubicBezierLine.d.ts","./node_modules/@react-three/drei/core/CatmullRomLine.d.ts","./node_modules/@react-three/drei/core/PositionalAudio.d.ts","./node_modules/@react-three/drei/core/Text.d.ts","./node_modules/@react-three/drei/core/useFont.d.ts","./node_modules/@react-three/drei/core/Text3D.d.ts","./node_modules/@react-three/drei/core/Effects.d.ts","./node_modules/@react-three/drei/core/GradientTexture.d.ts","./node_modules/@react-three/drei/core/Image.d.ts","./node_modules/@react-three/drei/core/Edges.d.ts","./node_modules/@react-three/drei/core/Outlines.d.ts","./node_modules/meshline/dist/MeshLineGeometry.d.ts","./node_modules/meshline/dist/MeshLineMaterial.d.ts","./node_modules/meshline/dist/raycast.d.ts","./node_modules/meshline/dist/index.d.ts","./node_modules/@react-three/drei/core/Trail.d.ts","./node_modules/@react-three/drei/core/Sampler.d.ts","./node_modules/@react-three/drei/core/ComputedAttribute.d.ts","./node_modules/@react-three/drei/core/Clone.d.ts","./node_modules/@react-three/drei/core/MarchingCubes.d.ts","./node_modules/@react-three/drei/core/Decal.d.ts","./node_modules/@react-three/drei/core/Svg.d.ts","./node_modules/@react-three/drei/core/Gltf.d.ts","./node_modules/@react-three/drei/core/AsciiRenderer.d.ts","./node_modules/@react-three/drei/core/Splat.d.ts","./node_modules/@react-three/drei/core/OrthographicCamera.d.ts","./node_modules/@react-three/drei/core/PerspectiveCamera.d.ts","./node_modules/@react-three/drei/core/CubeCamera.d.ts","./node_modules/@react-three/drei/core/DeviceOrientationControls.d.ts","./node_modules/@react-three/drei/core/FlyControls.d.ts","./node_modules/@react-three/drei/core/MapControls.d.ts","./node_modules/@react-three/drei/core/OrbitControls.d.ts","./node_modules/@react-three/drei/core/TrackballControls.d.ts","./node_modules/@react-three/drei/core/ArcballControls.d.ts","./node_modules/@react-three/drei/core/TransformControls.d.ts","./node_modules/@react-three/drei/core/PointerLockControls.d.ts","./node_modules/@react-three/drei/core/FirstPersonControls.d.ts","./node_modules/camera-controls/dist/index.d.ts","./node_modules/@react-three/drei/core/CameraControls.d.ts","./node_modules/@react-three/drei/core/MotionPathControls.d.ts","./node_modules/@react-three/drei/core/GizmoHelper.d.ts","./node_modules/@react-three/drei/core/GizmoViewcube.d.ts","./node_modules/@react-three/drei/core/GizmoViewport.d.ts","./node_modules/@react-three/drei/core/Grid.d.ts","./node_modules/@react-three/drei/core/CubeTexture.d.ts","./node_modules/@react-three/drei/core/Fbx.d.ts","./node_modules/@react-three/drei/core/Ktx2.d.ts","./node_modules/@react-three/drei/core/Progress.d.ts","./node_modules/@react-three/drei/core/Texture.d.ts","./node_modules/hls.js/dist/hls.d.mts","./node_modules/@react-three/drei/core/VideoTexture.d.ts","./node_modules/@react-three/drei/core/useSpriteLoader.d.ts","./node_modules/@react-three/drei/core/Helper.d.ts","./node_modules/@react-three/drei/core/Stats.d.ts","./node_modules/stats-gl/dist/stats-gl.d.ts","./node_modules/@react-three/drei/core/StatsGl.d.ts","./node_modules/@react-three/drei/core/useDepthBuffer.d.ts","./node_modules/@react-three/drei/core/useAspect.d.ts","./node_modules/@react-three/drei/core/useCamera.d.ts","./node_modules/detect-gpu/dist/src/index.d.ts","./node_modules/@react-three/drei/core/DetectGPU.d.ts","./node_modules/three-mesh-bvh/src/index.d.ts","./node_modules/@react-three/drei/core/Bvh.d.ts","./node_modules/@react-three/drei/core/useContextBridge.d.ts","./node_modules/@react-three/drei/core/useAnimations.d.ts","./node_modules/@react-three/drei/core/Fbo.d.ts","./node_modules/@react-three/drei/core/useIntersect.d.ts","./node_modules/@react-three/drei/core/useBoxProjectedEnv.d.ts","./node_modules/@react-three/drei/core/BBAnchor.d.ts","./node_modules/@react-three/drei/core/TrailTexture.d.ts","./node_modules/@react-three/drei/core/Example.d.ts","./node_modules/@react-three/drei/core/Instances.d.ts","./node_modules/@react-three/drei/core/SpriteAnimator.d.ts","./node_modules/@react-three/drei/core/CurveModifier.d.ts","./node_modules/@react-three/drei/core/MeshDistortMaterial.d.ts","./node_modules/@react-three/drei/core/MeshWobbleMaterial.d.ts","./node_modules/@react-three/drei/materials/MeshReflectorMaterial.d.ts","./node_modules/@react-three/drei/core/MeshReflectorMaterial.d.ts","./node_modules/@react-three/drei/materials/MeshRefractionMaterial.d.ts","./node_modules/@react-three/drei/core/MeshRefractionMaterial.d.ts","./node_modules/@react-three/drei/core/MeshTransmissionMaterial.d.ts","./node_modules/@react-three/drei/core/MeshDiscardMaterial.d.ts","./node_modules/@react-three/drei/core/MultiMaterial.d.ts","./node_modules/@react-three/drei/core/PointMaterial.d.ts","./node_modules/@react-three/drei/core/shaderMaterial.d.ts","./node_modules/@react-three/drei/core/softShadows.d.ts","./node_modules/@react-three/drei/core/shapes.d.ts","./node_modules/@react-three/drei/core/RoundedBox.d.ts","./node_modules/@react-three/drei/core/ScreenQuad.d.ts","./node_modules/@react-three/drei/core/Center.d.ts","./node_modules/@react-three/drei/core/Resize.d.ts","./node_modules/@react-three/drei/core/Bounds.d.ts","./node_modules/@react-three/drei/core/CameraShake.d.ts","./node_modules/@react-three/drei/core/Float.d.ts","./node_modules/@react-three/drei/helpers/environment-assets.d.ts","./node_modules/@react-three/drei/core/useEnvironment.d.ts","./node_modules/@react-three/drei/core/Environment.d.ts","./node_modules/@react-three/drei/core/ContactShadows.d.ts","./node_modules/@react-three/drei/core/AccumulativeShadows.d.ts","./node_modules/@react-three/drei/core/Stage.d.ts","./node_modules/@react-three/drei/core/Backdrop.d.ts","./node_modules/@react-three/drei/core/Shadow.d.ts","./node_modules/@react-three/drei/core/Caustics.d.ts","./node_modules/@react-three/drei/core/SpotLight.d.ts","./node_modules/@react-three/drei/core/Lightformer.d.ts","./node_modules/@react-three/drei/core/Sky.d.ts","./node_modules/@react-three/drei/core/Stars.d.ts","./node_modules/@react-three/drei/core/Cloud.d.ts","./node_modules/@react-three/drei/core/Sparkles.d.ts","./node_modules/@react-three/drei/core/MatcapTexture.d.ts","./node_modules/@react-three/drei/core/NormalTexture.d.ts","./node_modules/@react-three/drei/materials/WireframeMaterial.d.ts","./node_modules/@react-three/drei/core/Wireframe.d.ts","./node_modules/@react-three/drei/core/ShadowAlpha.d.ts","./node_modules/@react-three/drei/core/Points.d.ts","./node_modules/@react-three/drei/core/Segments.d.ts","./node_modules/@react-three/drei/core/Detailed.d.ts","./node_modules/@react-three/drei/core/Preload.d.ts","./node_modules/@react-three/drei/core/BakeShadows.d.ts","./node_modules/@react-three/drei/core/meshBounds.d.ts","./node_modules/@react-three/drei/core/AdaptiveDpr.d.ts","./node_modules/@react-three/drei/core/AdaptiveEvents.d.ts","./node_modules/@react-three/drei/core/PerformanceMonitor.d.ts","./node_modules/@react-three/drei/core/RenderTexture.d.ts","./node_modules/@react-three/drei/core/RenderCubeTexture.d.ts","./node_modules/@react-three/drei/core/Mask.d.ts","./node_modules/@react-three/drei/core/Hud.d.ts","./node_modules/@react-three/drei/core/Fisheye.d.ts","./node_modules/@react-three/drei/core/MeshPortalMaterial.d.ts","./node_modules/@react-three/drei/core/calculateScaleFactor.d.ts","./node_modules/@react-three/drei/core/index.d.ts","./node_modules/@react-three/drei/web/View.d.ts","./node_modules/@react-three/drei/web/pivotControls/context.d.ts","./node_modules/@react-three/drei/web/pivotControls/index.d.ts","./node_modules/@react-three/drei/web/ScreenVideoTexture.d.ts","./node_modules/@react-three/drei/web/WebcamVideoTexture.d.ts","./node_modules/@mediapipe/tasks-vision/vision.d.ts","./node_modules/@react-three/drei/web/Facemesh.d.ts","./node_modules/@react-three/drei/web/FaceControls.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/utils.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/state.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/config.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/internalConfig.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/handlers.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/config/resolver.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/EventStore.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/TimeoutStore.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/Controller.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/engines/Engine.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/action.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/index.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types.d.ts","./node_modules/@use-gesture/core/types/dist/use-gesture-core-types.cjs.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/types.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useDrag.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/usePinch.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useWheel.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useScroll.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useMove.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useHover.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useGesture.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/createUseGesture.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/utils/maths.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/utils.d.ts","./node_modules/@use-gesture/core/utils/dist/use-gesture-core-utils.cjs.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/actions.d.ts","./node_modules/@use-gesture/core/actions/dist/use-gesture-core-actions.cjs.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/index.d.ts","./node_modules/@use-gesture/react/dist/use-gesture-react.cjs.d.ts","./node_modules/@react-three/drei/web/DragControls.d.ts","./node_modules/@react-three/drei/web/FaceLandmarker.d.ts","./node_modules/@react-three/drei/web/index.d.ts","./node_modules/@react-three/drei/index.d.ts","./src/routes/archive/2023.OnOrbits.tsx","./node_modules/@react-pdf/font/lib/index.d.ts","./node_modules/@react-pdf/types/pdf.d.ts","./node_modules/@react-pdf/types/svg.d.ts","./node_modules/@react-pdf/stylesheet/lib/index.d.ts","./node_modules/@react-pdf/types/style.d.ts","./node_modules/@react-pdf/primitives/lib/index.d.ts","./node_modules/@react-pdf/types/primitive.d.ts","./node_modules/@react-pdf/types/font.d.ts","./node_modules/@react-pdf/types/page.d.ts","./node_modules/@react-pdf/types/bookmark.d.ts","./node_modules/@react-pdf/types/node.d.ts","./node_modules/@react-pdf/types/image.d.ts","./node_modules/@react-pdf/types/context.d.ts","./node_modules/@react-pdf/types/index.d.ts","./node_modules/@react-pdf/renderer/lib/react-pdf.d.ts","./src/lib/post/Book.tsx","./src/lib/post/Post.tsx","./src/@orbitmines/js/react/Modules.tsx","./src/@orbitmines/js/react/IModule.ts","./src/lib/prism/ray.ts","./src/@ether/UI/pages/Placeholder.tsx","./src/@ether/UI/pages/language/ErrorsPanel.tsx","./src/@ether/UI/pages/language/LanguageList.tsx","./src/@ether/UI/pages/language/ProgramPanel.tsx","./src/@ether/UI/pages/language/SidebarPanel.tsx","./src/@ether/UI/pages/language/LanguageCreator.tsx","./src/@ether/UI/pages/language/LangPage.tsx","./src/@ether/UI/pages/library/icons.tsx","./src/@ether/UI/pages/library/Socials.tsx","./src/@ether/UI/pages/library/DisplayPanel.tsx","./src/@ether/UI/pages/library/Dropdown.tsx","./src/@ether/UI/pages/library/SelectionContext.tsx","./src/@ether/UI/pages/library/EntryView.tsx","./src/@ether/UI/pages/library/ProjectList.tsx","./src/@ether/UI/pages/library/SettingsPanel.tsx","./src/@ether/UI/pages/library/Library.tsx","./src/@ether/UI/pages/pullrequests/Header.tsx","./src/@ether/UI/pages/pullrequests/CategoryView.tsx","./src/@ether/UI/pages/pullrequests/CommitDiff.tsx","./src/@ether/UI/pages/pullrequests/DetailView.tsx","./src/@ether/UI/pages/pullrequests/ListView.tsx","./src/@ether/UI/pages/pullrequests/NewPRForm.tsx","./src/@ether/UI/pages/pullrequests/PullRequests.tsx","./src/@ether/UI/pages/repository/AccessBadge.tsx","./src/@ether/UI/pages/repository/ClonePopup.tsx","./src/@ether/UI/pages/repository/ActionButtons.tsx","./src/@ether/UI/pages/repository/Breadcrumb.tsx","./src/@ether/UI/pages/repository/FileListing.tsx","./src/@ether/UI/pages/repository/FileViewer.tsx","./src/@ether/UI/pages/repository/IframeMount.tsx","./src/@ether/UI/pages/repository/ProfileNames.tsx","./src/routes/profiles/fadi-shawki/FadiShawki.tsx","./src/@ether/UI/pages/repository/userDefaults.tsx","./src/@ether/UI/pages/repository/Profile.tsx","./src/@ether/UI/pages/repository/Sidebar.tsx","./src/@ether/UI/pages/repository/Repository.tsx","./src/@ether/UI/pages/settings/Settings.tsx","./src/@ether/UI/router/EtherRoutes.tsx","./src/@orbitmines/ether/Ether.tsx","./src/routes/Minimap.tsx","./src/@ether/UI/router/EtherOrMinimap.tsx","./src/lib/post/ImageGallery.tsx","./src/routes/Almanac.tsx","./src/routes/Error.tsx","./src/routes/archive/2024.02.OrbitMines_as_a_Game_Project.tsx","./src/routes/archive/2022.OnIntelligibility.tsx","./src/routes/archive/2025.TowardsAUniversalLanguage.tsx","./src/routes/archive/2026.MinecraftArchive.tsx","./src/routes/archive/2026.RayCalculiAndPhysics.tsx","./src/routes/Archive.tsx","./src/routes/archive/Physics.tsx","./src/routes/archive/Physics2.tsx","./src/routes/profiles/Profiles.tsx","./app/almanac/[[...section]]/AlmanacClient.tsx","./app/almanac/[[...section]]/page.tsx","./app/archive/[item]/ArchiveClient.tsx","./app/archive/[item]/page.tsx","./app/profiles/[profile]/ProfileRedirect.tsx","./app/profiles/[profile]/page.tsx","./app/sitemap.ts","./app/Providers.tsx","./app/layout.tsx","./app/not-found.tsx","./app/page.tsx","./app/[...path]/CatchAllClient.tsx","./app/[...path]/page.tsx","./app/papers/[[...slug]]/PapersRedirect.tsx","./app/papers/[[...slug]]/page.tsx","./app/thumbnail/ThumbnailClient.tsx","./app/thumbnail/page.tsx","./.next/types/cache-life.d.ts","./.next/types/routes.d.ts","./.next/types/validator.ts","./.next/dev/types/cache-life.d.ts","./.next/dev/types/validator.ts","./node_modules/@types/draco3d/index.d.ts","./node_modules/@types/istanbul-lib-coverage/index.d.ts","./node_modules/@types/istanbul-lib-report/index.d.ts","./node_modules/@types/istanbul-reports/index.d.ts","./node_modules/@jest/expect-utils/build/index.d.ts","./node_modules/chalk/index.d.ts","./node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.d.mts","./node_modules/@sinclair/typebox/build/esm/type/symbols/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/any/any.d.mts","./node_modules/@sinclair/typebox/build/esm/type/any/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.d.mts","./node_modules/@sinclair/typebox/build/esm/type/async-iterator/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/readonly/readonly.d.mts","./node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/readonly/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.d.mts","./node_modules/@sinclair/typebox/build/esm/type/readonly-optional/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.d.mts","./node_modules/@sinclair/typebox/build/esm/type/constructor/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/literal/literal.d.mts","./node_modules/@sinclair/typebox/build/esm/type/literal/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/enum/enum.d.mts","./node_modules/@sinclair/typebox/build/esm/type/enum/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/function/function.d.mts","./node_modules/@sinclair/typebox/build/esm/type/function/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/computed/computed.d.mts","./node_modules/@sinclair/typebox/build/esm/type/computed/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/never/never.d.mts","./node_modules/@sinclair/typebox/build/esm/type/never/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intersect/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/union/union-type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.d.mts","./node_modules/@sinclair/typebox/build/esm/type/union/union.d.mts","./node_modules/@sinclair/typebox/build/esm/type/union/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.d.mts","./node_modules/@sinclair/typebox/build/esm/type/recursive/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.d.mts","./node_modules/@sinclair/typebox/build/esm/type/unsafe/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/ref/ref.d.mts","./node_modules/@sinclair/typebox/build/esm/type/ref/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.d.mts","./node_modules/@sinclair/typebox/build/esm/type/tuple/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/error/error.d.mts","./node_modules/@sinclair/typebox/build/esm/type/error/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/string/string.d.mts","./node_modules/@sinclair/typebox/build/esm/type/string/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.d.mts","./node_modules/@sinclair/typebox/build/esm/type/boolean/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/number/number.d.mts","./node_modules/@sinclair/typebox/build/esm/type/number/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/integer/integer.d.mts","./node_modules/@sinclair/typebox/build/esm/type/integer/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.d.mts","./node_modules/@sinclair/typebox/build/esm/type/bigint/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/template-literal.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/union.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.d.mts","./node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.d.mts","./node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/indexed/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.d.mts","./node_modules/@sinclair/typebox/build/esm/type/iterator/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/promise/promise.d.mts","./node_modules/@sinclair/typebox/build/esm/type/promise/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/sets/set.d.mts","./node_modules/@sinclair/typebox/build/esm/type/sets/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/mapped/mapped.d.mts","./node_modules/@sinclair/typebox/build/esm/type/mapped/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/optional/optional.d.mts","./node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/optional/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.d.mts","./node_modules/@sinclair/typebox/build/esm/type/awaited/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.d.mts","./node_modules/@sinclair/typebox/build/esm/type/keyof/keyof.d.mts","./node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-entries.d.mts","./node_modules/@sinclair/typebox/build/esm/type/keyof/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/omit/omit.d.mts","./node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/omit/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/pick/pick.d.mts","./node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/pick/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/null/null.d.mts","./node_modules/@sinclair/typebox/build/esm/type/null/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.d.mts","./node_modules/@sinclair/typebox/build/esm/type/symbol/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.d.mts","./node_modules/@sinclair/typebox/build/esm/type/undefined/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/partial/partial.d.mts","./node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/partial/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.d.mts","./node_modules/@sinclair/typebox/build/esm/type/regexp/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/record/record.d.mts","./node_modules/@sinclair/typebox/build/esm/type/record/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/required/required.d.mts","./node_modules/@sinclair/typebox/build/esm/type/required/required-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/required/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/transform/transform.d.mts","./node_modules/@sinclair/typebox/build/esm/type/transform/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/module/compute.d.mts","./node_modules/@sinclair/typebox/build/esm/type/module/infer.d.mts","./node_modules/@sinclair/typebox/build/esm/type/module/module.d.mts","./node_modules/@sinclair/typebox/build/esm/type/module/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/not/not.d.mts","./node_modules/@sinclair/typebox/build/esm/type/not/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/static/static.d.mts","./node_modules/@sinclair/typebox/build/esm/type/static/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/object/object.d.mts","./node_modules/@sinclair/typebox/build/esm/type/object/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/helpers/helpers.d.mts","./node_modules/@sinclair/typebox/build/esm/type/helpers/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/array/array.d.mts","./node_modules/@sinclair/typebox/build/esm/type/array/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/date/date.d.mts","./node_modules/@sinclair/typebox/build/esm/type/date/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.d.mts","./node_modules/@sinclair/typebox/build/esm/type/uint8array/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.d.mts","./node_modules/@sinclair/typebox/build/esm/type/unknown/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/void/void.d.mts","./node_modules/@sinclair/typebox/build/esm/type/void/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/schema/schema.d.mts","./node_modules/@sinclair/typebox/build/esm/type/schema/anyschema.d.mts","./node_modules/@sinclair/typebox/build/esm/type/schema/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/clone/type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/clone/value.d.mts","./node_modules/@sinclair/typebox/build/esm/type/clone/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/create/type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/create/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/argument/argument.d.mts","./node_modules/@sinclair/typebox/build/esm/type/argument/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/guard/kind.d.mts","./node_modules/@sinclair/typebox/build/esm/type/guard/type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/guard/value.d.mts","./node_modules/@sinclair/typebox/build/esm/type/guard/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.d.mts","./node_modules/@sinclair/typebox/build/esm/type/patterns/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/registry/format.d.mts","./node_modules/@sinclair/typebox/build/esm/type/registry/type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/registry/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/composite/composite.d.mts","./node_modules/@sinclair/typebox/build/esm/type/composite/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/const/const.d.mts","./node_modules/@sinclair/typebox/build/esm/type/const/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.d.mts","./node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-template-literal.d.mts","./node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.d.mts","./node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/exclude/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/extends-check.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/extends.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/extends-undefined.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extract/extract.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extract/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/instance-type/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.d.mts","./node_modules/@sinclair/typebox/build/esm/type/instantiate/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic-from-mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/lowercase.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/uncapitalize.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/uppercase.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.d.mts","./node_modules/@sinclair/typebox/build/esm/type/parameters/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/rest/rest.d.mts","./node_modules/@sinclair/typebox/build/esm/type/rest/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/return-type/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/type/json.d.mts","./node_modules/@sinclair/typebox/build/esm/type/type/javascript.d.mts","./node_modules/@sinclair/typebox/build/esm/type/type/index.d.mts","./node_modules/@sinclair/typebox/build/esm/index.d.mts","./node_modules/@jest/schemas/build/index.d.ts","./node_modules/pretty-format/build/index.d.ts","./node_modules/jest-diff/build/index.d.ts","./node_modules/jest-matcher-utils/build/index.d.ts","./node_modules/expect/node_modules/jest-mock/build/index.d.ts","./node_modules/expect/build/index.d.ts","./node_modules/@types/jest/index.d.ts","./node_modules/@types/offscreencanvas/index.d.ts","./node_modules/@types/react-reconciler/index.d.ts","./node_modules/@types/stack-utils/index.d.ts","./node_modules/@types/stats.js/index.d.ts","./node_modules/@types/three/index.d.ts","./node_modules/@types/yargs-parser/index.d.ts","./node_modules/@types/yargs/index.d.ts"],"fileIdsList":[[94,157,165,169,172,174,175,176,189,506,507,508,509,1648],[94,157,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,249,550,552,1098,1632,1634,1636,1639,1641,1643,1645,1647,1648,1651],[94,157,165,169,172,174,175,176,189,506,507,508,509,1651],[94,157,165,169,172,174,175,176,189,249,550,1098,1632,1634,1636,1639,1641,1643,1645,1647,1648,1649,1651],[85,94,157,165,169,172,174,175,176,189,249,567,621,634,1098,1575,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1618,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1636,1642,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1620,1648,1651],[94,157,165,169,172,174,175,176,181,189,249,551,636,1098,1631,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1627,1648,1651],[94,157,165,169,172,174,175,176,181,189,249,551,1098,1633,1648,1651],[94,157,165,169,172,174,175,176,189,249,548,551,1098,1638,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,540,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,551,1098,1644,1648,1651],[94,157,165,169,172,174,175,176,189,249,551,1098,1635,1648,1651],[94,157,165,169,172,174,175,176,181,189,249,551,1098,1632,1634,1636,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1574,1648,1651],[94,157,165,169,172,174,175,176,189,249,551,1098,1646,1648,1651],[94,157,165,169,172,174,175,176,189,551,552,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1850],[85,94,157,165,169,172,174,175,176,189,1571,1648,1651],[94,157,165,169,172,174,175,176,189,1558,1648,1651],[94,157,165,169,172,174,175,176,189,1559,1560,1562,1564,1565,1566,1567,1568,1569,1570,1648,1651],[94,157,165,169,172,174,175,176,189,1562,1564,1565,1566,1567,1648,1651],[94,157,165,169,172,174,175,176,189,1563,1648,1651],[94,157,165,169,172,174,175,176,189,1561,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1104,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1103,1104,1381,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1103,1389,1390,1392,1408,1427,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1103,1104,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1103,1104,1389,1390,1392,1408,1421,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1104,1648,1651],[94,157,165,169,172,174,175,176,189,1104,1381,1382,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1092,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1104,1381,1382,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1104,1381,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1443,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1381,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1478,1479,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1402,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1103,1104,1381,1389,1390,1392,1408,1427,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1381,1389,1390,1392,1402,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1084,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1092,1103,1104,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1103,1104,1389,1390,1392,1408,1427,1455,1458,1459,1460,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1462,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1088,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1092,1103,1389,1390,1392,1408,1427,1435,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1103,1389,1390,1392,1408,1427,1455,1458,1459,1461,1463,1464,1465,1473,1478,1480,1481,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1104,1438,1648,1651],[85,94,157,165,169,172,174,175,176,189,1103,1104,1389,1390,1392,1408,1427,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1104,1381,1388,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1104,1398,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1433,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1495,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1113,1114,1115,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1434,1435,1436,1437,1439,1440,1441,1442,1444,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1461,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1445,1478,1648,1651],[94,157,165,169,172,174,175,176,189,1381,1648,1651],[94,157,165,169,172,174,175,176,189,1555,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1104,1445,1552,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1434,1445,1520,1521,1648,1651],[85,94,157,165,169,172,174,175,176,189,1520,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1084,1103,1104,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1433,1434,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1104,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1105,1106,1107,1108,1109,1110,1111,1112,1514,1515,1517,1518,1519,1521,1522,1553,1554,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1104,1445,1516,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1090,1092,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1090,1091,1092,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1090,1091,1092,1093,1094,1095,1096,1648,1651],[94,157,165,169,172,174,175,176,189,711,1090,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1085,1090,1092,1093,1098,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1090,1091,1092,1093,1098,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,711,1079,1088,1089,1092,1093,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1090,1091,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1097,1098,1100,1101,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,215,216,217,218,219,249,479,501,546,1079,1092,1097,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,1097,1098,1099,1648,1651],[94,157,165,169,172,174,175,176,189,1090,1093,1648,1651],[94,157,165,169,172,174,175,176,189,1102,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1662,1666,1669,1671,1673,1675,1677,1679,1683,1687,1691,1693,1695,1697,1699,1701,1703,1705,1707,1709,1711,1719,1724,1726,1728,1730,1732,1735,1737,1742,1746,1750,1752,1754,1756,1759,1761,1763,1766,1768,1772,1774,1776,1778,1780,1782,1784,1786,1788,1790,1793,1796,1798,1800,1804,1806,1809,1811,1813,1815,1819,1825,1829,1831,1833,1840,1842,1844,1846,1849],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1661],[94,157,165,169,172,174,175,176,189,1648,1651,1799],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1776,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1781],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1776,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1665],[94,157,165,169,172,174,175,176,189,1648,1651,1681,1687,1691,1697,1728,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1736],[94,157,165,169,172,174,175,176,189,1648,1651,1710],[94,157,165,169,172,174,175,176,189,1648,1651,1704],[94,157,165,169,172,174,175,176,189,1648,1651,1794,1795],[94,157,165,169,172,174,175,176,189,1648,1651,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1687,1724,1730,1742,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1810],[94,157,165,169,172,174,175,176,189,1648,1651,1659,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1680],[94,157,165,169,172,174,175,176,189,1648,1651,1662,1669,1675,1679,1683,1699,1711,1752,1754,1756,1778,1780,1784,1786,1788,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1812],[94,157,165,169,172,174,175,176,189,1648,1651,1673,1683,1699,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1814],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1669,1671,1735,1776,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1672],[94,157,165,169,172,174,175,176,189,1648,1651,1797],[94,157,165,169,172,174,175,176,189,1648,1651,1791],[94,157,165,169,172,174,175,176,189,1648,1651,1783],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1675,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1676],[94,157,165,169,172,174,175,176,189,1648,1651,1700],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1778,1793,1817],[94,157,165,169,172,174,175,176,189,1648,1651,1719,1793,1817],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1691,1719,1732,1776,1780,1793,1816,1818],[94,157,165,169,172,174,175,176,189,1648,1651,1816,1817,1818],[94,157,165,169,172,174,175,176,189,1648,1651,1701,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1732,1778,1780,1793,1822],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1778,1793,1822],[94,157,165,169,172,174,175,176,189,1648,1651,1691,1732,1776,1780,1793,1821,1823],[94,157,165,169,172,174,175,176,189,1648,1651,1820,1821,1822,1823,1824],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1778,1793,1827],[94,157,165,169,172,174,175,176,189,1648,1651,1719,1793,1827],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1691,1719,1732,1776,1780,1793,1826,1828],[94,157,165,169,172,174,175,176,189,1648,1651,1826,1827,1828],[94,157,165,169,172,174,175,176,189,1648,1651,1678],[94,157,165,169,172,174,175,176,189,1648,1651,1801,1802,1803],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1662,1666,1669,1673,1675,1679,1681,1683,1687,1691,1693,1695,1697,1699,1703,1705,1707,1709,1711,1719,1726,1728,1732,1735,1752,1754,1756,1761,1763,1768,1772,1774,1778,1782,1784,1786,1788,1790,1793,1800],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1662,1666,1669,1673,1675,1679,1681,1683,1687,1691,1693,1695,1697,1699,1701,1703,1705,1707,1709,1711,1719,1726,1728,1732,1735,1752,1754,1756,1761,1763,1768,1772,1774,1778,1782,1784,1786,1788,1790,1793,1800],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1779],[94,157,165,169,172,174,175,176,189,1648,1651,1720,1721,1722,1723],[94,157,165,169,172,174,175,176,189,1648,1651,1722,1732,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1720,1724,1732,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1707,1709,1719,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1681,1683,1687,1691,1693,1697,1699,1720,1721,1723,1732,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1830],[94,157,165,169,172,174,175,176,189,1648,1651,1673,1683,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1832],[94,157,165,169,172,174,175,176,189,1648,1651,1666,1669,1671,1673,1679,1687,1691,1699,1726,1728,1735,1763,1778,1782,1788,1793,1800],[94,157,165,169,172,174,175,176,189,1648,1651,1708],[94,157,165,169,172,174,175,176,189,1648,1651,1684,1685,1686],[94,157,165,169,172,174,175,176,189,1648,1651,1669,1683,1684,1735,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1684,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1793,1835],[94,157,165,169,172,174,175,176,189,1648,1651,1834,1835,1836,1837,1838,1839],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1732,1778,1780,1793,1835],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1719,1732,1793,1834],[94,157,165,169,172,174,175,176,189,1648,1651,1725],[94,157,165,169,172,174,175,176,189,1648,1651,1738,1739,1740,1741],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1739,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1687,1691,1693,1699,1730,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1681,1691,1697,1707,1732,1738,1740,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1674],[94,157,165,169,172,174,175,176,189,1648,1651,1663,1664,1731],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1663,1664,1666,1669,1673,1675,1677,1679,1687,1691,1699,1724,1726,1728,1730,1735,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1666,1669,1673,1677,1679,1681,1683,1687,1691,1697,1699,1724,1726,1735,1737,1742,1746,1750,1759,1763,1766,1768,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1771],[94,157,165,169,172,174,175,176,189,1648,1651,1666,1669,1673,1677,1679,1687,1691,1693,1697,1699,1726,1735,1763,1776,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1769,1770,1776,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1682],[94,157,165,169,172,174,175,176,189,1648,1651,1773],[94,157,165,169,172,174,175,176,189,1648,1651,1751],[94,157,165,169,172,174,175,176,189,1648,1651,1706],[94,157,165,169,172,174,175,176,189,1648,1651,1777],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1669,1735,1776,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1743,1744,1745],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1744,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1744,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1681,1687,1691,1693,1697,1724,1732,1743,1745,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1733,1734],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1733,1778],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1732,1734,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1841],[94,157,165,169,172,174,175,176,189,1648,1651,1679,1683,1699,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1757,1758],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1757,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1669,1671,1675,1681,1687,1691,1693,1697,1703,1705,1707,1709,1711,1732,1735,1752,1754,1756,1758,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1805],[94,157,165,169,172,174,175,176,189,1648,1651,1747,1748,1749],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1748,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1748,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1681,1687,1691,1693,1697,1724,1732,1747,1749,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1727],[94,157,165,169,172,174,175,176,189,1648,1651,1670],[94,157,165,169,172,174,175,176,189,1648,1651,1669,1735,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1667,1668],[94,157,165,169,172,174,175,176,189,1648,1651,1667,1732,1778],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1668,1732,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1762],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1662,1675,1677,1683,1691,1703,1705,1707,1709,1719,1761,1776,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1692],[94,157,165,169,172,174,175,176,189,1648,1651,1696],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1695,1776,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1760],[94,157,165,169,172,174,175,176,189,1648,1651,1807,1808],[94,157,165,169,172,174,175,176,189,1648,1651,1764,1765],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1764,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1669,1671,1675,1681,1687,1691,1693,1697,1703,1705,1707,1709,1711,1732,1735,1752,1754,1756,1765,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1843],[94,157,165,169,172,174,175,176,189,1648,1651,1687,1691,1699,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1845],[94,157,165,169,172,174,175,176,189,1648,1651,1679,1683,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1662,1666,1673,1675,1677,1679,1687,1691,1693,1697,1699,1703,1705,1707,1709,1711,1719,1726,1728,1752,1754,1756,1761,1763,1774,1778,1782,1784,1786,1788,1790,1791],[94,157,165,169,172,174,175,176,189,1648,1651,1791,1792],[94,157,165,169,172,174,175,176,189,1648,1651,1660],[94,157,165,169,172,174,175,176,189,1648,1651,1729],[94,157,165,169,172,174,175,176,189,1648,1651,1775],[94,157,165,169,172,174,175,176,189,1648,1651,1666,1669,1673,1677,1679,1683,1687,1691,1693,1695,1697,1699,1726,1728,1735,1763,1768,1772,1774,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1702],[94,157,165,169,172,174,175,176,189,1648,1651,1753],[94,157,165,169,172,174,175,176,189,1648,1651,1659],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1701,1703,1705,1707,1709,1711,1712,1719],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1701,1705,1712,1713,1719,1780],[94,157,165,169,172,174,175,176,189,1648,1651,1712,1713,1714,1715,1716,1717,1718],[94,157,165,169,172,174,175,176,189,1648,1651,1701],[94,157,165,169,172,174,175,176,189,1648,1651,1701,1719],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1703,1705,1707,1711,1719,1780],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1675,1683,1691,1703,1705,1707,1709,1711,1715,1776,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1717,1776,1780],[94,157,165,169,172,174,175,176,189,1648,1651,1767],[94,157,165,169,172,174,175,176,189,1648,1651,1698],[94,157,165,169,172,174,175,176,189,1648,1651,1847,1848],[94,157,165,169,172,174,175,176,189,1648,1651,1666,1673,1679,1711,1726,1728,1737,1754,1756,1761,1784,1786,1790,1793,1800,1815,1831,1833,1842,1846,1847],[94,157,165,169,172,174,175,176,189,1648,1651,1662,1669,1671,1675,1677,1683,1687,1691,1693,1695,1697,1699,1703,1705,1707,1709,1719,1724,1732,1735,1742,1746,1750,1752,1759,1763,1766,1768,1772,1774,1778,1782,1788,1793,1811,1813,1819,1825,1829,1840,1844],[94,157,165,169,172,174,175,176,189,1648,1651,1785],[94,157,165,169,172,174,175,176,189,1648,1651,1755],[94,157,165,169,172,174,175,176,189,1648,1651,1688,1689,1690],[94,157,165,169,172,174,175,176,189,1648,1651,1669,1683,1688,1735,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1688,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1787],[94,157,165,169,172,174,175,176,189,1648,1651,1694],[94,157,165,169,172,174,175,176,189,1648,1651,1789],[94,157,165,169,172,174,175,176,189,1648,1651,1654],[94,157,165,169,172,174,175,176,189,1648,1651,1655],[94,157,165,169,172,174,175,176,189,1648,1651,1852,1856],[94,157,165,169,172,174,175,176,189,608,610,611,612,613,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,611,612,613,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,609,610,611,612,613,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,612,613,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,613,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,615,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,615,616,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,615,616,617,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,615,616,617,618,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,615,616,617,618,619,1648,1651],[94,154,155,157,165,169,172,174,175,176,189,1648,1651],[94,156,157,165,169,172,174,175,176,189,1648,1651],[157,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,197,1648,1651],[94,157,158,163,165,168,169,172,174,175,176,178,189,194,206,1648,1651],[94,157,158,159,165,168,169,172,174,175,176,189,1648,1651],[94,157,160,165,169,172,174,175,176,189,207,1648,1651],[94,157,161,162,165,169,172,174,175,176,180,189,1648,1651],[94,157,162,165,169,172,174,175,176,189,194,203,1648,1651],[94,157,163,165,168,169,172,174,175,176,178,189,1648,1651],[94,156,157,164,165,169,172,174,175,176,189,1648,1651],[94,157,165,166,169,172,174,175,176,189,1648,1651],[94,157,165,167,168,169,172,174,175,176,189,1648,1651],[94,156,157,165,168,169,172,174,175,176,189,1648,1651],[94,157,165,168,169,170,172,174,175,176,189,194,206,1648,1651],[94,157,165,168,169,170,172,174,175,176,189,194,197,1648,1651],[94,144,157,165,168,169,171,172,174,175,176,178,189,194,206,1648,1651],[94,157,165,168,169,171,172,174,175,176,178,189,194,203,206,1648,1651],[94,157,165,169,171,172,173,174,175,176,189,194,203,206,1648,1651],[92,93,94,95,96,97,98,99,100,101,102,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,1648,1651],[94,157,165,168,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,176,189,1648,1651],[94,157,165,169,172,174,175,176,177,189,206,1648,1651],[94,157,165,168,169,172,174,175,176,178,189,194,1648,1651],[94,157,165,169,172,174,175,176,180,189,1648,1651],[94,157,165,169,172,174,175,176,181,189,1648,1651],[94,157,165,168,169,172,174,175,176,184,189,1648,1651],[94,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,1648,1651],[94,157,165,169,172,174,175,176,186,189,1648,1651],[94,157,165,169,172,174,175,176,187,189,1648,1651],[94,157,162,165,169,172,174,175,176,178,189,197,1648,1651],[94,157,165,168,169,172,174,175,176,189,190,1648,1651],[94,157,165,169,172,174,175,176,189,191,207,210,1648,1651],[94,157,165,168,169,172,174,175,176,189,194,196,197,1648,1651],[94,157,165,169,172,174,175,176,189,195,197,1648,1651],[94,157,165,169,172,174,175,176,189,197,207,1648,1651],[94,157,165,169,172,174,175,176,189,198,1648,1651],[94,154,157,165,169,172,174,175,176,189,194,200,206,1648,1651],[94,157,165,169,172,174,175,176,189,194,199,1648,1651],[94,157,165,168,169,172,174,175,176,189,201,202,1648,1651],[94,157,165,169,172,174,175,176,189,201,202,1648,1651],[94,157,162,165,169,172,174,175,176,178,189,194,203,1648,1651],[94,157,165,169,172,174,175,176,189,204,1648,1651],[94,157,165,169,172,174,175,176,178,189,205,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,206,1648,1651],[94,157,165,169,172,174,175,176,189,207,208,1648,1651],[94,157,162,165,169,172,174,175,176,189,208,1648,1651],[94,157,165,169,172,174,175,176,189,194,209,1648,1651],[94,157,165,169,172,174,175,176,177,189,210,1648,1651],[94,157,165,169,172,174,175,176,189,211,1648,1651],[94,157,160,165,169,172,174,175,176,189,1648,1651],[94,157,162,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,207,1648,1651],[94,144,157,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,206,1648,1651],[94,157,165,169,172,174,175,176,189,212,1648,1651],[94,157,165,169,172,174,175,176,184,189,1648,1651],[94,157,165,169,172,174,175,176,189,202,1648,1651],[94,144,157,165,168,169,170,172,174,175,176,184,189,194,197,206,209,210,212,1648,1651],[94,157,165,169,172,174,175,176,189,194,213,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,215,216,217,219,501,546,1098,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,215,216,217,218,482,501,546,1098,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,215,216,218,219,501,546,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,219,482,483,1648,1651],[85,94,157,165,169,172,174,175,176,189,219,482,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,216,217,218,219,501,546,1098,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,215,217,218,219,501,546,1098,1648,1651],[83,84,94,157,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,1078,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,681,682,683,684,685,686,687,688,689,690,691,692,693,694,696,709,712,713,714,716,717,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,772,786,794,795,796,810,837,848,863,864,869,870,871,872,877,882,883,884,887,889,890,895,896,898,899,903,941,962,978,979,980,981,982,983,984,985,996,997,998,999,1000,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1648,1651],[94,157,165,169,172,174,175,176,189,695,697,698,699,700,701,702,703,704,705,706,707,708,710,717,718,719,720,721,722,723,977,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1648,1651],[94,157,165,169,172,174,175,176,189,646,669,730,734,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,661,662,668,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,667,669,681,730,731,733,735,941,1648,1651],[94,157,165,169,172,174,175,176,189,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,649,669,736,1648,1651],[94,157,165,169,172,174,175,176,189,646,649,664,665,666,667,1648,1651],[94,157,165,169,172,174,175,176,189,726,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,732,1648,1651],[94,157,165,169,172,174,175,176,189,668,1648,1651],[94,157,165,169,172,174,175,176,189,646,668,1648,1651],[94,157,165,169,172,174,175,176,189,730,744,941,1648,1651],[94,157,165,169,172,174,175,176,189,745,1648,1651],[94,157,165,169,172,174,175,176,189,712,1648,1651],[94,157,165,169,172,174,175,176,189,646,654,655,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,656,687,730,941,976,977,1648,1651],[94,157,165,169,172,174,175,176,189,656,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,647,656,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,648,654,1648,1651],[94,157,165,169,172,174,175,176,189,647,649,651,652,654,661,675,678,680,681,682,1648,1651],[94,157,165,169,172,174,175,176,189,649,1648,1651],[94,157,165,169,172,174,175,176,189,683,1648,1651],[94,157,165,169,172,174,175,176,189,649,650,1648,1651],[94,157,165,169,172,174,175,176,189,646,649,651,1648,1651],[94,157,165,169,172,174,175,176,189,648,649,650,654,1648,1651],[94,157,165,169,172,174,175,176,189,648,652,653,654,656,661,669,673,681,683,684,690,691,694,719,724,726,727,729,962,1648,1651],[94,157,165,169,172,174,175,176,189,647,656,661,717,727,728,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,655,681,686,691,1648,1651],[94,157,165,169,172,174,175,176,189,687,1648,1651],[94,157,165,169,172,174,175,176,189,646,681,863,1648,1651],[94,157,165,169,172,174,175,176,189,681,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,661,689,691,694,709,719,962,1648,1651],[94,157,165,169,172,174,175,176,189,647,1648,1651],[94,157,165,169,172,174,175,176,189,646,691,1648,1651],[94,157,165,169,172,174,175,176,189,647,661,1648,1651],[94,157,165,169,172,174,175,176,189,647,661,670,1648,1651],[94,157,165,169,172,174,175,176,189,647,671,1648,1651],[94,157,165,169,172,174,175,176,189,647,672,1648,1651],[94,157,165,169,172,174,175,176,189,647,658,672,673,1648,1651],[94,157,165,169,172,174,175,176,189,986,1648,1651],[94,157,165,169,172,174,175,176,189,661,670,1648,1651],[94,157,165,169,172,174,175,176,189,647,670,1648,1651],[94,157,165,169,172,174,175,176,189,986,987,988,989,990,991,992,993,994,995,1648,1651],[94,157,165,169,172,174,175,176,189,970,1648,1651],[94,157,165,169,172,174,175,176,189,1005,1648,1651],[94,157,165,169,172,174,175,176,189,647,661,670,673,683,1648,1651],[94,157,165,169,172,174,175,176,189,970,971,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1648,1651],[94,157,165,169,172,174,175,176,189,647,683,1648,1651],[94,157,165,169,172,174,175,176,189,673,683,1648,1651],[94,157,165,169,172,174,175,176,189,661,670,683,1648,1651],[94,157,165,169,172,174,175,176,189,658,661,714,730,941,1021,1648,1651],[94,157,165,169,172,174,175,176,189,658,1023,1648,1651],[94,157,165,169,172,174,175,176,189,658,678,1023,1648,1651],[94,157,165,169,172,174,175,176,189,658,678,683,730,850,941,1023,1648,1651],[94,157,165,169,172,174,175,176,189,656,658,1023,1648,1651],[94,157,165,169,172,174,175,176,189,654,658,730,884,941,1021,1648,1651],[94,157,165,169,172,174,175,176,189,658,683,850,1023,1648,1651],[94,157,165,169,172,174,175,176,189,658,730,852,887,941,1648,1651],[94,157,165,169,172,174,175,176,189,658,676,1021,1648,1651],[94,157,165,169,172,174,175,176,189,658,714,899,1648,1651],[94,157,165,169,172,174,175,176,189,658,662,730,941,1023,1648,1651],[94,157,165,169,172,174,175,176,189,658,730,890,941,1023,1648,1651],[94,157,165,169,172,174,175,176,189,658,685,1648,1651],[94,157,165,169,172,174,175,176,189,658,685,730,872,877,883,941,1648,1651],[94,157,165,169,172,174,175,176,189,872,877,882,1648,1651],[94,157,165,169,172,174,175,176,189,658,685,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,658,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,685,730,895,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,654,655,656,685,687,730,751,754,758,760,783,784,801,828,832,834,845,871,906,908,909,918,927,939,940,941,1648,1651],[94,157,165,169,172,174,175,176,189,658,685,730,872,877,898,941,1648,1651],[94,157,165,169,172,174,175,176,189,712,872,877,1648,1651],[94,157,165,169,172,174,175,176,189,658,685,691,730,872,877,889,941,1648,1651],[94,157,165,169,172,174,175,176,189,669,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,683,981,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,688,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,689,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,725,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,1036,1648,1651],[94,157,165,169,172,174,175,176,189,1037,1648,1651],[94,157,165,169,172,174,175,176,189,691,724,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,669,683,690,691,724,730,941,981,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,691,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,658,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,724,850,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,653,656,658,676,681,683,684,690,691,694,719,723,730,941,962,1648,1651],[94,157,165,169,172,174,175,176,189,724,850,851,852,853,854,855,856,857,858,859,860,861,862,865,866,867,868,1648,1651],[94,157,165,169,172,174,175,176,189,646,653,658,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,646,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,653,658,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,658,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,647,658,691,724,859,1648,1651],[94,157,165,169,172,174,175,176,189,865,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,648,654,655,661,695,724,730,864,941,1648,1651],[94,157,165,169,172,174,175,176,189,658,724,1648,1651],[94,157,165,169,172,174,175,176,189,724,751,754,758,760,761,764,783,784,791,801,828,832,834,845,906,908,909,918,927,937,938,939,940,966,1648,1651],[94,157,165,169,172,174,175,176,189,649,685,724,769,937,938,965,975,1648,1651],[94,157,165,169,172,174,175,176,189,649,654,661,675,676,677,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,648,649,651,657,661,1648,1651],[94,157,165,169,172,174,175,176,189,646,648,658,661,1648,1651],[94,157,165,169,172,174,175,176,189,661,1648,1651],[94,157,165,169,172,174,175,176,189,652,654,661,1648,1651],[94,157,165,169,172,174,175,176,189,646,654,661,675,676,678,730,870,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,661,675,678,713,730,870,941,1648,1651],[94,157,165,169,172,174,175,176,189,654,661,1648,1651],[94,157,165,169,172,174,175,176,189,652,1648,1651],[94,157,165,169,172,174,175,176,189,647,654,661,1648,1651],[94,157,165,169,172,174,175,176,189,646,648,652,653,661,1648,1651],[94,157,165,169,172,174,175,176,189,648,654,661,674,675,678,1648,1651],[94,157,165,169,172,174,175,176,189,649,651,653,654,661,1648,1651],[94,157,165,169,172,174,175,176,189,654,661,675,676,678,1648,1651],[94,157,165,169,172,174,175,176,189,654,661,676,678,1648,1651],[94,157,165,169,172,174,175,176,189,647,649,651,655,661,676,678,1648,1651],[94,157,165,169,172,174,175,176,189,648,649,1648,1651],[94,157,165,169,172,174,175,176,189,648,649,651,652,653,654,656,658,659,660,1648,1651],[94,157,165,169,172,174,175,176,189,649,652,654,1648,1651],[94,157,165,169,172,174,175,176,189,663,1648,1651],[94,157,165,169,172,174,175,176,189,749,750,751,752,753,754,755,756,757,758,759,760,761,763,764,765,766,767,768,769,770,771,773,774,775,776,777,778,779,780,781,782,783,784,785,787,788,789,790,791,792,793,798,799,800,801,802,803,804,805,806,807,808,809,811,812,813,814,815,816,817,818,819,820,821,822,823,825,826,827,828,829,830,831,832,833,834,835,836,838,839,840,841,842,843,844,845,846,847,849,875,876,877,878,879,880,881,885,886,888,891,892,893,894,897,900,901,902,904,905,906,907,908,909,910,911,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,934,935,937,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,786,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,646,649,650,651,751,754,755,758,760,783,784,789,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,773,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,689,751,754,758,760,783,784,792,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,794,796,797,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,795,798,1648,1651],[94,157,165,169,172,174,175,176,189,724,801,802,1648,1651],[94,157,165,169,172,174,175,176,189,648,654,751,754,758,760,783,784,801,804,826,828,832,834,845,906,908,909,918,927,936,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,714,751,754,758,760,773,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,730,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,941,1648,1651],[94,157,165,169,172,174,175,176,189,802,975,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,810,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,649,679,749,751,754,758,760,780,781,783,784,788,789,797,801,813,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,691,749,751,754,758,760,783,784,792,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,691,751,754,758,760,783,784,792,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,691,751,754,758,760,773,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,788,789,801,812,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,802,1648,1651],[94,157,165,169,172,174,175,176,189,654,750,773,1648,1651],[94,157,165,169,172,174,175,176,189,753,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,750,1648,1651],[94,157,165,169,172,174,175,176,189,750,751,754,758,760,783,784,801,825,828,832,834,845,906,908,909,918,927,936,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,770,783,784,801,822,824,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,755,938,1648,1651],[94,157,165,169,172,174,175,176,189,685,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,759,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,937,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,691,762,763,826,936,1648,1651],[94,157,165,169,172,174,175,176,189,681,749,769,938,1648,1651],[94,157,165,169,172,174,175,176,189,683,691,724,730,749,751,754,758,759,760,765,774,775,776,779,783,784,801,828,832,834,845,906,908,909,912,918,927,937,939,940,941,975,1648,1651],[94,157,165,169,172,174,175,176,189,767,1648,1651],[94,157,165,169,172,174,175,176,189,656,694,724,730,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,941,962,975,1648,1651],[94,157,165,169,172,174,175,176,189,770,1648,1651],[94,157,165,169,172,174,175,176,189,824,1648,1651],[94,157,165,169,172,174,175,176,189,771,773,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,654,655,658,661,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,646,775,1648,1651],[94,157,165,169,172,174,175,176,189,777,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,780,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,654,655,658,661,749,755,769,771,772,938,1648,1651],[94,157,165,169,172,174,175,176,189,646,751,754,758,760,776,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,646,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,646,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,655,656,687,691,724,727,730,750,751,754,758,760,764,783,784,792,801,828,832,834,845,906,908,909,918,927,939,940,941,975,1648,1651],[94,157,165,169,172,174,175,176,189,646,750,751,754,758,760,783,784,801,809,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,656,658,694,751,754,758,760,783,784,801,828,831,832,834,845,906,908,909,918,927,939,940,962,1648,1651],[94,157,165,169,172,174,175,176,189,686,751,754,758,760,783,784,801,828,832,834,838,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,837,838,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,687,691,749,751,754,758,760,783,784,792,801,828,832,834,837,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,761,1648,1651],[94,157,165,169,172,174,175,176,189,933,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,761,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,647,655,658,661,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,975,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,849,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,848,877,1648,1651],[94,157,165,169,172,174,175,176,189,685,751,754,758,760,783,784,801,828,832,834,845,849,872,876,906,908,909,918,927,937,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,877,884,1648,1651],[94,157,165,169,172,174,175,176,189,661,751,754,758,760,773,783,784,801,828,832,834,845,877,887,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,891,1648,1651],[94,157,165,169,172,174,175,176,189,818,877,896,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,761,783,784,801,828,832,834,845,906,908,909,918,927,937,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,685,751,754,758,760,783,784,801,826,828,832,834,845,849,906,908,909,918,927,936,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,877,899,900,906,908,909,918,927,937,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,685,751,754,758,760,783,784,801,828,832,834,845,872,876,877,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,725,751,754,758,760,783,784,801,828,832,834,845,877,903,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,656,683,684,685,694,724,730,872,874,875,877,937,941,962,975,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,877,890,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,647,655,661,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,910,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,912,913,1648,1651],[94,157,165,169,172,174,175,176,189,691,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,654,655,658,661,751,754,756,758,760,772,779,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,769,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,826,828,832,834,845,906,908,909,918,927,936,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,826,828,832,834,845,906,908,909,918,927,936,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,691,773,792,1648,1651],[94,157,165,169,172,174,175,176,189,646,687,751,754,758,760,783,784,792,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,656,687,730,751,754,758,760,783,784,792,801,828,832,834,845,906,908,909,918,927,939,940,941,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,812,814,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,654,655,656,658,675,678,683,714,724,1648,1651],[94,157,165,169,172,174,175,176,189,676,684,1648,1651],[94,157,165,169,172,174,175,176,189,649,654,658,675,678,683,714,724,725,730,794,941,1648,1651],[94,157,165,169,172,174,175,176,189,683,724,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,683,724,730,941,1021,1648,1651],[94,157,165,169,172,174,175,176,189,661,683,724,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,654,662,725,1648,1651],[94,157,165,169,172,174,175,176,189,646,654,661,675,678,683,714,724,726,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,647,683,730,869,941,1648,1651],[94,157,165,169,172,174,175,176,189,687,709,1058,1648,1651],[94,157,165,169,172,174,175,176,189,687,709,1060,1648,1651],[94,157,165,169,172,174,175,176,189,687,689,691,709,719,1648,1651],[94,157,165,169,172,174,175,176,189,687,691,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,649,655,656,658,661,676,678,683,691,694,696,697,698,700,701,702,703,708,709,710,718,724,730,941,962,1648,1651],[94,157,165,169,172,174,175,176,189,649,650,651,941,950,1648,1651],[94,157,165,169,172,174,175,176,189,646,730,975,1648,1651],[94,157,165,169,172,174,175,176,189,947,1648,1651],[94,157,165,169,172,174,175,176,189,646,1648,1651],[94,157,165,169,172,174,175,176,189,649,947,1648,1651],[94,157,165,169,172,174,175,176,189,684,1648,1651],[94,157,165,169,172,174,175,176,189,647,655,681,686,837,1648,1651],[94,157,165,169,172,174,175,176,189,648,654,655,656,676,694,873,962,1648,1651],[94,157,165,169,172,174,175,176,189,658,1648,1651],[94,157,165,169,172,174,175,176,189,687,691,975,1648,1651],[94,157,165,169,172,174,175,176,189,649,683,944,950,951,952,965,1648,1651],[94,157,165,169,172,174,175,176,189,649,679,1648,1651],[94,157,165,169,172,174,175,176,189,656,687,691,694,751,754,758,760,769,783,784,801,828,832,834,845,906,908,909,918,927,939,940,962,975,1648,1651],[94,157,165,169,172,174,175,176,189,685,730,937,941,1648,1651],[94,157,165,169,172,174,175,176,189,714,724,882,975,1648,1651],[94,157,165,169,172,174,175,176,189,655,656,686,687,691,764,874,1648,1651],[94,157,165,169,172,174,175,176,189,656,683,685,694,724,730,874,937,941,946,949,962,1648,1651],[94,157,165,169,172,174,175,176,189,649,650,656,683,694,724,730,874,937,941,948,949,953,954,962,963,964,966,975,1648,1651],[94,157,165,169,172,174,175,176,189,826,936,975,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,649,655,656,658,661,678,679,680,683,687,691,694,696,724,730,764,837,845,874,937,940,941,942,943,944,945,946,962,968,969,974,1648,1651],[94,157,165,169,172,174,175,176,189,649,794,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,654,655,658,661,772,1648,1651],[94,157,165,169,172,174,175,176,189,958,1648,1651],[94,157,165,169,172,174,175,176,189,956,957,959,1648,1651],[94,157,165,169,172,174,175,176,189,652,661,681,687,712,713,714,717,852,970,971,972,973,975,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,765,783,784,801,828,832,834,845,906,908,909,918,927,939,940,948,966,1648,1651],[94,157,165,169,172,174,175,176,189,646,685,724,751,754,758,760,783,784,801,828,832,834,845,877,906,908,909,918,927,939,940,967,1648,1651],[94,157,165,169,172,174,175,176,189,656,691,694,724,730,751,754,758,760,769,783,784,801,828,832,834,845,906,908,909,918,927,937,939,940,941,950,954,955,961,962,965,975,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,654,655,658,661,772,774,956,1648,1651],[94,157,165,169,172,174,175,176,189,771,960,1648,1651],[94,157,165,169,172,174,175,176,189,695,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,658,1648,1651],[94,157,165,169,172,174,175,176,189,695,864,1648,1651],[94,157,165,169,172,174,175,176,189,649,651,682,1648,1651],[94,157,165,169,172,174,175,176,189,649,683,700,704,724,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,698,701,1648,1651],[94,157,165,169,172,174,175,176,189,656,676,702,724,1648,1651],[94,157,165,169,172,174,175,176,189,691,1648,1651],[94,157,165,169,172,174,175,176,189,649,683,701,704,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,698,701,704,1648,1651],[94,157,165,169,172,174,175,176,189,700,1648,1651],[94,157,165,169,172,174,175,176,189,656,685,698,1648,1651],[94,157,165,169,172,174,175,176,189,683,701,704,705,706,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,699,719,1648,1651],[94,157,165,169,172,174,175,176,189,646,685,694,695,697,698,700,705,719,720,721,722,724,730,941,962,1648,1651],[94,157,165,169,172,174,175,176,189,683,684,694,702,724,730,941,962,1648,1651],[94,157,165,169,172,174,175,176,189,646,656,685,694,697,707,719,962,1648,1651],[94,157,165,169,172,174,175,176,189,646,655,698,709,724,1648,1651],[94,157,165,169,172,174,175,176,189,687,691,697,698,701,702,710,1075,1648,1651],[94,157,165,169,172,174,175,176,189,646,698,1648,1651],[94,157,165,169,172,174,175,176,189,661,684,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,714,716,718,1648,1651],[94,157,165,169,172,174,175,176,189,655,681,711,712,713,714,716,717,719,1648,1651],[94,157,165,169,172,174,175,176,189,653,658,691,692,693,724,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,688,1648,1651],[94,157,165,169,172,174,175,176,189,646,649,691,1648,1651],[94,157,165,169,172,174,175,176,189,691,715,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,648,681,687,688,689,690,1648,1651],[94,157,165,169,172,174,175,176,189,646,1065,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1863],[94,157,165,169,172,174,175,176,189,1549,1648,1651],[94,157,165,169,172,174,175,176,189,1529,1530,1535,1648,1651],[94,157,165,169,172,174,175,176,189,1531,1535,1648,1651],[94,157,165,169,172,174,175,176,189,1528,1535,1648,1651],[94,157,165,169,172,174,175,176,189,1535,1648,1651],[94,157,165,169,172,174,175,176,189,1529,1530,1531,1535,1648,1651],[94,157,165,169,172,174,175,176,189,1534,1648,1651],[94,157,165,169,172,174,175,176,189,1525,1528,1531,1532,1648,1651],[94,157,165,169,172,174,175,176,189,1523,1524,1648,1651],[94,157,165,169,172,174,175,176,189,1523,1524,1525,1648,1651],[94,157,165,169,172,174,175,176,189,1523,1524,1525,1526,1527,1533,1648,1651],[94,157,165,169,172,174,175,176,189,1523,1525,1648,1651],[94,157,165,169,172,174,175,176,189,1546,1648,1651],[94,157,165,169,172,174,175,176,189,1547,1648,1651],[94,157,165,169,172,174,175,176,189,1536,1537,1648,1651],[94,157,165,169,172,174,175,176,189,1536,1538,1539,1540,1541,1542,1543,1544,1545,1548,1550,1648,1651],[85,94,157,165,169,172,174,175,176,189,1536,1648,1651],[94,157,165,169,172,174,175,176,189,1551,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1657,1854,1855],[94,157,165,169,172,174,175,176,189,639,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1852],[94,157,165,169,172,174,175,176,189,1648,1651,1658,1853],[94,157,165,169,172,174,175,176,189,1395,1396,1397,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1396,1445,1648,1651],[94,157,165,169,172,174,175,176,189,504,1648,1651],[94,157,165,169,172,174,175,176,189,506,507,508,509,1648,1651],[94,157,165,169,172,174,175,176,189,452,515,516,1648,1651],[94,157,165,169,172,174,175,176,189,224,225,227,239,263,378,389,497,1648,1651],[94,157,165,169,172,174,175,176,189,227,258,259,260,262,497,1648,1651],[94,157,165,169,172,174,175,176,189,227,395,397,399,400,402,497,499,1648,1651],[94,157,165,169,172,174,175,176,189,227,261,298,497,1648,1651],[94,157,165,169,172,174,175,176,189,225,227,238,239,245,251,256,377,378,379,388,497,499,1648,1651],[94,157,165,169,172,174,175,176,189,497,1648,1651],[94,157,165,169,172,174,175,176,189,234,240,259,279,374,1648,1651],[94,157,165,169,172,174,175,176,189,227,1648,1651],[94,157,165,169,172,174,175,176,189,220,234,240,1648,1651],[94,157,165,169,172,174,175,176,189,406,1648,1651],[94,157,165,169,172,174,175,176,189,403,404,406,1648,1651],[94,157,165,169,172,174,175,176,189,403,405,497,1648,1651],[94,157,165,169,171,172,174,175,176,189,279,476,494,1648,1651],[94,157,165,169,171,172,174,175,176,189,350,353,369,374,494,1648,1651],[94,157,165,169,171,172,174,175,176,189,322,494,1648,1651],[94,157,165,169,172,174,175,176,189,382,1648,1651],[94,157,165,169,172,174,175,176,189,381,382,383,1648,1651],[94,157,165,169,172,174,175,176,189,381,1648,1651],[91,94,157,165,169,171,172,174,175,176,189,220,227,239,245,251,257,259,263,264,277,278,345,375,376,389,497,501,1648,1651],[94,157,165,169,172,174,175,176,189,224,227,261,298,395,396,401,497,549,1648,1651],[94,157,165,169,172,174,175,176,189,261,549,1648,1651],[94,157,165,169,172,174,175,176,189,224,278,447,497,549,1648,1651],[94,157,165,169,172,174,175,176,189,549,1648,1651],[94,157,165,169,172,174,175,176,189,227,261,262,549,1648,1651],[94,157,165,169,172,174,175,176,189,398,549,1648,1651],[94,157,165,169,172,174,175,176,189,264,377,380,387,1648,1651],[85,94,157,165,169,172,174,175,176,189,452,1648,1651],[94,157,165,169,172,174,175,176,187,189,234,249,1098,1648,1651],[94,157,165,169,172,174,175,176,189,234,249,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,319,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,240,249,452,1098,1648,1651],[94,157,165,169,172,174,175,176,189,234,305,319,320,531,538,1648,1651],[94,157,165,169,172,174,175,176,189,304,532,533,534,535,537,1648,1651],[94,157,165,169,172,174,175,176,189,355,1648,1651],[94,157,165,169,172,174,175,176,189,355,356,1648,1651],[94,157,165,169,172,174,175,176,189,238,240,307,308,1648,1651],[94,157,165,169,172,174,175,176,189,240,314,315,1648,1651],[94,157,165,169,172,174,175,176,189,240,309,317,1648,1651],[94,157,165,169,172,174,175,176,189,314,1648,1651],[94,157,165,169,172,174,175,176,189,232,240,307,308,309,310,311,312,313,314,317,1648,1651],[94,157,165,169,172,174,175,176,189,240,307,314,315,316,318,1648,1651],[94,157,165,169,172,174,175,176,189,240,308,310,311,1648,1651],[94,157,165,169,172,174,175,176,189,308,310,313,315,1648,1651],[94,157,165,169,172,174,175,176,189,536,1648,1651],[94,157,165,169,172,174,175,176,189,240,1648,1651],[85,94,157,165,169,172,174,175,176,189,228,525,1648,1651],[85,94,157,165,169,172,174,175,176,189,206,1648,1651],[85,94,157,165,169,172,174,175,176,189,261,296,1648,1651],[85,94,157,165,169,172,174,175,176,189,261,389,1648,1651],[94,157,165,169,172,174,175,176,189,294,299,1648,1651],[85,94,157,165,169,172,174,175,176,189,295,503,1648,1651],[85,89,94,157,165,169,171,172,174,175,176,189,215,216,217,218,219,501,545,1098,1648,1651],[94,157,165,169,171,172,174,175,176,189,240,1648,1651],[94,157,165,169,171,172,174,175,176,189,239,244,325,342,384,385,389,444,446,497,498,1648,1651],[94,157,165,169,172,174,175,176,189,277,386,1648,1651],[94,157,165,169,172,174,175,176,189,501,1648,1651],[94,157,165,169,172,174,175,176,189,226,1648,1651],[85,94,157,165,169,172,174,175,176,189,231,234,449,465,467,1648,1651],[94,157,165,169,172,174,175,176,187,189,234,449,464,465,466,548,1648,1651],[94,157,165,169,172,174,175,176,189,458,459,460,461,462,463,1648,1651],[94,157,165,169,172,174,175,176,189,460,1648,1651],[94,157,165,169,172,174,175,176,189,464,1648,1651],[94,157,165,169,172,174,175,176,189,249,413,414,416,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,240,407,408,409,410,415,1648,1651],[94,157,165,169,172,174,175,176,189,413,415,1648,1651],[94,157,165,169,172,174,175,176,189,411,1648,1651],[94,157,165,169,172,174,175,176,189,412,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,295,503,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,502,503,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,503,1098,1648,1651],[94,157,165,169,172,174,175,176,189,342,343,1648,1651],[94,157,165,169,172,174,175,176,189,343,1648,1651],[94,157,165,169,171,172,174,175,176,189,498,503,1648,1651],[94,157,165,169,172,174,175,176,189,372,1648,1651],[94,156,157,165,169,172,174,175,176,189,371,1648,1651],[94,157,165,169,172,174,175,176,189,234,240,246,248,350,363,367,369,446,449,486,487,494,498,1648,1651],[94,157,165,169,172,174,175,176,189,240,289,311,1648,1651],[94,157,165,169,172,174,175,176,189,350,361,364,369,1648,1651],[85,94,157,165,169,172,174,175,176,189,231,234,350,353,369,372,406,453,454,455,456,457,468,469,470,471,472,473,474,475,549,1648,1651],[94,157,165,169,172,174,175,176,189,231,234,259,350,357,358,359,362,363,1648,1651],[94,157,165,169,172,174,175,176,189,194,240,259,361,368,449,450,494,1648,1651],[94,157,165,169,172,174,175,176,189,365,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,228,240,244,254,286,287,290,342,345,410,444,445,486,497,498,499,501,549,1648,1651],[94,157,165,169,172,174,175,176,189,231,232,234,1648,1651],[94,157,165,169,172,174,175,176,189,350,1648,1651],[94,156,157,165,169,172,174,175,176,189,259,286,287,344,345,346,347,348,349,498,1648,1651],[94,157,165,169,172,174,175,176,189,369,1648,1651],[94,156,157,165,169,172,174,175,176,189,233,234,244,248,284,350,357,358,359,360,361,364,365,366,367,368,487,1648,1651],[94,157,165,169,171,172,174,175,176,189,284,285,357,498,499,1648,1651],[94,157,165,169,172,174,175,176,189,259,287,342,345,350,446,498,1648,1651],[94,157,165,169,171,172,174,175,176,189,497,499,1648,1651],[94,157,165,169,171,172,174,175,176,189,194,494,498,499,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,220,234,239,246,248,251,254,261,281,286,287,288,289,290,325,326,328,331,333,336,337,338,339,341,389,444,446,494,497,498,499,1648,1651],[94,157,165,169,171,172,174,175,176,189,194,1648,1651],[94,157,165,169,172,174,175,176,189,227,228,229,257,494,495,496,501,503,549,1648,1651],[94,157,165,169,172,174,175,176,189,224,225,497,1648,1651],[94,157,165,169,172,174,175,176,189,418,1648,1651],[94,157,165,169,171,172,174,175,176,189,194,206,236,402,406,407,408,409,410,416,417,549,1648,1651],[94,157,165,169,172,174,175,176,187,189,206,220,234,236,248,251,287,326,331,341,342,395,422,423,424,430,433,434,444,446,494,497,1648,1651],[94,157,165,169,172,174,175,176,189,251,257,264,277,287,345,497,1648,1651],[94,157,165,169,171,172,174,175,176,189,206,228,239,248,287,428,494,497,1648,1651],[94,157,165,169,172,174,175,176,189,448,1648,1651],[94,157,165,169,171,172,174,175,176,189,418,431,432,441,1648,1651],[94,157,165,169,172,174,175,176,189,494,497,1648,1651],[94,157,165,169,172,174,175,176,189,347,487,1648,1651],[94,157,165,169,172,174,175,176,189,248,286,389,503,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,226,331,391,395,424,430,433,436,494,1648,1651],[94,157,165,169,171,172,174,175,176,189,264,277,395,437,1648,1651],[94,157,165,169,172,174,175,176,189,227,288,389,439,497,499,1648,1651],[94,157,165,169,171,172,174,175,176,189,206,410,497,1648,1651],[94,157,165,169,171,172,174,175,176,189,261,288,389,390,391,400,418,438,440,497,1648,1651],[91,94,157,165,169,171,172,174,175,176,189,286,443,501,503,1648,1651],[94,157,165,169,172,174,175,176,189,340,444,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,234,237,239,240,246,248,254,263,264,277,287,290,326,328,338,341,342,389,422,423,424,425,427,429,444,446,494,503,1648,1651],[94,157,165,169,171,172,174,175,176,189,194,264,430,435,441,494,1648,1651],[94,157,165,169,172,174,175,176,189,267,268,269,270,271,272,273,274,275,276,1648,1651],[94,157,165,169,172,174,175,176,189,281,332,1648,1651],[94,157,165,169,172,174,175,176,189,334,1648,1651],[94,157,165,169,172,174,175,176,189,332,1648,1651],[94,157,165,169,172,174,175,176,189,334,335,1648,1651],[94,157,165,169,171,172,174,175,176,189,238,239,240,244,245,498,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,226,228,246,250,286,289,290,324,444,494,499,501,503,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,206,230,237,238,248,250,287,442,487,493,498,1648,1651],[94,157,165,169,172,174,175,176,189,357,1648,1651],[94,157,165,169,172,174,175,176,189,358,1648,1651],[94,157,165,169,172,174,175,176,189,240,251,486,1648,1651],[94,157,165,169,172,174,175,176,189,359,1648,1651],[94,157,165,169,172,174,175,176,189,233,1648,1651],[94,157,165,169,172,174,175,176,189,235,247,1648,1651],[94,157,165,169,171,172,174,175,176,189,235,239,246,1648,1651],[94,157,165,169,172,174,175,176,189,242,247,1648,1651],[94,157,165,169,172,174,175,176,189,243,1648,1651],[94,157,165,169,172,174,175,176,189,235,236,1648,1651],[94,157,165,169,172,174,175,176,189,235,291,1648,1651],[94,157,165,169,172,174,175,176,189,235,1648,1651],[94,157,165,169,172,174,175,176,189,237,281,330,1648,1651],[94,157,165,169,172,174,175,176,189,329,1648,1651],[94,157,165,169,172,174,175,176,189,234,236,237,1648,1651],[94,157,165,169,172,174,175,176,189,237,327,1648,1651],[94,157,165,169,172,174,175,176,189,234,236,1648,1651],[94,157,165,169,172,174,175,176,189,286,389,1648,1651],[94,157,165,169,172,174,175,176,189,486,1648,1651],[94,157,165,169,171,172,174,175,176,189,206,246,248,252,286,389,443,446,449,450,451,477,478,481,485,487,494,498,1648,1651],[94,157,165,169,172,174,175,176,189,300,303,305,306,319,320,1648,1651],[85,94,157,165,169,172,174,175,176,189,217,219,249,479,480,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,217,219,249,479,480,484,1098,1648,1651],[94,157,165,169,172,174,175,176,189,373,1648,1651],[94,157,165,169,172,174,175,176,189,259,280,285,286,350,351,352,353,354,356,369,370,372,375,443,446,497,499,1648,1651],[94,157,165,169,172,174,175,176,189,319,1648,1651],[94,157,165,169,171,172,174,175,176,189,324,494,1648,1651],[94,157,165,169,172,174,175,176,189,324,1648,1651],[94,157,165,169,171,172,174,175,176,189,246,292,321,323,325,443,494,501,503,1648,1651],[94,157,165,169,172,174,175,176,189,300,301,302,303,305,306,319,320,502,1648,1651],[91,94,157,165,169,171,172,174,175,176,187,189,206,235,236,248,254,286,287,290,389,441,442,444,494,497,498,501,1648,1651],[94,157,165,169,172,174,175,176,189,231,234,241,1648,1651],[94,157,165,169,172,174,175,176,189,285,287,419,422,1648,1651],[94,157,165,169,172,174,175,176,189,285,420,488,489,490,491,492,1648,1651],[94,157,165,169,171,172,174,175,176,189,281,497,1648,1651],[94,157,165,169,171,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,284,369,1648,1651],[94,157,165,169,172,174,175,176,189,283,1648,1651],[94,157,165,169,172,174,175,176,189,285,338,1648,1651],[94,157,165,169,172,174,175,176,189,282,284,497,1648,1651],[94,157,165,169,171,172,174,175,176,189,230,285,419,420,421,494,497,498,1648,1651],[85,94,157,165,169,172,174,175,176,189,234,240,318,1648,1651],[85,94,157,165,169,172,174,175,176,189,232,1648,1651],[94,157,165,169,172,174,175,176,189,222,223,1648,1651],[85,94,157,165,169,172,174,175,176,189,228,1648,1651],[85,94,157,165,169,172,174,175,176,189,234,304,1648,1651],[85,91,94,157,165,169,172,174,175,176,189,286,290,501,503,1648,1651],[94,157,165,169,172,174,175,176,189,228,525,526,1648,1651],[85,94,157,165,169,172,174,175,176,189,299,1648,1651],[85,94,157,165,169,172,174,175,176,187,189,206,226,293,295,297,298,503,1648,1651],[94,157,165,169,172,174,175,176,189,234,261,498,1648,1651],[94,157,165,169,172,174,175,176,189,234,426,1648,1651],[85,94,157,165,169,171,172,174,175,176,187,189,224,226,299,397,501,502,1648,1651],[85,94,157,165,169,172,174,175,176,189,215,216,217,218,219,501,546,1098,1648,1651],[85,86,87,88,89,94,157,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,392,393,394,1648,1651],[94,157,165,169,172,174,175,176,189,392,1648,1651],[85,89,94,157,165,169,171,172,173,174,175,176,187,189,214,215,216,217,218,219,220,226,254,259,436,464,499,500,503,546,1098,1648,1651],[94,157,165,169,172,174,175,176,189,511,1648,1651],[94,157,165,169,172,174,175,176,189,513,1648,1651],[94,157,165,169,172,174,175,176,189,517,1648,1651],[94,157,165,169,172,174,175,176,189,519,1648,1651],[94,157,165,169,172,174,175,176,189,521,522,523,1648,1651],[94,157,165,169,172,174,175,176,189,527,1648,1651],[90,94,157,165,169,172,174,175,176,189,505,510,512,514,518,520,524,528,530,540,541,543,547,548,549,550,1648,1651],[94,157,165,169,172,174,175,176,189,529,1648,1651],[94,157,165,169,172,174,175,176,189,539,1648,1651],[94,157,165,169,172,174,175,176,189,295,1648,1651],[94,157,165,169,172,174,175,176,189,542,1648,1651],[94,156,157,165,169,172,174,175,176,189,285,419,420,422,488,489,491,492,544,546,1648,1651],[94,157,165,169,172,174,175,176,189,214,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1851],[85,94,157,165,169,172,174,175,176,189,643,1648,1651],[94,157,165,169,172,174,175,176,189,194,214,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1149,1150,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1175,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1186,1192,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1186,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1255,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1256,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1246,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1253,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1187,1188,1189,1190,1191,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1307,1445,1648,1651],[94,157,165,169,172,174,175,176,189,711,1079,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1361,1362,1365,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1360,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1360,1362,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1238,1239,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1330,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1324,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1126,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1321,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1238,1240,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1181,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1127,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1160,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1153,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1154,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1218,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1229,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1222,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1207,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1203,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1200,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1163,1198,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1199,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1225,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1199,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1199,1648,1651],[94,157,165,169,172,174,175,176,189,711,1079,1233,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1240,1241,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1233,1244,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1245,1445,1648,1651],[94,109,112,115,116,157,165,169,172,174,175,176,189,206,1648,1651],[94,112,157,165,169,172,174,175,176,189,194,206,1648,1651],[94,112,116,157,165,169,172,174,175,176,189,206,1648,1651],[94,157,165,169,172,174,175,176,189,194,1648,1651],[94,106,157,165,169,172,174,175,176,189,1648,1651],[94,110,157,165,169,172,174,175,176,189,1648,1651],[94,108,109,112,157,165,169,172,174,175,176,189,206,1648,1651],[94,157,165,169,172,174,175,176,178,189,203,1648,1651],[94,106,157,165,169,172,174,175,176,189,214,1648,1651],[94,108,112,157,165,169,172,174,175,176,178,189,206,1648,1651],[94,103,104,105,107,111,157,165,168,169,172,174,175,176,189,194,206,1648,1651],[94,112,121,129,157,165,169,172,174,175,176,189,1648,1651],[94,104,110,157,165,169,172,174,175,176,189,1648,1651],[94,112,138,139,157,165,169,172,174,175,176,189,1648,1651],[94,104,107,112,157,165,169,172,174,175,176,189,197,206,214,1648,1651],[94,112,157,165,169,172,174,175,176,189,1648,1651],[94,108,112,157,165,169,172,174,175,176,189,206,1648,1651],[94,103,157,165,169,172,174,175,176,189,1648,1651],[94,106,107,108,110,111,112,113,114,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,139,140,141,142,143,157,165,169,172,174,175,176,189,1648,1651],[94,112,131,134,157,165,169,172,174,175,176,189,1648,1651],[94,112,121,122,123,157,165,169,172,174,175,176,189,1648,1651],[94,110,112,122,124,157,165,169,172,174,175,176,189,1648,1651],[94,111,157,165,169,172,174,175,176,189,1648,1651],[94,104,106,112,157,165,169,172,174,175,176,189,1648,1651],[94,112,116,122,124,157,165,169,172,174,175,176,189,1648,1651],[94,116,157,165,169,172,174,175,176,189,1648,1651],[94,110,112,115,157,165,169,172,174,175,176,189,206,1648,1651],[94,104,108,112,121,157,165,169,172,174,175,176,189,1648,1651],[94,112,131,157,165,169,172,174,175,176,189,1648,1651],[94,124,157,165,169,172,174,175,176,189,1648,1651],[94,106,112,138,157,165,169,172,174,175,176,189,197,212,214,1648,1651],[94,157,165,169,172,174,175,176,189,1080,1081,1082,1083,1648,1651],[94,157,165,169,172,174,175,176,189,1080,1648,1651],[94,157,165,169,172,174,175,176,189,1081,1648,1651],[94,157,165,169,172,174,175,176,189,1086,1087,1648,1651],[94,157,165,169,172,174,175,176,189,1086,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,555,559,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,555,559,564,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,555,556,557,558,560,562,563,565,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,555,559,561,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,559,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,558,561,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,555,559,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,568,569,570,571,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,568,572,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,568,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,568,569,570,571,572,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,574,576,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,574,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,574,575,576,577,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,556,558,560,561,562,563,564,565,566,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,559,579,580,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,579,580,581,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,579,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,583,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,590,1098,1580,1583,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,578,582,583,584,585,586,1098,1579,1581,1582,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,557,573,578,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,583,584,586,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,578,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,583,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,573,583,584,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,583,584,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,588,1098,1585,1586,1648,1651],[85,94,157,165,169,172,174,175,176,189,217,219,249,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,587,1098,1585,1588,1589,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,557,582,587,588,1098,1585,1586,1587,1589,1591,1592,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,587,1098,1590,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,587,588,1098,1585,1591,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,588,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,587,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,559,573,578,589,590,591,1098,1594,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,578,590,591,607,1098,1594,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,578,589,590,591,607,1098,1594,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,590,591,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,558,573,578,590,591,1098,1594,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,590,1098,1595,1596,1597,1598,1599,1648,1651],[94,157,165,169,172,174,175,176,189,249,590,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,578,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,593,594,1098,1602,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,1098,1603,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,593,594,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,578,592,1098,1601,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,573,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,592,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,594,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,592,593,594,596,605,634,1098,1604,1605,1608,1610,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,573,593,594,595,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,557,559,573,582,590,592,593,594,596,597,605,1098,1603,1604,1605,1606,1607,1611,1612,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,559,573,578,592,594,1098,1601,1648,1651],[94,157,165,169,172,174,175,176,189,249,593,594,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,573,592,594,596,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,593,594,638,642,1098,1574,1609,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,557,559,590,598,599,600,601,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,598,599,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,598,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,1098,1615,1617,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,602,1098,1578,1584,1593,1600,1613,1614,1648,1651],[94,157,165,169,172,174,175,176,189,249,558,590,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,559,604,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,603,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,603,604,605,606,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,634,1098,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,620,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,621,1098,1575,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,621,622,635,1098,1574,1576,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,620,623,634,1098,1576,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,1098,1576,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,624,625,626,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,624,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,623,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,624,625,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,217,219,249,559,624,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,623,624,625,626,627,628,629,630,631,632,633,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,1098,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,634,637,1098,1574,1648,1651],[85,94,157,160,165,169,172,174,175,176,189,249,484,557,559,620,625,634,637,638,640,642,644,1098,1557,1558,1572,1573,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,636,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,644,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,634,638,641,642,643,644,645,1098,1556,1557,1574,1577,1616,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,1098,1557,1621,1622,1623,1624,1625,1626,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1617,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,634,638,642,645,1098,1557,1574,1616,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,638,641,642,645,1098,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,620,634,638,640,641,642,645,1079,1098,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1556,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,638,642,645,1098,1557,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,638,642,644,645,1098,1557,1574,1577,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,638,642,644,645,1098,1557,1574,1619,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,634,641,645,1098,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,1098,1609,1621,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,638,641,642,645,1098,1557,1574,1648,1651],[94,157,165,169,172,174,175,176,189,249,638,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,641,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,638,642,1098,1648,1651]],"fileInfos":[{"version":"c430d44666289dae81f30fa7b2edebf186ecc91a2d4c71266ea6ae76388792e1","affectsGlobalScope":true,"impliedFormat":1},{"version":"45b7ab580deca34ae9729e97c13cfd999df04416a79116c3bfb483804f85ded4","impliedFormat":1},{"version":"3facaf05f0c5fc569c5649dd359892c98a85557e3e0c847964caeb67076f4d75","impliedFormat":1},{"version":"e44bb8bbac7f10ecc786703fe0a6a4b952189f908707980ba8f3c8975a760962","impliedFormat":1},{"version":"5e1c4c362065a6b95ff952c0eab010f04dcd2c3494e813b493ecfd4fcb9fc0d8","impliedFormat":1},{"version":"68d73b4a11549f9c0b7d352d10e91e5dca8faa3322bfb77b661839c42b1ddec7","impliedFormat":1},{"version":"5efce4fc3c29ea84e8928f97adec086e3dc876365e0982cc8479a07954a3efd4","impliedFormat":1},{"version":"feecb1be483ed332fad555aff858affd90a48ab19ba7272ee084704eb7167569","impliedFormat":1},{"version":"ee7bad0c15b58988daa84371e0b89d313b762ab83cb5b31b8a2d1162e8eb41c2","impliedFormat":1},{"version":"27bdc30a0e32783366a5abeda841bc22757c1797de8681bbe81fbc735eeb1c10","impliedFormat":1},{"version":"8fd575e12870e9944c7e1d62e1f5a73fcf23dd8d3a321f2a2c74c20d022283fe","impliedFormat":1},{"version":"2ab096661c711e4a81cc464fa1e6feb929a54f5340b46b0a07ac6bbf857471f0","impliedFormat":1},{"version":"080941d9f9ff9307f7e27a83bcd888b7c8270716c39af943532438932ec1d0b9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2e80ee7a49e8ac312cc11b77f1475804bee36b3b2bc896bead8b6e1266befb43","affectsGlobalScope":true,"impliedFormat":1},{"version":"c57796738e7f83dbc4b8e65132f11a377649c00dd3eee333f672b8f0a6bea671","affectsGlobalScope":true,"impliedFormat":1},{"version":"dc2df20b1bcdc8c2d34af4926e2c3ab15ffe1160a63e58b7e09833f616efff44","affectsGlobalScope":true,"impliedFormat":1},{"version":"515d0b7b9bea2e31ea4ec968e9edd2c39d3eebf4a2d5cbd04e88639819ae3b71","affectsGlobalScope":true,"impliedFormat":1},{"version":"0559b1f683ac7505ae451f9a96ce4c3c92bdc71411651ca6ddb0e88baaaad6a3","affectsGlobalScope":true,"impliedFormat":1},{"version":"0dc1e7ceda9b8b9b455c3a2d67b0412feab00bd2f66656cd8850e8831b08b537","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce691fb9e5c64efb9547083e4a34091bcbe5bdb41027e310ebba8f7d96a98671","affectsGlobalScope":true,"impliedFormat":1},{"version":"8d697a2a929a5fcb38b7a65594020fcef05ec1630804a33748829c5ff53640d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ff2a353abf8a80ee399af572debb8faab2d33ad38c4b4474cff7f26e7653b8d","affectsGlobalScope":true,"impliedFormat":1},{"version":"fb0f136d372979348d59b3f5020b4cdb81b5504192b1cacff5d1fbba29378aa1","affectsGlobalScope":true,"impliedFormat":1},{"version":"d15bea3d62cbbdb9797079416b8ac375ae99162a7fba5de2c6c505446486ac0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"68d18b664c9d32a7336a70235958b8997ebc1c3b8505f4f1ae2b7e7753b87618","affectsGlobalScope":true,"impliedFormat":1},{"version":"eb3d66c8327153d8fa7dd03f9c58d351107fe824c79e9b56b462935176cdf12a","affectsGlobalScope":true,"impliedFormat":1},{"version":"38f0219c9e23c915ef9790ab1d680440d95419ad264816fa15009a8851e79119","affectsGlobalScope":true,"impliedFormat":1},{"version":"69ab18c3b76cd9b1be3d188eaf8bba06112ebbe2f47f6c322b5105a6fbc45a2e","affectsGlobalScope":true,"impliedFormat":1},{"version":"a680117f487a4d2f30ea46f1b4b7f58bef1480456e18ba53ee85c2746eeca012","affectsGlobalScope":true,"impliedFormat":1},{"version":"2f11ff796926e0832f9ae148008138ad583bd181899ab7dd768a2666700b1893","affectsGlobalScope":true,"impliedFormat":1},{"version":"4de680d5bb41c17f7f68e0419412ca23c98d5749dcaaea1896172f06435891fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"954296b30da6d508a104a3a0b5d96b76495c709785c1d11610908e63481ee667","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac9538681b19688c8eae65811b329d3744af679e0bdfa5d842d0e32524c73e1c","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a969edff4bd52585473d24995c5ef223f6652d6ef46193309b3921d65dd4376","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e9fbd7030c440b33d021da145d3232984c8bb7916f277e8ffd3dc2e3eae2bdb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811ec78f7fefcabbda4bfa93b3eb67d9ae166ef95f9bff989d964061cbf81a0c","affectsGlobalScope":true,"impliedFormat":1},{"version":"717937616a17072082152a2ef351cb51f98802fb4b2fdabd32399843875974ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"d7e7d9b7b50e5f22c915b525acc5a49a7a6584cf8f62d0569e557c5cfc4b2ac2","affectsGlobalScope":true,"impliedFormat":1},{"version":"71c37f4c9543f31dfced6c7840e068c5a5aacb7b89111a4364b1d5276b852557","affectsGlobalScope":true,"impliedFormat":1},{"version":"576711e016cf4f1804676043e6a0a5414252560eb57de9faceee34d79798c850","affectsGlobalScope":true,"impliedFormat":1},{"version":"89c1b1281ba7b8a96efc676b11b264de7a8374c5ea1e6617f11880a13fc56dc6","affectsGlobalScope":true,"impliedFormat":1},{"version":"74f7fa2d027d5b33eb0471c8e82a6c87216223181ec31247c357a3e8e2fddc5b","affectsGlobalScope":true,"impliedFormat":1},{"version":"d6d7ae4d1f1f3772e2a3cde568ed08991a8ae34a080ff1151af28b7f798e22ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"063600664504610fe3e99b717a1223f8b1900087fab0b4cad1496a114744f8df","affectsGlobalScope":true,"impliedFormat":1},{"version":"934019d7e3c81950f9a8426d093458b65d5aff2c7c1511233c0fd5b941e608ab","affectsGlobalScope":true,"impliedFormat":1},{"version":"52ada8e0b6e0482b728070b7639ee42e83a9b1c22d205992756fe020fd9f4a47","affectsGlobalScope":true,"impliedFormat":1},{"version":"3bdefe1bfd4d6dee0e26f928f93ccc128f1b64d5d501ff4a8cf3c6371200e5e6","affectsGlobalScope":true,"impliedFormat":1},{"version":"59fb2c069260b4ba00b5643b907ef5d5341b167e7d1dbf58dfd895658bda2867","affectsGlobalScope":true,"impliedFormat":1},{"version":"639e512c0dfc3fad96a84caad71b8834d66329a1f28dc95e3946c9b58176c73a","affectsGlobalScope":true,"impliedFormat":1},{"version":"368af93f74c9c932edd84c58883e736c9e3d53cec1fe24c0b0ff451f529ceab1","affectsGlobalScope":true,"impliedFormat":1},{"version":"af3dd424cf267428f30ccfc376f47a2c0114546b55c44d8c0f1d57d841e28d74","affectsGlobalScope":true,"impliedFormat":1},{"version":"995c005ab91a498455ea8dfb63aa9f83fa2ea793c3d8aa344be4a1678d06d399","affectsGlobalScope":true,"impliedFormat":1},{"version":"959d36cddf5e7d572a65045b876f2956c973a586da58e5d26cde519184fd9b8a","affectsGlobalScope":true,"impliedFormat":1},{"version":"965f36eae237dd74e6cca203a43e9ca801ce38824ead814728a2807b1910117d","affectsGlobalScope":true,"impliedFormat":1},{"version":"3925a6c820dcb1a06506c90b1577db1fdbf7705d65b62b99dce4be75c637e26b","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a3d63ef2b853447ec4f749d3f368ce642264246e02911fcb1590d8c161b8005","affectsGlobalScope":true,"impliedFormat":1},{"version":"8cdf8847677ac7d20486e54dd3fcf09eda95812ac8ace44b4418da1bbbab6eb8","affectsGlobalScope":true,"impliedFormat":1},{"version":"8444af78980e3b20b49324f4a16ba35024fef3ee069a0eb67616ea6ca821c47a","affectsGlobalScope":true,"impliedFormat":1},{"version":"3287d9d085fbd618c3971944b65b4be57859f5415f495b33a6adc994edd2f004","affectsGlobalScope":true,"impliedFormat":1},{"version":"b4b67b1a91182421f5df999988c690f14d813b9850b40acd06ed44691f6727ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"df83c2a6c73228b625b0beb6669c7ee2a09c914637e2d35170723ad49c0f5cd4","affectsGlobalScope":true,"impliedFormat":1},{"version":"436aaf437562f276ec2ddbee2f2cdedac7664c1e4c1d2c36839ddd582eeb3d0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e3c06ea092138bf9fa5e874a1fdbc9d54805d074bee1de31b99a11e2fec239d","affectsGlobalScope":true,"impliedFormat":1},{"version":"87dc0f382502f5bbce5129bdc0aea21e19a3abbc19259e0b43ae038a9fc4e326","affectsGlobalScope":true,"impliedFormat":1},{"version":"b1cb28af0c891c8c96b2d6b7be76bd394fddcfdb4709a20ba05a7c1605eea0f9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2fef54945a13095fdb9b84f705f2b5994597640c46afeb2ce78352fab4cb3279","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac77cb3e8c6d3565793eb90a8373ee8033146315a3dbead3bde8db5eaf5e5ec6","affectsGlobalScope":true,"impliedFormat":1},{"version":"56e4ed5aab5f5920980066a9409bfaf53e6d21d3f8d020c17e4de584d29600ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ece9f17b3866cc077099c73f4983bddbcb1dc7ddb943227f1ec070f529dedd1","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a6282c8827e4b9a95f4bf4f5c205673ada31b982f50572d27103df8ceb8013c","affectsGlobalScope":true,"impliedFormat":1},{"version":"1c9319a09485199c1f7b0498f2988d6d2249793ef67edda49d1e584746be9032","affectsGlobalScope":true,"impliedFormat":1},{"version":"e3a2a0cee0f03ffdde24d89660eba2685bfbdeae955a6c67e8c4c9fd28928eeb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811c71eee4aa0ac5f7adf713323a5c41b0cf6c4e17367a34fbce379e12bbf0a4","affectsGlobalScope":true,"impliedFormat":1},{"version":"51ad4c928303041605b4d7ae32e0c1ee387d43a24cd6f1ebf4a2699e1076d4fa","affectsGlobalScope":true,"impliedFormat":1},{"version":"60037901da1a425516449b9a20073aa03386cce92f7a1fd902d7602be3a7c2e9","affectsGlobalScope":true,"impliedFormat":1},{"version":"d4b1d2c51d058fc21ec2629fff7a76249dec2e36e12960ea056e3ef89174080f","affectsGlobalScope":true,"impliedFormat":1},{"version":"22adec94ef7047a6c9d1af3cb96be87a335908bf9ef386ae9fd50eeb37f44c47","affectsGlobalScope":true,"impliedFormat":1},{"version":"196cb558a13d4533a5163286f30b0509ce0210e4b316c56c38d4c0fd2fb38405","affectsGlobalScope":true,"impliedFormat":1},{"version":"73f78680d4c08509933daf80947902f6ff41b6230f94dd002ae372620adb0f60","affectsGlobalScope":true,"impliedFormat":1},{"version":"c5239f5c01bcfa9cd32f37c496cf19c61d69d37e48be9de612b541aac915805b","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e7f8264d0fb4c5339605a15daadb037bf238c10b654bb3eee14208f860a32ea","affectsGlobalScope":true,"impliedFormat":1},{"version":"782dec38049b92d4e85c1585fbea5474a219c6984a35b004963b00beb1aab538","affectsGlobalScope":true,"impliedFormat":1},{"version":"7e29f41b158de217f94cb9676bf9cbd0cd9b5a46e1985141ed36e075c52bf6ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac51dd7d31333793807a6abaa5ae168512b6131bd41d9c5b98477fc3b7800f9f","impliedFormat":1},{"version":"bd7dee3446a5b94651d58000ddfda40296f073e9372891f65003a524b4620697","impliedFormat":1},{"version":"acd8fd5090ac73902278889c38336ff3f48af6ba03aa665eb34a75e7ba1dccc4","impliedFormat":1},{"version":"d6258883868fb2680d2ca96bc8b1352cab69874581493e6d52680c5ffecdb6cc","impliedFormat":1},{"version":"1b61d259de5350f8b1e5db06290d31eaebebc6baafd5f79d314b5af9256d7153","impliedFormat":1},{"version":"f258e3960f324a956fc76a3d3d9e964fff2244ff5859dcc6ce5951e5413ca826","impliedFormat":1},{"version":"643f7232d07bf75e15bd8f658f664d6183a0efaca5eb84b48201c7671a266979","impliedFormat":1},{"version":"21da358700a3893281ce0c517a7a30cbd46be020d9f0c3f2834d0a8ad1f5fc75","impliedFormat":1},{"version":"d153a11543fd884b596587ccd97aebbeed950b26933ee000f94009f1ab142848","affectsGlobalScope":true,"impliedFormat":1},{"version":"0ccdaa19852d25ecd84eec365c3bfa16e7859cadecf6e9ca6d0dbbbee439743f","affectsGlobalScope":true,"impliedFormat":1},{"version":"438b41419b1df9f1fbe33b5e1b18f5853432be205991d1b19f5b7f351675541e","affectsGlobalScope":true,"impliedFormat":1},{"version":"096116f8fedc1765d5bd6ef360c257b4a9048e5415054b3bf3c41b07f8951b0b","affectsGlobalScope":true,"impliedFormat":1},{"version":"e5e01375c9e124a83b52ee4b3244ed1a4d214a6cfb54ac73e164a823a4a7860a","affectsGlobalScope":true,"impliedFormat":1},{"version":"f90ae2bbce1505e67f2f6502392e318f5714bae82d2d969185c4a6cecc8af2fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"4b58e207b93a8f1c88bbf2a95ddc686ac83962b13830fe8ad3f404ffc7051fb4","affectsGlobalScope":true,"impliedFormat":1},{"version":"1fefabcb2b06736a66d2904074d56268753654805e829989a46a0161cd8412c5","affectsGlobalScope":true,"impliedFormat":1},{"version":"9798340ffb0d067d69b1ae5b32faa17ab31b82466a3fc00d8f2f2df0c8554aaa","affectsGlobalScope":true,"impliedFormat":1},{"version":"c18a99f01eb788d849ad032b31cafd49de0b19e083fe775370834c5675d7df8e","affectsGlobalScope":true,"impliedFormat":1},{"version":"5247874c2a23b9a62d178ae84f2db6a1d54e6c9a2e7e057e178cc5eea13757fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"cdcf9ea426ad970f96ac930cd176d5c69c6c24eebd9fc580e1572d6c6a88f62c","impliedFormat":1},{"version":"23cd712e2ce083d68afe69224587438e5914b457b8acf87073c22494d706a3d0","impliedFormat":1},{"version":"156a859e21ef3244d13afeeba4e49760a6afa035c149dda52f0c45ea8903b338","impliedFormat":1},{"version":"10ec5e82144dfac6f04fa5d1d6c11763b3e4dbbac6d99101427219ab3e2ae887","impliedFormat":1},{"version":"615754924717c0b1e293e083b83503c0a872717ad5aa60ed7f1a699eb1b4ea5c","impliedFormat":1},{"version":"074de5b2fdead0165a2757e3aaef20f27a6347b1c36adea27d51456795b37682","impliedFormat":1},{"version":"68834d631c8838c715f225509cfc3927913b9cc7a4870460b5b60c8dbdb99baf","impliedFormat":1},{"version":"24371e69a38fc33e268d4a8716dbcda430d6c2c414a99ff9669239c4b8f40dea","impliedFormat":1},{"version":"ccab02f3920fc75c01174c47fcf67882a11daf16baf9e81701d0a94636e94556","impliedFormat":1},{"version":"3e11fce78ad8c0e1d1db4ba5f0652285509be3acdd519529bc8fcef85f7dafd9","impliedFormat":1},{"version":"ea6bc8de8b59f90a7a3960005fd01988f98fd0784e14bc6922dde2e93305ec7d","impliedFormat":1},{"version":"36107995674b29284a115e21a0618c4c2751b32a8766dd4cb3ba740308b16d59","impliedFormat":1},{"version":"914a0ae30d96d71915fc519ccb4efbf2b62c0ddfb3a3fc6129151076bc01dc60","impliedFormat":1},{"version":"9c32412007b5662fd34a8eb04292fb5314ec370d7016d1c2fb8aa193c807fe22","impliedFormat":1},{"version":"7fd1b31fd35876b0aa650811c25ec2c97a3c6387e5473eb18004bed86cdd76b6","impliedFormat":1},{"version":"4d327f7d72ad0918275cea3eee49a6a8dc8114ae1d5b7f3f5d0774de75f7439a","impliedFormat":1},{"version":"6ebe8ebb8659aaa9d1acbf3710d7dae3e923e97610238b9511c25dc39023a166","impliedFormat":1},{"version":"e85d7f8068f6a26710bff0cc8c0fc5e47f71089c3780fbede05857331d2ddec9","impliedFormat":1},{"version":"7befaf0e76b5671be1d47b77fcc65f2b0aad91cc26529df1904f4a7c46d216e9","impliedFormat":1},{"version":"0a60a292b89ca7218b8616f78e5bbd1c96b87e048849469cccb4355e98af959a","impliedFormat":1},{"version":"0b6e25234b4eec6ed96ab138d96eb70b135690d7dd01f3dd8a8ab291c35a683a","impliedFormat":1},{"version":"9666f2f84b985b62400d2e5ab0adae9ff44de9b2a34803c2c5bd3c8325b17dc0","impliedFormat":1},{"version":"40cd35c95e9cf22cfa5bd84e96408b6fcbca55295f4ff822390abb11afbc3dca","impliedFormat":1},{"version":"b1616b8959bf557feb16369c6124a97a0e74ed6f49d1df73bb4b9ddf68acf3f3","impliedFormat":1},{"version":"5b03a034c72146b61573aab280f295b015b9168470f2df05f6080a2122f9b4df","impliedFormat":1},{"version":"40b463c6766ca1b689bfcc46d26b5e295954f32ad43e37ee6953c0a677e4ae2b","impliedFormat":1},{"version":"249b9cab7f5d628b71308c7d9bb0a808b50b091e640ba3ed6e2d0516f4a8d91d","impliedFormat":1},{"version":"80aae6afc67faa5ac0b32b5b8bc8cc9f7fa299cff15cf09cc2e11fd28c6ae29e","impliedFormat":1},{"version":"f473cd2288991ff3221165dcf73cd5d24da30391f87e85b3dd4d0450c787a391","impliedFormat":1},{"version":"499e5b055a5aba1e1998f7311a6c441a369831c70905cc565ceac93c28083d53","impliedFormat":1},{"version":"8aee8b6d4f9f62cf3776cda1305fb18763e2aade7e13cea5bbe699112df85214","impliedFormat":1},{"version":"c63b9ada8c72f95aac5db92aea07e5e87ec810353cdf63b2d78f49a58662cf6c","impliedFormat":1},{"version":"1cc2a09e1a61a5222d4174ab358a9f9de5e906afe79dbf7363d871a7edda3955","impliedFormat":1},{"version":"5d0375ca7310efb77e3ef18d068d53784faf62705e0ad04569597ae0e755c401","impliedFormat":1},{"version":"59af37caec41ecf7b2e76059c9672a49e682c1a2aa6f9d7dc78878f53aa284d6","impliedFormat":1},{"version":"addf417b9eb3f938fddf8d81e96393a165e4be0d4a8b6402292f9c634b1cb00d","impliedFormat":1},{"version":"b64d4d1c5f877f9c666e98e833f0205edb9384acc46e98a1fef344f64d6aba44","impliedFormat":1},{"version":"adf27937dba6af9f08a68c5b1d3fce0ca7d4b960c57e6d6c844e7d1a8e53adae","impliedFormat":1},{"version":"12950411eeab8563b349cb7959543d92d8d02c289ed893d78499a19becb5a8cc","impliedFormat":1},{"version":"2e85db9e6fd73cfa3d7f28e0ab6b55417ea18931423bd47b409a96e4a169e8e6","impliedFormat":1},{"version":"c46e079fe54c76f95c67fb89081b3e399da2c7d109e7dca8e4b58d83e332e605","impliedFormat":1},{"version":"c9381908473a1c92cb8c516b184e75f4d226dad95c3a85a5af35f670064d9a2f","impliedFormat":1},{"version":"c3f5289820990ab66b70c7fb5b63cb674001009ff84b13de40619619a9c8175f","affectsGlobalScope":true,"impliedFormat":1},{"version":"b3275d55fac10b799c9546804126239baf020d220136163f763b55a74e50e750","affectsGlobalScope":true,"impliedFormat":1},{"version":"fa68a0a3b7cb32c00e39ee3cd31f8f15b80cac97dce51b6ee7fc14a1e8deb30b","affectsGlobalScope":true,"impliedFormat":1},{"version":"1cf059eaf468efcc649f8cf6075d3cb98e9a35a0fe9c44419ec3d2f5428d7123","affectsGlobalScope":true,"impliedFormat":1},{"version":"6c36e755bced82df7fb6ce8169265d0a7bb046ab4e2cb6d0da0cb72b22033e89","affectsGlobalScope":true,"impliedFormat":1},{"version":"e7721c4f69f93c91360c26a0a84ee885997d748237ef78ef665b153e622b36c1","affectsGlobalScope":true,"impliedFormat":1},{"version":"7a93de4ff8a63bafe62ba86b89af1df0ccb5e40bb85b0c67d6bbcfdcf96bf3d4","affectsGlobalScope":true,"impliedFormat":1},{"version":"90e85f9bc549dfe2b5749b45fe734144e96cd5d04b38eae244028794e142a77e","affectsGlobalScope":true,"impliedFormat":1},{"version":"e0a5deeb610b2a50a6350bd23df6490036a1773a8a71d70f2f9549ab009e67ee","affectsGlobalScope":true,"impliedFormat":1},{"version":"3fad5618174d74a34ee006406d4eb37e8d07dd62eb1315dbf52f48d31a337547","impliedFormat":1},{"version":"7e49f52a159435fc8df4de9dc377ef5860732ca2dc9efec1640531d3cf5da7a3","impliedFormat":1},{"version":"dd4bde4bdc2e5394aed6855e98cf135dfdf5dd6468cad842e03116d31bbcc9bc","impliedFormat":1},{"version":"4d4e879009a84a47c05350b8dca823036ba3a29a3038efed1be76c9f81e45edf","affectsGlobalScope":true,"impliedFormat":1},{"version":"8b50a819485ffe0d237bf0d131e92178d14d11e2aa873d73615a9ec578b341f5","impliedFormat":1},{"version":"9ba13b47cb450a438e3076c4a3f6afb9dc85e17eae50f26d4b2d72c0688c9251","impliedFormat":1},{"version":"b64cd4401633ea4ecadfd700ddc8323a13b63b106ac7127c1d2726f32424622c","impliedFormat":1},{"version":"37c6e5fe5715814412b43cc9b50b24c67a63c4e04e753e0d1305970d65417a60","impliedFormat":1},{"version":"1d024184fb57c58c5c91823f9d10b4915a4867b7934e89115fd0d861a9df27c8","impliedFormat":1},{"version":"ee0e4946247f842c6dd483cbb60a5e6b484fee07996e3a7bc7343dfb68a04c5d","impliedFormat":1},{"version":"ef051f42b7e0ef5ca04552f54c4552eac84099d64b6c5ad0ef4033574b6035b8","impliedFormat":1},{"version":"853a43154f1d01b0173d9cbd74063507ece57170bad7a3b68f3fa1229ad0a92f","impliedFormat":1},{"version":"56231e3c39a031bfb0afb797690b20ed4537670c93c0318b72d5180833d98b72","impliedFormat":1},{"version":"5cc7c39031bfd8b00ad58f32143d59eb6ffc24f5d41a20931269011dccd36c5e","impliedFormat":1},{"version":"12d602a8fe4c2f2ba4f7804f5eda8ba07e0c83bf5cf0cda8baffa2e9967bfb77","affectsGlobalScope":true,"impliedFormat":1},{"version":"f96a48183254c00d24575401f1a761b4ce4927d927407e7862a83e06ce5d6964","impliedFormat":1},{"version":"cc25940cfb27aa538e60d465f98bb5068d4d7d33131861ace43f04fe6947d68f","impliedFormat":1},{"version":"8db46b61a690f15b245cf16270db044dc047dce9f93b103a59f50262f677ea1f","impliedFormat":1},{"version":"01ff95aa1443e3f7248974e5a771f513cb2ac158c8898f470a1792f817bee497","impliedFormat":1},{"version":"757227c8b345c57d76f7f0e3bbad7a91ffca23f1b2547cbed9e10025816c9cb7","impliedFormat":1},{"version":"42a05d8f239f74587d4926aba8cc54792eed8e8a442c7adc9b38b516642aadfe","impliedFormat":1},{"version":"e843c4c3582948689477a98129c080d2a6919cf44b6b1eed8f992642fe141cf5","impliedFormat":1},{"version":"101f482fd48cb4c7c0468dcc6d62c843d842977aea6235644b1edd05e81fbf22","impliedFormat":1},{"version":"266bee0a41e9c3ba335583e21e9277ae03822402cf5e8e1d99f5196853613b98","affectsGlobalScope":true,"impliedFormat":1},{"version":"386606f8a297988535cb1401959041cfa7f59d54b8a9ed09738e65c98684c976","impliedFormat":1},{"version":"4967529644e391115ca5592184d4b63980569adf60ee685f968fd59ab1557188","impliedFormat":1},{"version":"3ef397f12387eff17f550bc484ea7c27d21d43816bbe609d495107f44b97e933","impliedFormat":1},{"version":"1023282e2ba810bc07905d3668349fbd37a26411f0c8f94a70ef3c05fe523fcf","impliedFormat":1},{"version":"b214ebcf76c51b115453f69729ee8aa7b7f8eccdae2a922b568a45c2d7ff52f7","impliedFormat":1},{"version":"429c9cdfa7d126255779efd7e6d9057ced2d69c81859bbab32073bad52e9ba76","impliedFormat":1},{"version":"e236b5eba291f51bdf32c231673e6cab81b5410850e61f51a7a524dddadc0f95","impliedFormat":1},{"version":"9cc9d479fb2283d21495e1eb22dccce6cbeaa1e2d87832fe390f6b61b1ff537d","affectsGlobalScope":true,"impliedFormat":1},{"version":"7f2c62938251b45715fd2a9887060ec4fbc8724727029d1cbce373747252bdd7","impliedFormat":1},{"version":"e3ace08b6bbd84655d41e244677b474fd995923ffef7149ddb68af8848b60b05","impliedFormat":1},{"version":"132580b0e86c48fab152bab850fc57a4b74fe915c8958d2ccb052b809a44b61c","impliedFormat":1},{"version":"90a278f5fab7557e69e97056c0841adf269c42697194f0bd5c5e69152637d4b3","impliedFormat":1},{"version":"69c9a5a9392e8564bd81116e1ed93b13205201fb44cb35a7fde8c9f9e21c4b23","impliedFormat":1},{"version":"5f8fc37f8434691ffac1bfd8fc2634647da2c0e84253ab5d2dd19a7718915b35","impliedFormat":1},{"version":"5981c2340fd8b076cae8efbae818d42c11ffc615994cb060b1cd390795f1be2b","impliedFormat":1},{"version":"3e4e0959c67965a12a0976d58ba1ef64c49d852aaaf0e91148a64d3681ca22c9","impliedFormat":1},{"version":"1edcf2f36fc332615846bde6dcc71a8fe526065505bc5e3dcfd65a14becdf698","affectsGlobalScope":true,"impliedFormat":1},{"version":"0250da3eb85c99624f974e77ef355cdf86f43980251bc371475c2b397ba55bcd","impliedFormat":1},{"version":"f1c93e046fb3d9b7f8249629f4b63dc068dd839b824dd0aa39a5e68476dc9420","impliedFormat":1},{"version":"3d3a5f27ffbc06c885dd4d5f9ee20de61faf877fe2c3a7051c4825903d9a7fdc","impliedFormat":1},{"version":"12806f9f085598ef930edaf2467a5fa1789a878fba077cd27e85dc5851e11834","impliedFormat":1},{"version":"1c7573c37465af751be31717e70588b16a272a974e790427fc9558b8e9b199d1","impliedFormat":1},{"version":"a43fe41c33d0a192a0ecaf9b92e87bef3709c9972e6d53c42c49251ccb962d69","impliedFormat":1},{"version":"a177959203c017fad3ecc4f3d96c8757a840957a4959a3ae00dab9d35961ca6c","affectsGlobalScope":true,"impliedFormat":1},{"version":"6fc727ccf9b36e257ff982ea0badeffbfc2c151802f741bddff00c6af3b784cf","impliedFormat":1},{"version":"ca279fadaa088b63f123c86ffb4dda5116f8dba23e6e93e63a2b48262320be38","impliedFormat":1},{"version":"4844a4c9b4b1e812b257676ed8a80b3f3be0e29bf05e742cc2ea9c3c6865e6c6","impliedFormat":1},{"version":"064878a60367e0407c42fb7ba02a2ea4d83257357dc20088e549bd4d89433e9c","impliedFormat":1},{"version":"cca8917838a876e2d7016c9b6af57cbf11fdf903c5fdd8e613fa31840b2957bf","impliedFormat":1},{"version":"d91ae55e4282c22b9c21bc26bd3ef637d3fe132507b10529ae68bf76f5de785b","impliedFormat":1},{"version":"b484ec11ba00e3a2235562a41898d55372ccabe607986c6fa4f4aba72093749f","impliedFormat":1},{"version":"bc9b17634d5e75b9040d8b414bb5bc936273e8100212816e905e39948cd9de96","impliedFormat":1},{"version":"41ef7992c555671a8fe54db302788adefa191ded810a50329b79d20a6772d14c","impliedFormat":1},{"version":"041a7781b9127ab568d2cdcce62c58fdea7c7407f40b8c50045d7866a2727130","impliedFormat":1},{"version":"4c5e90ddbcd177ad3f2ffc909ae217c87820f1e968f6959e4b6ba38a8cec935e","impliedFormat":1},{"version":"b70dd9a44e1ac42f030bb12e7d79117eac7cb74170d72d381a1e7913320af23a","impliedFormat":1},{"version":"55cdbeebe76a1fa18bbd7e7bf73350a2173926bd3085bb050cf5a5397025ee4e","impliedFormat":1},{"version":"2beff543f6e9a9701df88daeee3cdd70a34b4a1c11cb4c734472195a5cb2af54","impliedFormat":1},{"version":"2e07abf27aa06353d46f4448c0bbac73431f6065eef7113128a5cd804d0c384d","impliedFormat":1},{"version":"be1cc4d94ea60cbe567bc29ed479d42587bf1e6cba490f123d329976b0fe4ee5","impliedFormat":1},{"version":"42bc0e1a903408137c3df2b06dfd7e402cdab5bbfa5fcfb871b22ebfdb30bd0b","impliedFormat":1},{"version":"9894dafe342b976d251aac58e616ac6df8db91fb9d98934ff9dd103e9e82578f","impliedFormat":1},{"version":"413df52d4ea14472c2fa5bee62f7a40abd1eb49be0b9722ee01ee4e52e63beb2","impliedFormat":1},{"version":"db6d2d9daad8a6d83f281af12ce4355a20b9a3e71b82b9f57cddcca0a8964a96","impliedFormat":1},{"version":"446a50749b24d14deac6f8843e057a6355dd6437d1fac4f9e5ce4a5071f34bff","impliedFormat":1},{"version":"182e9fcbe08ac7c012e0a6e2b5798b4352470be29a64fdc114d23c2bab7d5106","impliedFormat":1},{"version":"2f4e6b4d39426a1b85ecf4bdeb9dddbf4d9b3397d95d8555d46f925c9519ec7d","impliedFormat":1},{"version":"78a2869ad0cbf3f9045dda08c0d4562b7e1b2bfe07b19e0db072f5c3c56e9584","impliedFormat":1},{"version":"89d5d28d4f57e000b836ac273079be1b75710e28ce14750d081fb420d37e2ca5","impliedFormat":1},{"version":"fd4e24ccff3966390600d7f5d6aa1fed5a512e92ada735ea5fbc933d313ad3d3","impliedFormat":1},{"version":"b7cddfe1aa6b86b5fad3c9ccb30d05b3ccb165aebbf112f48d2d8a5f69dd98b1","impliedFormat":1},{"version":"a86f82d646a739041d6702101afa82dcb935c416dd93cbca7fd754fd0282ce1f","impliedFormat":1},{"version":"ad0d1d75d129b1c80f911be438d6b61bfa8703930a8ff2be2f0e1f8a91841c64","impliedFormat":1},{"version":"bd2c7ada3dee03653d3f601011d30072194bc3970cd93208f9588fbdc0c69347","impliedFormat":1},{"version":"e480da45d32313e7174b265674da504f075f59ef326852f0c5a5d863b438ae85","impliedFormat":1},{"version":"ad54850f61fcf5d014e11be80d2f46fea9265cfa7e77456da876f7833ef81769","impliedFormat":1},{"version":"6f7c9e8bd2b5b6a080b07080065f94900bd3c7e5ebbd3047bc33fcce2fab1dd8","impliedFormat":1},{"version":"3e7efde639c6a6c3edb9847b3f61e308bf7a69685b92f665048c45132f51c218","impliedFormat":1},{"version":"df45ca1176e6ac211eae7ddf51336dc075c5314bc5c253651bae639defd5eec5","impliedFormat":1},{"version":"8a0e762ceb20c7e72504feef83d709468a70af4abccb304f32d6b9bac1129b2c","impliedFormat":1},{"version":"da5950ee2a90721df6f3fba45f5d05308f7e4c35835392215dd2cd404505e2de","impliedFormat":1},{"version":"ce75b1aebb33d510ff28af960a9221410a3eaf7f18fc5f21f9404075fba77256","impliedFormat":1},{"version":"f42d5fed19610d485c646a0c430e768115567d078c7fc855c57b0c578b3d6cd3","impliedFormat":1},{"version":"ee8df1cb8d0faaca4013a1b442e99130769ce06f438d18d510fed95890067563","impliedFormat":1},{"version":"d5630f2ad9b4541e5ce891648121022f9412ecdca1820baa1f0104f70fd7eff7","impliedFormat":1},{"version":"4d15375ab13497104bc8fe56fdef2b5fd6853f29255737d23a33fa306ff7fd69","impliedFormat":1},{"version":"2cd3fc1d0d6a1e85baffd2d4f50f5efb192b5446eef567e97c94765402f0aad4","impliedFormat":1},{"version":"e4cbf2f1e89ecccaddd2c045e600ae41b732295953fb06247c7dcbc2d281ed30","impliedFormat":1},{"version":"6dcedaef57dff0d79a05ab0ab602cde74db803d1e765468bf91263786a383e1b","impliedFormat":1},{"version":"8c1697d90c394a6fd955b98eae01238eff628e129b987a68aea10f898a48e7da","impliedFormat":1},{"version":"7580e62139cb2b44a0270c8d01abcbfcba2819a02514a527342447fa69b34ef1","impliedFormat":1},{"version":"42c169fb8c2d42f4f668c624a9a11e719d5d07dacbebb63cbcf7ef365b0a75b3","impliedFormat":1},{"version":"f374cb24e93e7798c4d9e83ff872fa52d2cdb36306392b840a6ddf46cb925cb6","impliedFormat":1},{"version":"d10d63718e1646c2279e3b33831f82c60e31f622b2b7020f1196409ca4c09242","impliedFormat":1},{"version":"106c6025f1d99fd468fd8bf6e5bda724e11e5905a4076c5d29790b6c3745e50c","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"148679c6d0f449210a96e7d2e562d589e56fcde87f843a92808b3ff103f1a774","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"02436d7e9ead85e09a2f8e27d5f47d9464bced31738dec138ca735390815c9f0","impliedFormat":1},{"version":"f8d5ff8eafd37499f2b6a98659dd9b45a321de186b8db6b6142faed0fea3de77","impliedFormat":1},{"version":"c86fe861cf1b4c46a0fb7d74dffe596cf679a2e5e8b1456881313170f092e3fa","impliedFormat":1},{"version":"a22dd55aa4d39906252000ab8e8a1b83b195eef7f4274eb51e457c1f11cf6580","impliedFormat":1},{"version":"540cc83ab772a2c6bc509fe1354f314825b5dba3669efdfbe4693ecd3048e34f","impliedFormat":1},{"version":"121b0696021ab885c570bbeb331be8ad82c6efe2f3b93a6e63874901bebc13e3","impliedFormat":1},{"version":"612d9da66bb046a9c1e2e8d026245ded881fc4b9f98cbfae714415d57ee0ae0b","impliedFormat":1},{"version":"32c2ad9494dad5d11b0564a619fee18f388db6c1e9e2cd3c360b3122549691eb","impliedFormat":1},{"version":"6c301d40aec56a74ec7bd7324e31a728dadf9bfba3e96def02938d3d973534ec","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"aa14cee20aa0db79f8df101fc027d929aec10feb5b8a8da3b9af3895d05b7ba2","impliedFormat":1},{"version":"493c700ac3bd317177b2eb913805c87fe60d4e8af4fb39c41f04ba81fae7e170","impliedFormat":1},{"version":"aeb554d876c6b8c818da2e118d8b11e1e559adbe6bf606cc9a611c1b6c09f670","impliedFormat":1},{"version":"acf5a2ac47b59ca07afa9abbd2b31d001bf7448b041927befae2ea5b1951d9f9","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"d71291eff1e19d8762a908ba947e891af44749f3a2cbc5bd2ec4b72f72ea795f","impliedFormat":1},{"version":"c0480e03db4b816dff2682b347c95f2177699525c54e7e6f6aa8ded890b76be7","impliedFormat":1},{"version":"25a5f6fd3a2243c859eddc99ab5fba11d970af2fe7a5df9c32b7668f76f97b01","impliedFormat":1},{"version":"8d207e1f9d2c30d6f77dfa693f3827c3fbf0d89240297e10bdfe1041d433df68","impliedFormat":1},{"version":"b620391fe8060cf9bedc176a4d01366e6574d7a71e0ac0ab344a4e76576fcbb8","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"2652448ac55a2010a1f71dd141f828b682298d39728f9871e1cdf8696ef443fd","impliedFormat":1},{"version":"d682336018141807fb602709e2d95a192828fcb8d5ba06dda3833a8ea98f69e3","impliedFormat":1},{"version":"6124e973eab8c52cabf3c07575204efc1784aca6b0a30c79eb85fe240a857efa","impliedFormat":1},{"version":"0d891735a21edc75df51f3eb995e18149e119d1ce22fd40db2b260c5960b914e","impliedFormat":1},{"version":"3b414b99a73171e1c4b7b7714e26b87d6c5cb03d200352da5342ab4088a54c85","impliedFormat":1},{"version":"4fbd3116e00ed3a6410499924b6403cc9367fdca303e34838129b328058ede40","impliedFormat":1},{"version":"9c82171d836c47486074e4ca8e059735bf97b205e70b196535b5efd40cbe1bc5","impliedFormat":1},{"version":"8c70ddc0c22d85e56011d49fddfaae3405eb53d47b59327b9dd589e82df672e7","impliedFormat":1},{"version":"2f9c89cbb29d362290531b48880a4024f258c6033aaeb7e59fbc62db26819650","impliedFormat":1},{"version":"a365c4d3bed3be4e4e20793c999c51f5cd7e6792322f14650949d827fbcd170f","impliedFormat":1},{"version":"c5426dbfc1cf90532f66965a7aa8c1136a78d4d0f96d8180ecbfc11d7722f1a5","impliedFormat":1},{"version":"65a15fc47900787c0bd18b603afb98d33ede930bed1798fc984d5ebb78b26cf9","impliedFormat":1},{"version":"9d202701f6e0744adb6314d03d2eb8fc994798fc83d91b691b75b07626a69801","impliedFormat":1},{"version":"de9d2df7663e64e3a91bf495f315a7577e23ba088f2949d5ce9ec96f44fba37d","impliedFormat":1},{"version":"c7af78a2ea7cb1cd009cfb5bdb48cd0b03dad3b54f6da7aab615c2e9e9d570c5","impliedFormat":1},{"version":"1ee45496b5f8bdee6f7abc233355898e5bf9bd51255db65f5ff7ede617ca0027","impliedFormat":1},{"version":"273782b8454e78f6a8b30d2cfbf6860499c930595095fcc1689637115f0eddda","affectsGlobalScope":true,"impliedFormat":1},{"version":"3fbdd025f9d4d820414417eeb4107ffa0078d454a033b506e22d3a23bc3d9c41","affectsGlobalScope":true,"impliedFormat":1},{"version":"dba114fb6a32b355a9cfc26ca2276834d72fe0e94cd2c3494005547025015369","impliedFormat":1},{"version":"a8f8e6ab2fa07b45251f403548b78eaf2022f3c2254df3dc186cb2671fe4996d","affectsGlobalScope":true,"impliedFormat":1},{"version":"fa6c12a7c0f6b84d512f200690bfc74819e99efae69e4c95c4cd30f6884c526e","impliedFormat":1},{"version":"f1c32f9ce9c497da4dc215c3bc84b722ea02497d35f9134db3bb40a8d918b92b","impliedFormat":1},{"version":"b73c319af2cc3ef8f6421308a250f328836531ea3761823b4cabbd133047aefa","affectsGlobalScope":true,"impliedFormat":1},{"version":"e433b0337b8106909e7953015e8fa3f2d30797cea27141d1c5b135365bb975a6","impliedFormat":1},{"version":"9f9bb6755a8ce32d656ffa4763a8144aa4f274d6b69b59d7c32811031467216e","impliedFormat":1},{"version":"5c32bdfbd2d65e8fffbb9fbda04d7165e9181b08dad61154961852366deb7540","impliedFormat":1},{"version":"ddff7fc6edbdc5163a09e22bf8df7bef75f75369ebd7ecea95ba55c4386e2441","impliedFormat":1},{"version":"0c05e9842ec4f8b7bfebfd3ca61604bb8c914ba8da9b5337c4f25da427a005f2","impliedFormat":1},{"version":"faed7a5153215dbd6ebe76dfdcc0af0cfe760f7362bed43284be544308b114cf","impliedFormat":1},{"version":"7029e566b8df176f703fb59fd437a38670c7a0e02c58b2d66dfb5b2e2b2defdb","impliedFormat":1},{"version":"7f2aa4d4989a82530aaac3f72b3dceca90e9c25bee0b1a327e8a08a1262435ad","impliedFormat":1},{"version":"d96b39301d0ded3f1a27b47759676a33a02f6f5049bfcbde81e533fd10f50dcb","impliedFormat":1},{"version":"e9f147ecca73d9346a4c073432843c159ccbe50bdcb678a78f6da10eae2cecf4","impliedFormat":1},{"version":"de061f7d72bd65c06fc1419f841dfdcb29a8e22fe6fa527d1e6eb20b897d4de0","impliedFormat":1},{"version":"663beafc2446079574570cba86e9b15f986f908ddb1b01274509970126fee945","impliedFormat":1},{"version":"a3102887d5058bf4cb5b37fa6964c09e9527c42053b3b5c642b89878620748de","impliedFormat":1},{"version":"0aaaa1727edd29673d85c9b26d7ca4d54e5407a48586903c51b48b7f7d196f61","impliedFormat":1},{"version":"d35bca0b261bff02635758c48e8ab99c61c420d0dfabbcf467e847171d876b7d","impliedFormat":1},{"version":"3bc12c40d90c342ff88a3d876996c555ed5cbee5fe8c3308a240b321f401ee46","impliedFormat":1},{"version":"ba130768aae855a5477e9e148e5c879548e6e7ccbcc56fd1934c8a18ea5b7569","impliedFormat":1},{"version":"2e4f37ffe8862b14d8e24ae8763daaa8340c0df0b859d9a9733def0eee7562d9","impliedFormat":1},{"version":"d38530db0601215d6d767f280e3a3c54b2a83b709e8d9001acb6f61c67e965fc","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"b499af2054a037a162b3b72cd886f48bbf32a3502c865c6e29fac7d2ab3ce0b5","impliedFormat":1},{"version":"b83cb14474fa60c5f3ec660146b97d122f0735627f80d82dd03e8caa39b4388c","impliedFormat":1},{"version":"48773ca557b0319c2ee62ae249cf52a81709e8be139920d6479a66274de7c4ed","impliedFormat":1},{"version":"7274fbffbd7c9589d8d0ffba68157237afd5cecff1e99881ea3399127e60572f","impliedFormat":1},{"version":"b73cbf0a72c8800cf8f96a9acfe94f3ad32ca71342a8908b8ae484d61113f647","impliedFormat":1},{"version":"bae6dd176832f6423966647382c0d7ba9e63f8c167522f09a982f086cd4e8b23","impliedFormat":1},{"version":"20865ac316b8893c1a0cc383ccfc1801443fbcc2a7255be166cf90d03fac88c9","impliedFormat":1},{"version":"c9958eb32126a3843deedda8c22fb97024aa5d6dd588b90af2d7f2bfac540f23","impliedFormat":1},{"version":"461d0ad8ae5f2ff981778af912ba71b37a8426a33301daa00f21c6ccb27f8156","impliedFormat":1},{"version":"e927c2c13c4eaf0a7f17e6022eee8519eb29ef42c4c13a31e81a611ab8c95577","impliedFormat":1},{"version":"fcafff163ca5e66d3b87126e756e1b6dfa8c526aa9cd2a2b0a9da837d81bbd72","impliedFormat":1},{"version":"70246ad95ad8a22bdfe806cb5d383a26c0c6e58e7207ab9c431f1cb175aca657","impliedFormat":1},{"version":"f00f3aa5d64ff46e600648b55a79dcd1333458f7a10da2ed594d9f0a44b76d0b","impliedFormat":1},{"version":"772d8d5eb158b6c92412c03228bd9902ccb1457d7a705b8129814a5d1a6308fc","impliedFormat":1},{"version":"802e797bcab5663b2c9f63f51bdf67eff7c41bc64c0fd65e6da3e7941359e2f7","impliedFormat":1},{"version":"b01bd582a6e41457bc56e6f0f9de4cb17f33f5f3843a7cf8210ac9c18472fb0f","impliedFormat":1},{"version":"8b4327413e5af38cd8cb97c59f48c3c866015d5d642f28518e3a891c469f240e","impliedFormat":1},{"version":"4cceef18d7f088e797a463e90b7a9dad10c6bc667724b7686e3e740ae00122be","impliedFormat":1},{"version":"7ee86fbb3754388e004de0ef9e6505485ddfb3be7640783d6d015711c03d302d","impliedFormat":1},{"version":"cc1954b539604b1e562319119ac7e888172208b32ca873f9a357a92c826bd046","impliedFormat":1},{"version":"a67b87d0281c97dfc1197ef28dfe397fc2c865ccd41f7e32b53f647184cc7307","impliedFormat":1},{"version":"771ffb773f1ddd562492a6b9aaca648192ac3f056f0e1d997678ff97dbb6bf9b","impliedFormat":1},{"version":"43e96a3d5d1411ab40ba2f61d6a3192e58177bcf3b133a80ad2a16591611726d","impliedFormat":1},{"version":"232f70c0cf2b432f3a6e56a8dc3417103eb162292a9fd376d51a3a9ea5fbbf6f","impliedFormat":1},{"version":"bb8f2dbc03533abca2066ce4655c119bff353dd4514375beb93c08590c03e023","impliedFormat":1},{"version":"706dd95827e7ebaabda91d5db2b755233e0952d98570e9c032b0f066a15c1177","affectsGlobalScope":true,"impliedFormat":1},{"version":"0b103e9abfe82d14c0ad06a55d9f91d6747154ef7cacc73cf27ecad2bfb3afcf","impliedFormat":1},{"version":"cd9304972e6d616197fb44fce00540a904f38b54306a1951b5dbeaf3c01ab5bd","impliedFormat":1},{"version":"77438e2c397a3db78407621cfc57241a305b310ddea2c185f1d555248297f587","impliedFormat":1},{"version":"120599fd965257b1f4d0ff794bc696162832d9d8467224f4665f713a3119078b","impliedFormat":1},{"version":"43ba4f2fa8c698f5c304d21a3ef596741e8e85a810b7c1f9b692653791d8d97a","impliedFormat":1},{"version":"5433f33b0a20300cca35d2f229a7fc20b0e8477c44be2affeb21cb464af60c76","impliedFormat":1},{"version":"db036c56f79186da50af66511d37d9fe77fa6793381927292d17f81f787bb195","impliedFormat":1},{"version":"a6805fcafed712aea7759f8bc731014f9d22738c1d6ef9d43b8091d1d48346d5","impliedFormat":1},{"version":"c49469a5349b3cc1965710b5b0f98ed6c028686aa8450bcb3796728873eb923e","impliedFormat":1},{"version":"4a889f2c763edb4d55cb624257272ac10d04a1cad2ed2948b10ed4a7fda2a428","impliedFormat":1},{"version":"7bb79aa2fead87d9d56294ef71e056487e848d7b550c9a367523ee5416c44cfa","impliedFormat":1},{"version":"d88ea80a6447d7391f52352ec97e56b52ebec934a4a4af6e2464cfd8b39c3ba8","impliedFormat":1},{"version":"142617b3cdf902b69c6464c9fbd942b60ab3e733ca18c032b19e0f7e2adbefe8","impliedFormat":1},{"version":"0b603555f1881f87256ffd6344d3e3ed6d466c2e701eabf381f28be8c2125892","impliedFormat":1},{"version":"897e4f7662488e3ecc79e743bdd3b78f13bdb69a97851afa5b440c4211e32ea9","impliedFormat":1},{"version":"e2e1c6d3b2d93add5200bd7bc1a8cccb4e446836b2111ece45db8683a2c765de","impliedFormat":1},{"version":"251b03d5cd243854ce870d9a9a39f491faf69898c5d6b5eee28cc7649c57417b","impliedFormat":1},{"version":"27ff4196654e6373c9af16b6165120e2dd2169f9ad6abb5c935af5abd8c7938c","impliedFormat":1},{"version":"2c4de79f406d137390608e8c0a44fba2ff8e00bacfcae7c9d1781fef10e9440d","impliedFormat":1},{"version":"07ba23a10465791be5d22deaf5ef7de7658774ddff53721e5ea17fedea1bc721","impliedFormat":1},{"version":"dca8c645c5afeb03b1ecedbf16323f33e7d0afaa6256c8e047e6e38087a97f53","impliedFormat":1},{"version":"775f181bd4a533d6f8b5e55ec1d9f1624559720ae8a70e9432258da26b38d27c","impliedFormat":1},{"version":"796273b2edc72e78a04e86d7c58ae94d370ab93a0ddf40b1aa85a37a1c29ecd7","impliedFormat":1},{"version":"5df15a69187d737d6d8d066e189ae4f97e41f4d53712a46b2710ff9f8563ec9f","impliedFormat":1},{"version":"7715134a0cf07dd41a9da2895d708625a3a303a0385e355ecaaf0b8bfaef2550","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"622694a8522b46f6310c2a9b5d2530dde1e2854cb5829354e6d1ff8f371cf469","impliedFormat":1},{"version":"cd8ce8d68567f62dd580b3c3c37777ac3f5b81944c7417f5ea83030eab533385","impliedFormat":1},{"version":"e5c939d896565dcac0f6fbdbada11284e7728ef26a069561c09aa5aa4a788393","impliedFormat":1},{"version":"9e2739b32f741859263fdba0244c194ca8e96da49b430377930b8f721d77c000","impliedFormat":1},{"version":"a9e6c0ff3f8186fccd05752cf75fc94e147c02645087ac6de5cc16403323d870","impliedFormat":1},{"version":"49af4b52f0d4d2304c5f2c6fe5fab3e153e0acc38830d0202821b877c097dd02","impliedFormat":1},{"version":"49c346823ba6d4b12278c12c977fb3a31c06b9ca719015978cb145eb86da1c61","impliedFormat":1},{"version":"bfac6e50eaa7e73bb66b7e052c38fdc8ccfc8dbde2777648642af33cf349f7f1","impliedFormat":1},{"version":"92f7c1a4da7fbfd67a2228d1687d5c2e1faa0ba865a94d3550a3941d7527a45d","impliedFormat":1},{"version":"f53b120213a9289d9a26f5af90c4c686dd71d91487a0aa5451a38366c70dc64b","impliedFormat":1},{"version":"e68b8e5a1df7c1be2bc105141456ecba70215806e1c28bfbc5c12bfce4be6e68","impliedFormat":1},{"version":"511c8f02329808d47d00b859c532ae9115590048b17325a946c74dac48428650","impliedFormat":1},{"version":"57d67b72e06059adc5e9454de26bbfe567d412b962a501d263c75c2db430f40e","impliedFormat":1},{"version":"b5f9e66625783eefcbe3d2da074b2e7ba2066d61ce3fc6ef4f22805ad946cab4","impliedFormat":1},{"version":"e37115962d284b9f7a37c2bdd2add50f88365dde41f5e0ff591ffc48a8ec7575","impliedFormat":1},{"version":"6459054aabb306821a043e02b89d54da508e3a6966601a41e71c166e4ea1474f","impliedFormat":1},{"version":"bb37588926aba35c9283fe8d46ebf4e79ffe976343105f5c6d45f282793352b2","impliedFormat":1},{"version":"f89488602bec98a142072fae7ea5ba99431a569ff580c64b7be39896474799d8","impliedFormat":1},{"version":"bbbc47961f39a57df103cf4ca3bb8f8732b4b6678a18225a0aa76d59c466956c","impliedFormat":1},{"version":"2e6114a7dd6feeef85b2c80120fdbfb59a5529c0dcc5bfa8447b6996c97a69f5","impliedFormat":1},{"version":"2ffb043dc5163458e473b7010859f86e01dc4edffcae0a93d885d028b426a546","impliedFormat":1},{"version":"c8f004e6036aa1c764ad4ec543cf89a5c1893a9535c80ef3f2b653e370de45e6","impliedFormat":1},{"version":"dd80b1e600d00f5c6a6ba23f455b84a7db121219e68f89f10552c54ba46e4dc9","impliedFormat":1},{"version":"b064c36f35de7387d71c599bfcf28875849a1dbc733e82bd26cae3d1cd060521","impliedFormat":1},{"version":"05c7280d72f3ed26f346cbe7cbbbb002fb7f15739197cbbee6ab3fd1a6cb9347","impliedFormat":1},{"version":"8de9fe97fa9e00ec00666fa77ab6e91b35d25af8ca75dabcb01e14ad3299b150","impliedFormat":1},{"version":"04b7b2e0832dfd3c31e81df3975e8d8fda28e7ff999b0aa2932608a8f6661d5c","impliedFormat":1},{"version":"ca2d34c6ed5cbd3070b8b6f32f42ae54adcc6499c1e4b99f0a5798b3f27cc653","impliedFormat":1},{"version":"9ec68995e66dd6b9dac834bf5ae85fde802714ea2e82151a5d1d53ef01b463ef","impliedFormat":1},{"version":"5c4d626b4902f2ef8a1cc146d761d276cef988016dc674e3b98fbad70e64bc9f","impliedFormat":1},{"version":"fdfaa0aad899524962e2955287b5b991ffe3be50f64e02eb60c933ca44644a94","impliedFormat":1},{"version":"53c972a0f9bc3a4ec70fff7314123ea8cfcf75b3703046f767d2dc1eea87b2fb","impliedFormat":1},{"version":"f974e4a06953682a2c15d5bd5114c0284d5abf8bc0fe4da25cb9159427b70072","impliedFormat":1},{"version":"50256e9c31318487f3752b7ac12ff365c8949953e04568009c8705db802776fb","impliedFormat":1},{"version":"7d73b24e7bf31dfb8a931ca6c4245f6bb0814dfae17e4b60c9e194a631fe5f7b","impliedFormat":1},{"version":"d130c5f73768de51402351d5dc7d1b36eaec980ca697846e53156e4ea9911476","impliedFormat":1},{"version":"413586add0cfe7369b64979d4ec2ed56c3f771c0667fbde1bf1f10063ede0b08","impliedFormat":1},{"version":"06472528e998d152375ad3bd8ebcb69ff4694fd8d2effaf60a9d9f25a37a097a","impliedFormat":1},{"version":"7303b45138d2511035056a5901a1490ebdcbf055cbb1276f8629c5121cbe733e","impliedFormat":1},{"version":"27f874cd5327507eeff699a74567f60c1215b94509f4308633a7b01922471ed2","impliedFormat":1},{"version":"a401617604fa1f6ce437b81689563dfdc377069e4c58465dbd8d16069aede0a5","impliedFormat":1},{"version":"2c6cf04bc525caf6546e859e8ef10bfb9573837ec0bc5ec7b53a7b1b8ca72781","impliedFormat":1},{"version":"8695dec09ad439b0ceef3776ea68a232e381135b516878f0901ed2ea114fd0fe","impliedFormat":1},{"version":"304b44b1e97dd4c94697c3313df89a578dca4930a104454c99863f1784a54357","impliedFormat":1},{"version":"0a437ae178f999b46b6153d79095b60c42c996bc0458c04955f1c996dc68b971","impliedFormat":1},{"version":"74b2a5e5197bd0f2e0077a1ea7c07455bbea67b87b0869d9786d55104006784f","impliedFormat":1},{"version":"4a7baeb6325920044f66c0f8e5e6f1f52e06e6d87588d837bdf44feb6f35c664","impliedFormat":1},{"version":"87cc05fe13108f02e12da7e3efd8e360fef78d96a0c9e11408ea1b1b9fb3e03d","impliedFormat":1},{"version":"1abbf67c218d23c2ce76887caac2df6c7dab3d97ba2b65348432b876f510002a","impliedFormat":1},{"version":"1a82deef4c1d39f6882f28d275cad4c01f907b9b39be9cbc472fcf2cf051e05b","impliedFormat":1},{"version":"4b20fcf10a5413680e39f5666464859fc56b1003e7dfe2405ced82371ebd49b6","impliedFormat":1},{"version":"c06ef3b2569b1c1ad99fcd7fe5fba8d466e2619da5375dfa940a94e0feea899b","impliedFormat":1},{"version":"f7d628893c9fa52ba3ab01bcb5e79191636c4331ee5667ecc6373cbccff8ae12","impliedFormat":1},{"version":"1d879125d1ec570bf04bc1f362fdbe0cb538315c7ac4bcfcdf0c1e9670846aa6","impliedFormat":1},{"version":"dad97c99382889e9c7d1a9d8275500ff71235130fae9f8916fdbf3641d56e592","impliedFormat":1},{"version":"a6dba407fc287f1e25454e75028c91bbc00675f2d1c4e8b3edcc36c08611a486","impliedFormat":1},{"version":"d663134457d8d669ae0df34eabd57028bddc04fc444c4bc04bc5215afc91e1f4","impliedFormat":1},{"version":"e91f7b1344577a02f051b9b471f33044fef8334a76dc9e1de003d17595a5219b","impliedFormat":1},{"version":"c0723195c85e19656d6b5b9fdb81d3f3403c1ae4679e722c6ea058c516b38d12","impliedFormat":1},{"version":"b55eb9f72166093b5460d34b34f5d8699c968de3bc3fc696e40f2c93f2ebf650","impliedFormat":1},{"version":"71d9eb4c4e99456b78ae182fb20a5dfc20eb1667f091dbb9335b3c017dd1c783","impliedFormat":1},{"version":"cfa846a7b7847a1d973605fbb8c91f47f3a0f0643c18ac05c47077ebc72e71c7","impliedFormat":1},{"version":"1594da19968752a22b2ac48c2d0e60575700e745c577a8a4a676b841238ad5bb","impliedFormat":1},{"version":"e0cee12109e0a10a4c3d6769fcc7644b7c1ea7f52365bea51728f5af29f8a137","impliedFormat":1},{"version":"7d4254b4c6c67a29d5e7f65e67d72540480ac2cfb041ca484847f5ae70480b62","impliedFormat":1},{"version":"3536968defef8a75514f547ead5e2e9c1e984820290ec9b00c5fdfb6ef786535","impliedFormat":1},{"version":"d83773870080c30a230e322ce13a9c6f3398e8dacea4ea8a83e26370f3bac23e","impliedFormat":1},{"version":"dcfeaf98d66314fec29a9076c4290e45d0b196a65827becc19138e9c7b855f37","impliedFormat":1},{"version":"6849fe9210fe4946d5f085bfed36758f33dc6ae15a751338d178dd4daa017c46","impliedFormat":1},{"version":"888cda0fa66d7f74e985a3f7b1af1f64b8ff03eb3d5e80d051c3cbdeb7f32ab7","impliedFormat":1},{"version":"60681e13f3545be5e9477acb752b741eae6eaf4cc01658a25ec05bff8b82a2ef","impliedFormat":1},{"version":"ffae4e1e06aa848a1e4bcef162cd1c48e5909b26223515981310af9c036bdfc7","impliedFormat":1},{"version":"a57b1802794433adec9ff3fed12aa79d671faed86c49b09e02e1ac41b4f1d33a","impliedFormat":1},{"version":"34e16eb7c31768a11a08aebcfb3d70d7b8f0b016197e98d8419e566ceae6d6c8","impliedFormat":1},{"version":"f94ec1f7e4b709d26960306c9082a7a1b728a6e13089346aa48ba57c74cbf47e","impliedFormat":1},{"version":"9a11cb4033405e96c247cd5aa29790212aaffdd127869e8a5219103f0b389fd5","impliedFormat":1},{"version":"01479d9d5a5dda16d529b91811375187f61a06e74be294a35ecce77e0b9e8d6c","impliedFormat":1},{"version":"aff5213585cb72e94054dfe17250ff315f3569b3919d1ef1ad235f37c4ee894e","impliedFormat":1},{"version":"fb2ea35e1be6388d722d7725e2b49c697d34d9c890c3b96758faaeb86d35cef8","impliedFormat":1},{"version":"ce0df82a9ae6f914ba08409d4d883983cc08e6d59eb2df02d8e4d68309e7848b","impliedFormat":1},{"version":"1a4dc28334a926d90ba6a2d811ba0ff6c22775fcc13679521f034c124269fd40","impliedFormat":1},{"version":"f05315ff85714f0b87cc0b54bcd3dde2716e5a6b99aedcc19cad02bf2403e08c","impliedFormat":1},{"version":"5fad3b31fc17a5bc58095118a8b160f5260964787c52e7eb51e3d4fcf5d4a6f0","impliedFormat":1},{"version":"72105519d0390262cf0abe84cf41c926ade0ff475d35eb21307b2f94de985778","impliedFormat":1},{"version":"456006a6975b26c0a1785feddae165f6d307e2d601ffde27e21fc4a790e448a4","impliedFormat":1},{"version":"c857e0aae3f5f444abd791ec81206020fbcc1223e187316677e026d1c1d6fe08","impliedFormat":1},{"version":"ccf6dd45b708fb74ba9ed0f2478d4eb9195c9dfef0ff83a6092fa3cf2ff53b4f","impliedFormat":1},{"version":"1fe0d18b111e1145a7e7601855bccd4ca20f24e3b9a5aba6bb1fa9d1a7059170","impliedFormat":1},{"version":"5632c3c26d420c063eebe64c45b1248b9492a67bf44f1d0c57e9dc8f6cf449bb","impliedFormat":1},{"version":"0df5aa619ab12993a39ea6dae062ee46eadbb4d738916460e636ada52bced75b","impliedFormat":1},{"version":"8fca3039857709484e5893c05c1f9126ab7451fa6c29e19bb8c2411a2e937345","impliedFormat":1},{"version":"35069c2c417bd7443ae7c7cafd1de02f665bf015479fec998985ffbbf500628c","impliedFormat":1},{"version":"10ab7be91f87ebe8916b62cf28af2e45b5601fc7b0e311adf838f912c6b31dd8","impliedFormat":1},{"version":"bc636fbc08e0979ceb7eb0731a33000283d77a33b62e1f71ee65be50394e40ba","impliedFormat":1},{"version":"7e0b7f91c5ab6e33f511efc640d36e6f933510b11be24f98836a20a2dc914c2d","impliedFormat":1},{"version":"045b752f44bf9bbdcaffd882424ab0e15cb8d11fa94e1448942e338c8ef19fba","impliedFormat":1},{"version":"2894c56cad581928bb37607810af011764a2f511f575d28c9f4af0f2ef02d1ab","impliedFormat":1},{"version":"0a72186f94215d020cb386f7dca81d7495ab6c17066eb07d0f44a5bf33c1b21a","impliedFormat":1},{"version":"75bbd3be047d539988a0ff0b56384ef7a6a25f3b676ad96bee547d44c31622a7","impliedFormat":1},{"version":"42960001a776b089ade681ab5cfddc936e0afb0615133ec1841f3dee89d3e1bf","impliedFormat":1},{"version":"0aedb02516baf3e66b2c1db9fef50666d6ed257edac0f866ea32f1aa05aa474f","impliedFormat":1},{"version":"da47712b394d944328245482603bc6f416d3949b67c9392279caab595076b510","affectsGlobalScope":true,"impliedFormat":1},{"version":"37d0071d8f0a06dc55c2c5e0ec3391affd4fd107c53410bf358196ec0bf3923f","impliedFormat":1},{"version":"b213dad76ca37fd552274c9499056e1c0d9c1bd38a55bb7f68b22ba6b84c3ad7","impliedFormat":1},{"version":"56ccb49443bfb72e5952f7012f0de1a8679f9f75fc93a5c1ac0bafb28725fc5f","impliedFormat":1},{"version":"20fa37b636fdcc1746ea0738f733d0aed17890d1cd7cb1b2f37010222c23f13e","impliedFormat":1},{"version":"d90b9f1520366d713a73bd30c5a9eb0040d0fb6076aff370796bc776fd705943","impliedFormat":1},{"version":"bc03c3c352f689e38c0ddd50c39b1e65d59273991bfc8858a9e3c0ebb79c023b","impliedFormat":1},{"version":"19df3488557c2fc9b4d8f0bac0fd20fb59aa19dec67c81f93813951a81a867f8","affectsGlobalScope":true,"impliedFormat":1},{"version":"b25350193e103ae90423c5418ddb0ad1168dc9c393c9295ef34980b990030617","affectsGlobalScope":true,"impliedFormat":1},{"version":"bef86adb77316505c6b471da1d9b8c9e428867c2566270e8894d4d773a1c4dc2","impliedFormat":1},{"version":"5a49adaef698b7ad7e6127949fa1b0bbd3d46b7cbd11c54e392a4dcdd51f5190","impliedFormat":1},{"version":"6ee598cdfdd0fa52039dca135b3dfff7b49035dc13292143e0a93843e3861967","impliedFormat":1},{"version":"27be6622e2922a1b412eb057faa854831b95db9db5035c3f6d4b677b902ab3b7","impliedFormat":1},{"version":"5c634644d45a1b6bc7b05e71e05e52ec04f3d73d9ac85d5927f647a5f965181a","impliedFormat":1},{"version":"2489bf04d77dc025ba67f49f1a56eb24b9db477d5ff88123d887e163ed1776aa","impliedFormat":1},{"version":"63a7595a5015e65262557f883463f934904959da563b4f788306f699411e9bac","impliedFormat":1},{"version":"4ba137d6553965703b6b55fd2000b4e07ba365f8caeb0359162ad7247f9707a6","impliedFormat":1},{"version":"0b77b819b5417775fccb20c678293cf614c054a5b1a65421a5b933a9124ba998","impliedFormat":1},{"version":"eb5acb58487367e502d994b57e2c58255d8241f481ea8efa8e79af23af3f41c2","impliedFormat":1},{"version":"9252d498a77517aab5d8d4b5eb9d71e4b225bbc7123df9713e08181de63180f6","impliedFormat":1},{"version":"b1f1d57fde8247599731b24a733395c880a6561ec0c882efaaf20d7df968c5af","impliedFormat":1},{"version":"6715dc4eb59c8ea9abe2b78c235ed331dc710a06fe56798868dbc4d40cd1b707","impliedFormat":1},{"version":"35e6379c3f7cb27b111ad4c1aa69538fd8e788ab737b8ff7596a1b40e96f4f90","impliedFormat":1},{"version":"1fffe726740f9787f15b532e1dc870af3cd964dbe29e191e76121aa3dd8693f2","impliedFormat":1},{"version":"5a3ea721d03a361ccbdd7390ccd75f6e84cbca3a3f01f4b331ecc9af31890c49","impliedFormat":1},{"version":"e7dfaee4af38d45b1cab8a1ee0b3bc1f85ddcf64545ed391d675d78ae6526274","affectsGlobalScope":true,"impliedFormat":1},{"version":"e8daa443eaf9a27fd382cc1f8ebe30330c0f4d89511cfb469166874806751d35","impliedFormat":1},{"version":"af48e58339188d5737b608d41411a9c054685413d8ae88b8c1d0d9bfabdf6e7e","impliedFormat":1},{"version":"616775f16134fa9d01fc677ad3f76e68c051a056c22ab552c64cc281a9686790","impliedFormat":1},{"version":"65c24a8baa2cca1de069a0ba9fba82a173690f52d7e2d0f1f7542d59d5eb4db0","impliedFormat":1},{"version":"f9fe6af238339a0e5f7563acee3178f51db37f32a2e7c09f85273098cee7ec49","impliedFormat":1},{"version":"1de8c302fd35220d8f29dea378a4ae45199dc8ff83ca9923aca1400f2b28848a","impliedFormat":1},{"version":"77e71242e71ebf8528c5802993697878f0533db8f2299b4d36aa015bae08a79c","impliedFormat":1},{"version":"98a787be42bd92f8c2a37d7df5f13e5992da0d967fab794adbb7ee18370f9849","impliedFormat":1},{"version":"332248ee37cca52903572e66c11bef755ccc6e235835e63d3c3e60ddda3e9b93","impliedFormat":1},{"version":"94e8cc88ae2ef3d920bb3bdc369f48436db123aa2dc07f683309ad8c9968a1e1","impliedFormat":1},{"version":"4545c1a1ceca170d5d83452dd7c4994644c35cf676a671412601689d9a62da35","impliedFormat":1},{"version":"320f4091e33548b554d2214ce5fc31c96631b513dffa806e2e3a60766c8c49d9","impliedFormat":1},{"version":"a2d648d333cf67b9aeac5d81a1a379d563a8ffa91ddd61c6179f68de724260ff","impliedFormat":1},{"version":"d90d5f524de38889d1e1dbc2aeef00060d779f8688c02766ddb9ca195e4a713d","impliedFormat":1},{"version":"07ed3ddab975995eea41b22f3010506fb9f5fb301d04820b07d7a1aee5477d7c","impliedFormat":1},{"version":"969d8b0965849f4bae7cab0ba90bd1e1220e95999c2c6f01117fa7500901c017","impliedFormat":1},{"version":"6ec840ee5e2bc103f557fe38b1d585ee250540468713d7634ee066de372bf332","impliedFormat":1},{"version":"b0309e1eda99a9e76f87c18992d9c3689b0938266242835dd4611f2b69efe456","impliedFormat":1},{"version":"47699512e6d8bebf7be488182427189f999affe3addc1c87c882d36b7f2d0b0e","impliedFormat":1},{"version":"6ceb10ca57943be87ff9debe978f4ab73593c0c85ee802c051a93fc96aaf7a20","impliedFormat":1},{"version":"1de3ffe0cc28a9fe2ac761ece075826836b5a02f340b412510a59ba1d41a505a","impliedFormat":1},{"version":"e46d6cc08d243d8d0d83986f609d830991f00450fb234f5b2f861648c42dc0d8","impliedFormat":1},{"version":"1c0a98de1323051010ce5b958ad47bc1c007f7921973123c999300e2b7b0ecc0","impliedFormat":1},{"version":"ff863d17c6c659440f7c5c536e4db7762d8c2565547b2608f36b798a743606ca","impliedFormat":1},{"version":"5412ad0043cd60d1f1406fc12cb4fb987e9a734decbdd4db6f6acf71791e36fe","impliedFormat":1},{"version":"ad036a85efcd9e5b4f7dd5c1a7362c8478f9a3b6c3554654ca24a29aa850a9c5","impliedFormat":1},{"version":"fedebeae32c5cdd1a85b4e0504a01996e4a8adf3dfa72876920d3dd6e42978e7","impliedFormat":1},{"version":"e297c0a524edee7677939122f90027bfbe5f2698939d9a85728e5044b39c7124","impliedFormat":1},{"version":"cdf21eee8007e339b1b9945abf4a7b44930b1d695cc528459e68a3adc39a622e","impliedFormat":1},{"version":"bc9ee0192f056b3d5527bcd78dc3f9e527a9ba2bdc0a2c296fbc9027147df4b2","impliedFormat":1},{"version":"b62381cae176db34f003cc6172ee8f3e0122014889d66391aa73698105cf4934","impliedFormat":1},{"version":"1d9c0a9a6df4e8f29dc84c25c5aa0bb1da5456ebede7a03e03df08bb8b27bae6","impliedFormat":1},{"version":"84380af21da938a567c65ef95aefb5354f676368ee1a1cbb4cae81604a4c7d17","impliedFormat":1},{"version":"1af3e1f2a5d1332e136f8b0b95c0e6c0a02aaabd5092b36b64f3042a03debf28","impliedFormat":1},{"version":"30d8da250766efa99490fc02801047c2c6d72dd0da1bba6581c7e80d1d8842a4","impliedFormat":1},{"version":"03566202f5553bd2d9de22dfab0c61aa163cabb64f0223c08431fb3fc8f70280","impliedFormat":1},{"version":"41eb514d9ce0a6e87957f08a4b7af70d93f87637f37dee706e2d92a6601c25a9","impliedFormat":1},{"version":"e7765aa8bcb74a38b3230d212b4547686eb9796621ffb4367a104451c3f9614f","impliedFormat":1},{"version":"1de80059b8078ea5749941c9f863aa970b4735bdbb003be4925c853a8b6b4450","impliedFormat":1},{"version":"1d079c37fa53e3c21ed3fa214a27507bda9991f2a41458705b19ed8c2b61173d","impliedFormat":1},{"version":"5bf5c7a44e779790d1eb54c234b668b15e34affa95e78eada73e5757f61ed76a","impliedFormat":1},{"version":"5835a6e0d7cd2738e56b671af0e561e7c1b4fb77751383672f4b009f4e161d70","impliedFormat":1},{"version":"4b7f74b772140395e7af67c4841be1ab867c11b3b82a51b1aeb692822b76c872","impliedFormat":1},{"version":"7bd01f0f28cd3aeb2046274d85208e245965f6f2948edf4f7b2057bcf9f22ccc","impliedFormat":99},{"version":"d2f2cf2b8cc92bea913cda4a076e0f790b23a21e84f989d12f0116a7fe3906e0","impliedFormat":99},{"version":"6de125ea94866c736c6d58d68eb15272cf7d1020a5b459fea1c660027eca9a90","affectsGlobalScope":true,"impliedFormat":1},{"version":"f5b20bc288ee49989c95b20847fc93b96bf61cc0845598897a6a53a967dd7d07","affectsGlobalScope":true,"impliedFormat":1},{"version":"064ac1c2ac4b2867c2ceaa74bbdce0cb6a4c16e7c31a6497097159c18f74aa7c","impliedFormat":1},{"version":"3dc14e1ab45e497e5d5e4295271d54ff689aeae00b4277979fdd10fa563540ae","impliedFormat":1},{"version":"d3b315763d91265d6b0e7e7fa93cfdb8a80ce7cdd2d9f55ba0f37a22db00bdb8","impliedFormat":1},{"version":"f31c4f2e95ea48a5359b8b12d88e7f9df3e84c55297384c7ba6321fee2bca54c","affectsGlobalScope":true},"ae8d85097b2e3ca7910e75a092754a9de290a942051cc11af8fc10bfc6fb1fe5","08b16fa5ec6827b78461463bb8b8d3416c4b2237df8055161aa2b41a45de9631","d9cd90ae269f326eac20dd51658fc66c07d8dd7df401059e80facfcfdebbd95d","8c32f95805603eec3f9df5f16d63016cb4521a069774c80b3cbb33d772a61d27","d0541498b8ffe3f0810dc1f4bab9b7cdbc2e567cbef3bcf676c77a554150ceba","b7da7aa99a62fc2189ab75e2f606b72f448484a33e5f3ac0720ca39482772db2",{"version":"1dfdec0ec9c299625d20c5cb8f96e2a801c81d91669c6245f520e8734a92fb3d","impliedFormat":1},"e41d55ec6e3b685a818a601aa7dff02a8dd68842125cd0bae50f1162a93a5738","d43879eb72c4143f6f92099a9f6a8107b0a6d865c7f2a5d73ff67bb73abab1af","14d2410b254ce3e227fcfe74f24f5dce18aeb499a8c8c8b488a6cf8aa1a2ae6f","ba4f3d5afb5c3f38ca6c16c12c6b0c91c461857a5b94dfdfa9ad2bf7b0c9933e","bba517f643c523e46369fbaa55c2963dfd6150ff0cdbef54c2a8ecc99ea8ffbb","bf595ac8c5518a2e2539fd9e66ede0e1d73e89addc5b02c3cebae42231d507a6","fef69ddc966de18a819aa844ad9ce197c362c75e3f9f6a9be1a2b79345f20b10","18c2404f1e7f9c5f1a0684b9f3a37118a7b180298d003a734f31b35f66a22bb4","961d074ef6c51ff899d1ca1073fc015647183701e90ede472a4ff3c64be77afe","289a91c03a072be4358fded46a7ea7ead5d4388c84e28c5167d5d7fae5422db3","6add98f953747a4f57dfeba9cc05cc538bf2d6f4c178133af985904d2ad7ed44","7dbbc095661fc3931fd9010979ee76bca923383662fbed0c8aafac4adfa16377","7d97c4c275368f6dce9a7daab4ee39dbbc522c04fa53bcf72d3d7252c58b43bb","badf8c46467a7eeee968d184b1815966d2967893783f908b54772174f071d8ac","90c2762d08fe1d9f0b7eb1aa8b6f0548454835d92bce49e66b141be1e742c313","15d32674ac63504ff4626a7ba14671bd79cfd6badfa675cecfe0e810d58f70d2","c3c8d65911e0f4ce15b649ba59b33d4bae3aef4f5a0eb0c0539469878bff9e1b","7cd2985d47d3693bcffbaa6c8b877249d60a6010d56d5bc092cd21ea4bacf53f","506053623e708163d08eb391adce33e5183dce4b2e4874a27a0f326719802ac4","456404f4ab6e2bc310dce007f013e33ca7068717fd9d46e2ac5c323a17682e68","1b634365ff92792fafac251a2e7fd5e40f39a2aa8acb8603af2df65bd6406253","9f7434398b2c04b4000b982deecdf4a8c2556a5d9eb41bbad996e72d55fbd665","4a81e60de094f4e76cdef27220c0ceef66ac115c20b931db2d64c8cffba040f3","03a8052a3c163c543aac1df6fa28dceb02e6449e66a545894d5e58800b6983be","c414ecaff699cc052345486dcb0a8fd15297d4b937c63c4d7555fb8cfbc9e246","51fb71bb549769160d2d7ba00c7f7a8a757777a2f82e1ed6cbc28eb1b1e8d550","9fa0db2a413974b233b1772c1a7ba20cb207c9a69296201e116b2a4ea67517e9","c6552f2c41a799b5a83385bcf4ffd06c5445c4799501642332df5be94f638976","378962f1a6794913320d10ae1806e2a3d16e79d050e4b6164555d54e69b6bd68","d0bd3f295852f766084a428db3a267b8ceab8721e4ee42aa431aae6a0fbe7515","604d54ca2485a17a16ecfd235ca0924606ad5627e6c994ee4836de7da31a80fe","f54d21f0ee4bea6c6d2600bb0540ebf3bc8f8efa906f66a2b880e4bbd7a534f3","e859cd3fc426f7e33f0f01c22d68642890c4369667b2bf7292fbffece47f4d9f","c22c49274f197d70ddcf8f409b2ddda249f58e141fd24cac2de2afbe6e67841e","21f924231e3a0dd240fa297b0702ccaa45fa5335140e48ab355a45bed2d5714e","bb4a859dc8cad3715529deb3cca425d0a18a270af43ac4006125e6fd63d45863","71665c31058b210df2433d3f660e67e2b220b6f816f3e8220b2026aa40e387b4","cfd5c399ffa9ff9da19ccf9f8fc75968116e8258fa736fca60fb41c5a340f4f8","ef39dd3b68894e75685b87924a2a39dada129ef9bb93f1b28e7b5a9f932d9f21","fa6582d402c561447d5c6ecb02a9d13d49dc0e11a34fecfb424cf723be8649b6","5105756f9e6311aa4db5096bdb3256d23f2d3af3b2f07316af3b86983a78eec6","e299f731ba4a09752b014b9821c0df0c80c7de65bb879313cc28d7dbec460ba3","5cdb84c45be3f1a9e68133e616515e9854f062a20e4e3ad9ba313a863eb53929","c18e34946bf3dee1677af389eeb04017f7a7c962f1659034031246d459559336","85438192af2cce03087c9a7bb9bab8302adebb0106a3f17244fd87097b32238f","f4a5b725c377699d3eee7073531b812314b1a183f89f8dd73ab5f73218885054","b7ecc5372362a545ebc53009a7aa4bff0b7b10368e8005ddefa48b564eec065d","ae99e81ddf03f4e0722ae28e33b9b8932539410e6cab49fd3085b5acaccef613",{"version":"380b919bfa0516118edaf25b99e45f855e7bc3fd75ce4163a1cfe4a666388804","impliedFormat":1},{"version":"40de86ced5175a6ffe84a52abe6ac59ac0efbc604a5975a8c6476c3ddc682ff1","impliedFormat":1},{"version":"fcf79300e5257a23ed3bacaa6861d7c645139c6f7ece134d15e6669447e5e6db","impliedFormat":1},{"version":"187119ff4f9553676a884e296089e131e8cc01691c546273b1d0089c3533ce42","impliedFormat":1},{"version":"aa2c18a1b5a086bbcaae10a4efba409cc95ba7287d8cf8f2591b53704fea3dea","impliedFormat":1},{"version":"5a0b15210129310cee9fa6af9200714bb4b12af4a04d890e15f34dbea1cf1852","impliedFormat":1},{"version":"0244119dbcbcf34faf3ffdae72dab1e9bc2bc9efc3c477b2240ffa94af3bca56","impliedFormat":1},{"version":"00baffbe8a2f2e4875367479489b5d43b5fc1429ecb4a4cc98cfc3009095f52a","impliedFormat":1},{"version":"a873c50d3e47c21aa09fbe1e2023d9a44efb07cc0cb8c72f418bf301b0771fd3","impliedFormat":1},{"version":"7c14ccd2eaa82619fffc1bfa877eb68a012e9fb723d07ee98db451fadb618906","impliedFormat":1},{"version":"49c36529ee09ea9ce19525af5bb84985ea8e782cb7ee8c493d9e36d027a3d019","impliedFormat":1},{"version":"df996e25faa505f85aeb294d15ebe61b399cf1d1e49959cdfaf2cc0815c203f9","impliedFormat":1},{"version":"4f6a12044ee6f458db11964153830abbc499e73d065c51c329ec97407f4b13dd","impliedFormat":1},"a954453e91ad849d0b72c1ffce1e6473e36dba89ac9753c10f88d3496e970469","d72383872d59e93e649943cc95b22d8ec044ea304cf282ab961463f66b97aa81","b877866b3183e4e11374b6c985aa073ca020a6da061e365fbb26882fbcb78932","6f0eaf74ca1d561aa69047935c346375a00aa9afc8b798b02a21116c331794e6","969b707247da9eb5079cf5cf4c940ad6ce46ab4c26d957f98692e897e6bc2fc0","fadd3b2a6010f5554f4e8732700d283f53d309d9fdaba4f8338b1fbe2cbfcf37","02e2fce631ff37cc6989d91f9a648c496111bf05d8240cf71fdcbab1c5725c00","0097f0e67aa4dbb698b7f56a19607af5216618025cb852f914e7f1e412a6e799","96636313d5d6c3dd1d0f8d2fdbe777f43ae283b17ce704259da29bb265a137cd","303da22472180b5bc8f931a4f66b347afbe3ab1eefd9b4ad658bab0f714d342f","d5e17431c18ff94fe4b4588284327433aa4b91519e2f18a53999565b99d9dd97","1e9dbd778d0303fb9650987349b4f2d46ffb505567b80a5353b859e3fba363a6","8df85af41d3bcadf70b2854078f3a1e92bfab08b2a6dd21597dfe8bc1e7ae164","efd73a3819f444c546b33cc043b5abee26da294f62098db9464df49fb0c822ed","65b7c05d37ae593fd742f594bbd1c600fc9c833631744e8cad6a3a4e342a097b","cbe9cebdd594d19b1afb49b7e73b87384afda3c616fe55434bfb51d12634f07b","b6256df7361e9de91305ff4f3965f1bf4218bc27dc59fc03ae86656ac277293d","06b46e0436118c77c1dd3dfb5ada140b04f721c3bf811b2a9ffe67392f9273f0",{"version":"ee09b9348d02aec6cd1cebb94c27896c10d47efa042a3fbc9c90dd6a7f6af752","impliedFormat":1},{"version":"bf673997a66d2225f43fe1b51cdddd497d0a8c08a990ee331457f2d017563075","impliedFormat":1},"f5adf462de6f79e70149f4f72db3a5dbce8ad78c5dc8ccd13986eeed7b820936","5a20aae73fc38f37c1b00f6a8afc57f31f7854f41daa3ed88b33f9183ae74669",{"version":"e85d04f57b46201ddc8ba238a84322432a4803a5d65e0bbd8b3b4f05345edd51","impliedFormat":1},{"version":"713140d254961f506a4077c1b6a64c503122c621972a596b54eb693721234db1","impliedFormat":1},"402bbb012b41d3f2261eb858c2f87be3c5f3868e98fba169af5e2d8502ce048e",{"version":"7abffaa258259a7943318d4e43f2c0cd7c229be719637a09a3a8be2b1cb44f30","impliedFormat":99},{"version":"d0e136d6bf3c38be7af296b7e01912b6e8944a428ba7fd1e415a10acd9e687e8","impliedFormat":99},{"version":"7a685305685db7f9d2195ae629df44ae5888c13371a032ebe629a615a177a45b","impliedFormat":99},{"version":"026b28bf8f8c6f88e4e3aee7dd69f2523b91df8310bf6557d71c853144ec0720","impliedFormat":99},{"version":"4bc5ace72e3fcd7da9d8872af098c4b157ad8bd98b1996c097212884dc8e09cb","impliedFormat":99},{"version":"c3aa1b9d09adac7ac5e49aba8e8fa7114c2c842d46c2c5f51da53ec889787bac","impliedFormat":99},{"version":"7cd8fbd00f9608795145d427ff641d7abc485cd485d833ea1d9a90222ee73778","impliedFormat":99},{"version":"0f4f54801406a0a67455a9ad950bed9f4d2921fd66a91682f83a985086d60082","impliedFormat":99},{"version":"7c128cd80303077ca51f3b70b6103f5715048642f5b232cacc02f515ea2c0149","impliedFormat":99},{"version":"8c18a2ccca01e6ec6bb951c9a376d12b08112ee5237826caa913d85b4e3cadb5","impliedFormat":99},{"version":"cb3ae8ed61b12ed84b755665ed971cbc8f85a6cb005f5675467cc838b208b16d","impliedFormat":99},{"version":"6aeb63cfffaa8f3274025ba556e6d90d9e90a0b5a664bdcd26fcb23486309efd","impliedFormat":99},{"version":"76b348ba0d4830b55acf7e86e1714030c16d25a26b04bc9638aa03b8819e3c0f","impliedFormat":99},{"version":"6e5aa91099e2fe5d1d05f6f3100a90e5a5d9b8aea7b0ea6f4d05a0f192899a64","impliedFormat":99},{"version":"bd85cba544b37cd32e8d02b138c3a2a4075930d01146b3f5e33d713b39dafe77","impliedFormat":99},{"version":"725853c4d825cbe68599d75fafc4ec9ec47eac1a0a0d1bb343ee735321cf5328","impliedFormat":99},{"version":"20ca05d62223bf6f117925ef8f9b9781e894cb146d30ac491e0763d34e53a5d0","impliedFormat":99},{"version":"4ba733d1a5ff0a0779b714468b13c9089f0d877e6fbd0147fac7c3af54c89fe0","impliedFormat":99},{"version":"0110a18108a64dcc1bdebec9d344a4fa312352bf4979a56547df3ec2d76bd410","impliedFormat":99},{"version":"697203f3f5a1fea90e40fe660360325090ab36e630dc9422a1909dd4faa2cacc","impliedFormat":99},{"version":"ad1226eba93a65cdccdb1b4f115d67c5469e12705dbe80139c2988d6b296d04d","impliedFormat":99},{"version":"4ea2c94c3a1c87029d10f11c209674d4c6a0c675a97503dc9668d2815ff6ea11","impliedFormat":99},{"version":"ada4ab3255e0175af9a12012ed2e0db427829260dab466b0296697a754422f35","impliedFormat":99},{"version":"83c564d98be54908f9b84d9c67525bc38f52b423093763eb18f143a0cff3dc0e","impliedFormat":99},{"version":"94cfe3be66e4a6a1d52eaff0eb03bea21b4cded83428272c28feedfa5f9a152a","impliedFormat":99},{"version":"c2cf5eb33fc641dd321afd12c726ac3e753a81ab1618270ce6cd508f927989c7","impliedFormat":99},{"version":"a7f2f38cd72a96e7678555a1166a4488771b94e5a9c799d1c8943974ada483bd","impliedFormat":99},{"version":"c519327110a82e5eeaad683dc64f36994f19d9893fe69c4ea2b19d41b7e3e45b","impliedFormat":99},{"version":"fa525a25eaf81e3eaef7ca328c352bf4b38e1392ba468aeef117477a5dc42ea7","impliedFormat":99},{"version":"74a3f8babbd6269b402051673c8b255ad31db07539e37bc15aedcf6311fbb53c","impliedFormat":99},{"version":"73c4f628937d4e4a94d5af1c04bf57008a9d2c5f94a8fe6d9da8d51783069e15","impliedFormat":99},{"version":"f8e1fd0e462a1208e7c1e804fa87790112a6ba8c90ad3dc341d7c6430a8b79e1","impliedFormat":99},{"version":"1636e5ef72e41182b6a6a3e62595a3ff60c48f8b6fdb7373b2e7f7eb0f9485d7","impliedFormat":99},{"version":"6fbdecf06e73381e692ae1c2637a93fe2fa21f08e7cfebfac1cd2d50c6c6df6c","impliedFormat":99},{"version":"e437fb52a096addea9cf385b00cadc5fc34b8b8f6a7e63ef02b26cdc495478ab","impliedFormat":99},{"version":"75ad38105b8decc3c60ee068c8d76e3f546b4db1ca55255d0a509f45e4b52990","impliedFormat":99},{"version":"13ce682bb57f9df36d87418dba739412fd47a143f0846ea8a1eb579f85eeed5d","impliedFormat":99},{"version":"6dd4686bc0fc894051b6a93cff4f77b6a0159dd20801841dbc233231c5275082","impliedFormat":99},{"version":"d45218d368df27abcfd0253d4b1287e1b954156f32ff263f31913bad81a80918","impliedFormat":99},{"version":"0845f67763e97ee959128157c3269440004f71bba837cc781606c0f30ffc477d","impliedFormat":99},{"version":"dfb31f55c4a39440f89ae132de8bad7d4ff09c0f419df24955800ab5266cd7f5","impliedFormat":99},{"version":"edd454b3d3813b5cc5d87c68ba3c982ad8ec4b22b6ebd5e03a4f6a06f56f6e98","impliedFormat":99},{"version":"c5b7d15ea876bf33972a2ab1d31aa0dd9328e23ee6e59349afff62fa784e6da2","impliedFormat":99},{"version":"bdefac7b63b287f001df6473f691e46819338cdade107df98781b1650c76a42c","impliedFormat":99},{"version":"827a02d7987f70a3675cadeef9e7128cb4d65135fd8ea6fca87f91263b6229db","impliedFormat":99},{"version":"bfc938fd99ffb5407a7c0bde6d49c42a3d23f0e8fbdbbb5a50926b72114d5d1f","impliedFormat":99},{"version":"cdad6c3490b00ab05d414adc133e8c73e560f0c3fbfccd0a95a64a051cbe749a","impliedFormat":99},{"version":"d8f79448f4f860aec6c69d9953abcc95dbb8d4c8b99df7a2fbf3dd7ef779254f","impliedFormat":99},{"version":"7e7d9e525ffaba7c8324167c43d8fbadc174f415020946b0f0ecedb7b5762800","impliedFormat":99},{"version":"12a8b9d50244961dd1c86471af8b7c34df210888753c4930eb5cb6711da2b92e","impliedFormat":99},{"version":"965bfde0433a808a389b80a8e45b717cd2d5a3a0cdf418707cfda3046e33fa5e","impliedFormat":99},{"version":"923814ad5e253966d718fae2f1308528eecd1209c627bfde484d740fe310d36f","impliedFormat":99},{"version":"235f9ab7ecfe06e72b7d86612ec7abe2e60a8521d10614ebde48af12915bcd64","impliedFormat":99},{"version":"069e9adb92a941ed9f45cebc7b6ecf5d6f249a46142d267dffea594f712b5e56","impliedFormat":99},{"version":"815095b585fc89e31a644c99c8533f542c485acab1e9e52e48de01eac616e325","impliedFormat":99},{"version":"14d3c7499d1759af5c78eec4f26a6f5b85bdd5b0e41ef3f5e6e813f1ae88c06a","impliedFormat":99},{"version":"7714308befeeb34cbc1d6715bb650d05e2b4e0516db9e58ef4c399e462d222b1","impliedFormat":99},{"version":"5cacaa1a79b82d19cb221ce9bb3eba0313fd9ac6e48d44af0ec3e54fb3d988b3","impliedFormat":99},{"version":"99e0db809b99a0a2d55a3eef8b41d2b247ce0233cf29e39b85704ddaa536c776","impliedFormat":99},{"version":"217800577a2c9a7232e5a9d1abd1c1836acbb004e7522a5261299aa867713f96","impliedFormat":99},{"version":"8ee28204ddb2be7d6dfb68891493f654cbf10f5e1667bd33bd62920d9eb9e164","impliedFormat":99},{"version":"0063836258a86deea4e1e16c22a508e57fa3c42307048c8703885bf6676e94e9","impliedFormat":99},{"version":"feef3243cf2988daa9cc63a7a0c40bf39e4748759c18f020837085d24745c526","impliedFormat":99},{"version":"017907864b01ae728f5be6be99ea7632e68b2a35c2d7c9606bde20f85f10f838","impliedFormat":99},{"version":"01a85d7df6537db7f55188614119dc9a9fbbbd1444bce68e5a4ad3263adf1edf","impliedFormat":99},{"version":"c8a40bb3df60346af02e8d786473985ba53b716bc7caefd21ab838f025ec103b","affectsGlobalScope":true,"impliedFormat":1},{"version":"6f85727348a1b82b55deb40e9bbf6be7f8f2a00f0ebe44c02e16477f52b090dd","impliedFormat":99},{"version":"2c8c3026b97c4f40d183f893d860fb2836c9c46644591d2b40bdc2417b002fcf","impliedFormat":99},{"version":"4ca5b927a7e047f0a0974c7daaeb882230ac08ba3fc165c8e63ddcbd10da5261","impliedFormat":99},{"version":"12f20310f22fa2cad6018638d2bfeaa966db651cea186272506e53d0f64d20dc","affectsGlobalScope":true,"impliedFormat":1},{"version":"0b6d4c3f82f8dc5ea956b45f38badb561e5b580651397c7d7c06c472f9a7f2c3","impliedFormat":99},{"version":"6d056661e4b636cc04e36c36b24a4eb692499b21fe0b18cb81f8bb655d7a3930","impliedFormat":99},{"version":"e71c5f5440bea23cee6fa272d088930e69694c09ccb89f8811b097feb7c078dc","impliedFormat":99},{"version":"2f3b6743fa1fb12ccd929484e1221c7aee4cfd1584b34ede390c2d97fdc1968d","impliedFormat":99},{"version":"60981ae7c2a8926f7855d8068c42e05a3b1959f0bb795a8bb9773c912a9a6f16","impliedFormat":99},{"version":"811600963f726a8eb66c6883bdf39aaed77cd94cb6b7fd92d4b882cf0fb23fb6","impliedFormat":99},{"version":"b3f9f3f76f8d7284ba488f843d7027395b7aad615ec69538b8b7a6bbe3c34e20","impliedFormat":99},{"version":"a21250bad063e85aca3745978df1f26b8ec40532fa8305a243d1021485a877e2","impliedFormat":99},{"version":"02a8bead44c8301369f970a697156d401897b046bdcfe8a6fc7fd0ecce513a57","impliedFormat":99},{"version":"8e8fa002f1dabd3fadbdc4c110274558e44279e0628f53053c23cf89070d6a99","impliedFormat":99},{"version":"cb5a0b21c3314c89fab4006c6505011f03877a35edf78735f35e97c0fd5dfcb1","impliedFormat":99},{"version":"ae046314c0651da4a01e9e48ddf370ce9d22ad21f48962f25a12c1c09de9b01a","impliedFormat":99},{"version":"8d4a70e05b1f8450f5fb8997e5bfc336dd0baec3f2c8117f6f260d4eb68de0ac","impliedFormat":99},{"version":"8fa060b55694a9427afa2346181d988302de37181cac7df6e29f252b3741164c","impliedFormat":99},{"version":"db30902a5f43e35799c4f17baaf605325d6567c57037f7848e0fe3fb8b694a32","impliedFormat":99},{"version":"10f60c4f46231065e5a4815651300d69925049b6d654c141eea7bc3410fa5b4d","impliedFormat":99},{"version":"8ca97507cc241216ed30a5c73091a6dd4818dc9cf6dbd3bdab039e40f474202e","impliedFormat":99},{"version":"89221579f7e073535bd1dc5fbfdb5047bbdbbe52995fdfbf238f71f428dcadb0","impliedFormat":99},{"version":"5d32df00db39a9a997a2f8e4e575892478f892e737b71c48c019b80a295856dd","impliedFormat":99},{"version":"8cc3ab398412f20af6fdd1d307176f933f3a4a6b7eeab11388d3a084b811bec8","impliedFormat":99},{"version":"150dad61fbc648ab6f9ab3b6cc4d74a99a20bbbec64c8b21b16abadfbac49e28","impliedFormat":99},{"version":"0ad91f6047d442d95d241de373c4c7e9066a0be6934363fd6f0df2758e0721c2","impliedFormat":99},{"version":"cdc154f5e44aa28c4f948ddce70d8cc57acd0992809549761b2f352c409e03b4","impliedFormat":99},{"version":"d7697f915c61a7f7ee03922e9f4e2dd3ef8122a3bcdafc1d7824f2c664b67ad0","impliedFormat":99},{"version":"8ae0357ed41745154782684b1cd3a8b9c84dc92935348d3711b8c949472d6398","impliedFormat":99},{"version":"ece19f08fb075c84c2e22fee2af1991bd2f67f60157b72a2993dc6d1087a7e80","impliedFormat":99},{"version":"4804c3e9ab498d31144a0c9b95defba9f913a4326063d19d8583eb4ba9708a15","impliedFormat":99},{"version":"f7292171fc81d858880863eeea33c85f9522909b6929559f780b5ed697c99020","impliedFormat":99},{"version":"8cfa20678d5f41cb97d6afdf5076903e9ede523379c97bb7ae47efe0d25566e2","impliedFormat":99},{"version":"7299aed934f999ad939eef04327c25c1db4019bde85c868298da307f1336ccb6","impliedFormat":99},{"version":"a56c6a07f61f7382a1744d14a0d13894e07994a503c90436489d37efa49e3aa1","impliedFormat":99},{"version":"88220b86da493923d05930d0e0ce94cca2813a4196929f5dee099d1bd763d6a1","impliedFormat":99},{"version":"ca15c38c9fdcc210ef6382fa4c06fb513eb5623ecacaf225f77f1750cf0fcff6","impliedFormat":99},{"version":"d836b34bc823fca290361ab1697d11e82a213a6fd3057d0f82f12d57676efc64","impliedFormat":99},{"version":"f648ba1e623bc9027029a3f5cb82ccabc0e2bd9af8072e2d98ef0d8f17e88e3d","impliedFormat":99},{"version":"3b059298411793c465c4f04f509e6402b0f81ed6d9aa6f4cb5e5fbd8a68a0e3c","impliedFormat":99},{"version":"b15e4936fce4442d8fe92dac9cefd531970d80a74cab7f1f5277ba638cce626b","impliedFormat":99},{"version":"2b35bc90f642e0572c960de7e1b444d725b3959c49718c479564e06970046fcf","impliedFormat":99},{"version":"9bed9d3d3b1ffbf89af378638ce3ef0742a7bbcfa4ac32c950d4acb163421436","impliedFormat":99},{"version":"0ce5d0ce2ab178aa2aa2e448e6a0c5cb5d4b38533ba0dd2491e5b85946783208","impliedFormat":99},{"version":"74ceda95ca7d1851a27d935612f65a6946548e1f80cf5dd1298cad48828c27fc","impliedFormat":99},{"version":"7deb559b01045a41440095d8860c5d59c5ab1b2aa96c01e36074f4c58632b365","impliedFormat":99},{"version":"259ecaedf76b39789c0c81f8603a92314a79f51b61be1bbc15f1e1b334da1c38","impliedFormat":99},{"version":"b6352f615b5720d827308152fc030237636d5ae9eadfc542f86ad8343ea600f4","impliedFormat":99},{"version":"43c212e31056c922b3928552737293a984c6b329d41e4ea30d819648de5242cd","impliedFormat":99},{"version":"bfb2c74ba09559b9ac6b0c21012a72e124c399e7d12eefd0df801acdcaef359d","impliedFormat":99},{"version":"3c823aae91938552265e8451ca319f87a1a951a978c6e79e37e080242d50ebcf","impliedFormat":99},{"version":"b1012eafec8c934bb9cb9fcb5e41e3e7e2e013e4ea8d2e5f537d3ad747030810","impliedFormat":99},{"version":"91212da70b95a54d93fb9becf138e14d9a770aa63163204835d633f32fb301ab","impliedFormat":99},{"version":"05489ce1388e63ed911ffbdc0986ffae9a1131e51897133d7a1bcd34d5b8b54d","impliedFormat":99},{"version":"97a51fa3169e333c5aec82f2bfc559e1a14cfe9a6e7b0c3684edbce0481e302c","impliedFormat":99},{"version":"037ea0ac2272c05cb37157bff722effde2402b224ea90cd6e0d4acabc7938480","impliedFormat":99},{"version":"48c7ace1bb243f4828b917a32ad4a44ad70ceeb996598a608a7d8e7e532d35b1","impliedFormat":99},{"version":"08de8f1d972b833791a9782eaee39816eab1138c53319ffcb90ba9defefef6a1","impliedFormat":99},{"version":"ef1ce13d614f887ac1a4ce2a4a282c2582dc7e321477e87fb15564c5d7755dd5","impliedFormat":99},{"version":"f6bac2cf3c5d6043e24f74e200c0ddf6e4dff6e37e0be075db3f474af5ecf7d7","impliedFormat":99},{"version":"292856f47dad178fe1cb3401554428b3b0157369a8fa52792587fd2bd06fcbec","impliedFormat":99},{"version":"84f6e48e6acfbee5b84c896957eecab0b1c82f28f76347e9b1f3e5beab0b507c","impliedFormat":99},{"version":"86c032d6a08297f2d6107881b091c3e4b494abb6cbabf7af04128bd315010133","impliedFormat":99},{"version":"1f85c894a5d2e46686ad0e3baf8f4d0d470032d781e4757ca9a9db1f9ed1a6c8","impliedFormat":99},{"version":"9689a980013b2f1787a2da7dae1aacbf82e9ce2fe5f5172b4867feca8f98e0b0","impliedFormat":99},{"version":"ecef49f31349ad695be11c15af4ecc4fffc95b5975aff0c3225492bbc8d55cfb","impliedFormat":99},{"version":"4363c23b6d9b290d6eb6ab986a62473892cae3a7783b7b1468a3d0c2a25f0f55","impliedFormat":99},{"version":"61a605be404b4fe829b2e86b24c856012d5abc41763f32d9ccf7bd051a8da75b","impliedFormat":99},{"version":"4754025df53b19165caec8e99e341b304aa0405ee8779020c85f202dc1efccf3","impliedFormat":99},{"version":"8eb7a21fdc1a83843d8669f589b04d6aa5ff8d83f66e62dc7ba7da6db56de1b6","impliedFormat":99},{"version":"9deec5832bc5f0cdc3045db3956b47fa92482a44b5262cdb97b7019552170ea5","impliedFormat":99},{"version":"b2f5ed72f0b2c9c98034a0ee12661defe50334f013fade322acf70bfef46a39c","impliedFormat":99},{"version":"9bdb6e828cb364d75e79cff4584e5e812f9b56b726e8bd51ca7c92dacee18814","impliedFormat":99},{"version":"c2bc879419d6b9ab6edfa8005126807838c1a496c20ad64bd2135f8b27078ee1","impliedFormat":99},{"version":"876a4f3883db4bde394c8bcad52ba312f8f94f7e6acac5c684dcd68c7bb4e7f1","impliedFormat":99},{"version":"81a1f5c255fbc25aafb355268e389ad94d898ff78c168ef9e04c87bb648780ae","impliedFormat":99},{"version":"490b9c476f66eb7b5168e6c1c8eeca3ece512f0227441a39f9dc69ed64de6d2f","impliedFormat":99},{"version":"8c5cdd079401ed60f317bdce7ad8d1f196c83ff5ba809769e0e072c7ba5130ff","impliedFormat":99},{"version":"59ed96cde583387980522a6c849eb384c6b957761c3cc91c2342d8b8ac60a79f","impliedFormat":99},{"version":"ccd5a443fc8f869f27b9f3bb04fe2b0c925d976c45127c5d0fa319c9ec5fc126","impliedFormat":99},{"version":"5c3bb593b853926153fac6366f61f6099f0a19d02bc31d4de73ed387ac2a3ee1","impliedFormat":99},{"version":"fa2c1d795363840e2debe01f19457c1a89d505b39fb5ceb96079057a483b435b","impliedFormat":99},{"version":"d94acd15b4a3517523756dfeabcb7b4fb8ee853bba680d892ccfd3df4c81edc1","impliedFormat":99},{"version":"a324e25d97c3fb7465c07b33953a0311abc74f6ec2f34dd6c3e9e2e2dcb35cc8","impliedFormat":99},{"version":"9abd03a84d5473e66b038270dbeae266129ab97261d348a5fbd32ec876161a85","impliedFormat":99},{"version":"e76b77b319d694a0a6eaa2083bfff21bc11a95f13c439dda60607d8d66dcec47","impliedFormat":99},{"version":"4745b7d941723a317d363952c2fb830e6741956db7e6a29a2d3367e3261c7a45","impliedFormat":99},{"version":"b39a0a13c3c39e523a448b72ffa429f25938d13ad21af702466baf6c87858ae6","impliedFormat":99},{"version":"25591800d3f1085f26bb818516c8102f675876597a25a0262094d47421834716","impliedFormat":99},{"version":"4caa4e2fca87541345762e26360d78a26903123001dadca36e222cd2d6f4c67f","impliedFormat":99},{"version":"909e3572ac981d7c60a58aab8956effcea348ef5c4fd4893fa49111ab9c8f27b","impliedFormat":99},{"version":"3bf2f14609fb722d92d9255faee239e241bb1536876be83580342ec8114e3fd3","impliedFormat":99},{"version":"acbb26b2575aaf25926e685314c43f40d0df046562d4cbc809739584be5e7641","impliedFormat":99},{"version":"57bca639d39adba274ad4c815d6e0dca58d2720f18b2c65fb363858f48fcdd6b","impliedFormat":99},{"version":"2eba0455e8a1f103ddb70d901e9ef927cc6ac33c843d17fbbdf8718f18d54a8c","impliedFormat":99},{"version":"3de5f40d2d7f91a7ac258399ec6814e92850aa84743f17efcbd4cc038f18cdd5","impliedFormat":99},{"version":"2752b702a7652cb6d1c254578d67e2b658fb933495cd93fcea09785bbb694f27","impliedFormat":99},{"version":"7d1de45ea13fddacf53d4586e1a3e8cb6da52395f640744246910c35f13bdb89","impliedFormat":99},{"version":"5a6bae49831f960e7f0bc66f49b2c40077b136d9573871f865507fde09580436","impliedFormat":99},{"version":"8e20818befa967faed7aa9d9edec27ba951d826b359b4415bee2f09204fbd0db","impliedFormat":99},{"version":"cfd0c572e36d17dff1c5a8826584c50ac5969e63b5cb0f9a4a2ea201ada2a7ba","impliedFormat":99},{"version":"f7b5edfa4d033068a292b298b326eb4671c257d065c06fdc03d9b18e88874eb5","impliedFormat":99},{"version":"3b05dae5f0c9bdf14cbe39d5310d6c19c171c36352ef0861e780b4925a73c08e","impliedFormat":99},{"version":"6dc06d72a5743ec50df6c01e35aabbe448fe9e54e150cb44f8feceddfa764cc1","impliedFormat":99},{"version":"2992a29cf3c36433ac5d5e70a67035ba4a5984d11c1cacc91a5528f96c9afd03","impliedFormat":99},{"version":"3d04d3a7d162c68f649aba06921e4e2327c881e9d0f8b658a29b18b0091f6c33","impliedFormat":99},{"version":"d526d476ecdc2d4f778f949eda6eea7ce4026f62fb7f29acdb8afd353e4cf9d7","impliedFormat":99},{"version":"0c209eeab11eaadde8d9757835fc6681155c4c7ed655411e67b8e230fd82308b","impliedFormat":99},{"version":"d625ee4c5de9967d36c5796ca651f253fb615f4408a7ec0801a0557abad68c85","impliedFormat":99},{"version":"b508bd524c943d80149d34dcb99e76a8d3431df9f707fbc5a5f5e5f07a69bb59","impliedFormat":99},{"version":"e3e1cc8cf08e8aae175190a365f0e62976007c0aeea56b71bec6aa30c9adb3bc","impliedFormat":99},{"version":"18c054d4a2eb6cacb592c27bdee6caae2027164f34364e82d4e950c9be7e7ddc","impliedFormat":99},{"version":"132d7d3bfa9fdabb1988e6c68930db6675e3fc34bbe296e5fa39821936836bdd","impliedFormat":99},{"version":"c573b0c6a67c0b0e1f2ee07374624fac22b63637254d1ac626cc361143dd1968","impliedFormat":99},{"version":"e8a8c70232932bf92f352e5f8f9651e33157cd39a9a1daa9aec04bb94303607f","impliedFormat":99},{"version":"80838a5ed85d36f87dedf97f97708740ae3953feb73183c10e4ea547f6473a5d","impliedFormat":99},{"version":"47debd6bda0249e4b57f5e04c56c9c6683a2b352bfac161fc24d866fed923c5f","impliedFormat":99},{"version":"4a6d8a7717689cdcf45e37109e29769748689fea7d617a769da4c26f1aeccb19","impliedFormat":99},{"version":"e87c5aca44bc0f01b68755e15f71eda9324737ddba4ad1bbd481abd20eb4de72","impliedFormat":99},{"version":"640e9e924c3228324f04a04c76b33276e432661a990a3d53ddff0352605d2ce4","impliedFormat":99},{"version":"9dc197564ebea5d0bb19aaa52e7e4fe4950f15f6bcb7126a2b6cb5bfadb07c35","impliedFormat":99},{"version":"ca9de142871e3b8b7a0c5611311fcbb7b0b9f988e9c946fb30636942c0b9323e","impliedFormat":99},{"version":"207afb6b973cd7256564ef84ded56b0a1986586a9a090808b01e8975e28aa3d4","impliedFormat":99},{"version":"4b8869f1ba1c4189b81db38bd1db63383fdc9b99ae7fc532a9a3ac9de39df668","impliedFormat":99},{"version":"7cb46212bd1a7a09ef93154a3e5c32a9a5cd896594d9120c8166826ab0221316","impliedFormat":99},{"version":"c6b196ae0b930bc53f969cac072d2d5484727ff7574533d65c52202c226433ac","impliedFormat":99},{"version":"a5c00d33d753e13207cbd7fd64aecb0d20cb148e44b2cd6db50fbe6b04389c4f","impliedFormat":99},{"version":"e24303a625ba2922c82ee5ba023dcfc22b5b7aa96e14885728551ef9a3e19fef","impliedFormat":99},{"version":"bc43cd39e4dcf3b341cd90967df9c100abcade224412ee1ea56b94129fa96250","impliedFormat":99},{"version":"54f15014cb20913f5270ab54780e9228ee844fd7aa611c121d9582bca4653f1c","impliedFormat":99},{"version":"d5f11d37515acf62da295080602cd1a1f67b6e2d2c1e00b868c5e53fd46c3342","impliedFormat":99},{"version":"714daaa3cfc14d59a1b7cb780a2b2b6613d359eee3258f68835aa5c0023a418c","impliedFormat":99},{"version":"17d6732811c073140dc207498efaa8341be9c3dc423e03adf68e207af582ff02","impliedFormat":99},{"version":"9b4031707c076f73c6dc66297d697d5d9952941071099f6f55f77e4b8b13e0ed","impliedFormat":99},{"version":"858e6ee8d60768456973ebfb15cc797a5c477173b585fb8df872cec543c6aaca","impliedFormat":99},{"version":"2efe611f66bdc7fa6e2105b55051308d546444d61a1d7e6379077be242590f2d","impliedFormat":99},{"version":"d9f027b229ad5d8b026a206ce31aa5b7898efe0ab708a96fe9a45f54c941e080","impliedFormat":99},{"version":"1d083ca29e6e874200bab83efd40e5d85c3d4da21b46b8b00799ba03e0f4fb86","impliedFormat":99},{"version":"ebdc3b72652592040fe10eaaa4ae53621460085eaf70be4b0e560fc30d459877","impliedFormat":99},{"version":"c35b0845639396a86ea5bf1276550dc0db6aadbbfb1d7145fe5974701065f99a","impliedFormat":99},{"version":"7c7dfb0cb2a27eb09a6e6b47566678a13e85de27c244d37d897ecb17399c24ea","impliedFormat":99},{"version":"f5f99c35649b9ad64c6b3dcdd8cfc7c9db3472d27eeb04156b15c17be0e30e5c","impliedFormat":99},{"version":"ecd5b86187507d8dd18df5c1dfdf466533fa0c219f1141874544cad4ee8181d0","impliedFormat":99},{"version":"374ddd65ff6bcec0783a687407c06848dcaa354f98fd885f0e44e73473b03b8e","impliedFormat":99},{"version":"f38ae89747f696e40b633f4c4813e4a7b1e677ffc4d1fe41fa842bc89ece4979","impliedFormat":99},{"version":"b3f309aab87ae7d8c0b3db432480f23a023204fcd58c9ebba001b53aa3ec313b","impliedFormat":99},{"version":"fdf5cf76bab3021864b225f9a1b50d6b2df656d5c9f6800d2860df6d99ea36cb","impliedFormat":99},{"version":"277835d2fa0011bc11b00e550e92a95c82c128af031405938d85a38d8de12ed8","impliedFormat":99},{"version":"70859886ddd69237ad8e8c2e20d052c778870c6e3d420dbcddf4d2d9d56878f8","impliedFormat":99},{"version":"ad42398997e18754aa0441a40d1c73e3a45adef0742ca4b4d4bdc335405f6735","impliedFormat":99},{"version":"ba2edd91e0df0a3d331b411440c9273f4cf55f1603ba36af2bf849f1ab9e7edb","impliedFormat":99},{"version":"c91b058ab74323c57dda1cbda7eb8cee56272002249a642deebbbd977c4a0baa","impliedFormat":99},{"version":"cb7f489960477f1f432a3389f691dc243ca075e87f20032a2866321dab05bae2","impliedFormat":99},{"version":"e57aeb7a5f347f2c6237135add5a5f7db5964c62b7b01211fe8931d8616b5ad7","impliedFormat":99},{"version":"13c2e1798a144acb07b57bc6b66d4eadf6e79f1bbd72472357d303e7b794842a","impliedFormat":99},{"version":"516f5feb685e00a96e4d4c148f9f71f0c388bdc223350c76b7fb97a2750d4d98","impliedFormat":99},{"version":"24c626960973658ff450798d90b9696c53271c2d60192ce73306bd4298dcbd1b","impliedFormat":99},{"version":"7c7a960997d3470573faaaa089e6effd21cd6233d97ba7245974b4adf46597fd","impliedFormat":99},{"version":"560ad98415f922fd0bbe0371224646932d43d3719a5f2b4375817dc3704cb77b","impliedFormat":99},{"version":"69a24ce73bd1a72860582848f778a9404611a2cb05adeb2313c7d13bbc8fbad1","impliedFormat":99},{"version":"abe0dd728aa9abcd8ec475319c6eb54938373f52726dae4e3e97aa7defa7f35b","impliedFormat":99},{"version":"579fa7e0a81dc470473e651382981f18557ade5146e7f88b73e963574cb4dea7","impliedFormat":99},{"version":"eab1832f2519b737bc5cb4f8bcbe2ab715640ef0066f2f242237265d3b26bb0c","impliedFormat":99},{"version":"28ea0039f108f37f8bea3db0f55f129a032ece3f864e56bc5741a34f87114e87","impliedFormat":99},{"version":"a87cbe494f7bc082f0b0eee445fb578ef7bc21b675495639434f9a6d567bf28e","impliedFormat":99},{"version":"d5b27f01ba5f58111d778a35fe732688c83140202ae614436946997557938f33","impliedFormat":99},{"version":"5220818fcb21764a4238fb5f6e80c33469da6ffc37312346266b7a4146450c62","impliedFormat":99},{"version":"223092be51660bc7f4d58c5e0d710af4a1d141640062211c79a39b6bd794c833","impliedFormat":99},{"version":"3e85bd0741475d6fd494462a5b2b0583669b24662586dcd84e79b0b57a4f473d","impliedFormat":99},{"version":"ea33b0b6a133fdc5f24d73731ca316d6746492cd1111fd8486ff18a0c5e4476c","impliedFormat":99},{"version":"edde198b353f71feac0536fdb7bbfc6822054d2b37990ddb60bf94ad2a0a9b4b","impliedFormat":99},{"version":"4542ce8669240889dd3352a9182afa770d03c4ebb6d3e7ea0f57b251e5cf1141","impliedFormat":99},{"version":"b05cdfa9e1da98c66320978c734e5799d87d65e4459a9e6c48379f481052b3af","impliedFormat":99},{"version":"7bf2a520da5bcd1e809b5dc2a97c4856b907310d499b7b1afee2e819870376c1","impliedFormat":99},{"version":"3f54f74fd23f4996d3d1e4f13c2f400f984e936f7c2624e66fdfd4dde3e01c74","impliedFormat":99},{"version":"220331b446307cba2380436654a5d152178fb9da8a21cdf5ff81fa976f18d391","impliedFormat":99},{"version":"a26869d90f718fda8826663a321d00676a1542cf8d2f9270ad4a123dec6d6c81","impliedFormat":99},{"version":"86c32c0d6f5b9a3154cc5f3a9940fe072c5039671bc6fefe093ad90ed942fca4","impliedFormat":99},{"version":"3b8e9ed55356244fe7f14bbf799432fd79722975a26e4260befdc9a12f56c4e4","impliedFormat":99},{"version":"8d83324e9e2c32400cb73467d84a62dd728211cedc97bbb87373644416e77d1c","impliedFormat":99},{"version":"0faaac76aaa8aac11ef1a5c7963a4f5f0a6d0bd4f4685a179861f0de5863118b","impliedFormat":99},{"version":"d82f6d8f1886f7b27e0d6d55edf506d6a6bd0c4dd469df07b839368f487f1e46","impliedFormat":99},{"version":"decf2f16fc753624272bcce7388ba5773143e29da5fd5c1f99f4dd7f256a63f7","impliedFormat":99},{"version":"94a2d7c15538d8e83415299f17fd00ab88c594b6a0a40be1e26c99febbab45f6","impliedFormat":99},{"version":"381f3accb1b022a35c043d19cbe0cd5218e97077ec6a90f40ed79fb987c40f23","impliedFormat":99},{"version":"db1c146bb98f18eefe1aa37079090ddc200713f10dd0b53e5795aa1c30612264","impliedFormat":99},{"version":"96a687e0c2304bc17be245728797469b6b8ea2eef6dcada4a2b849672596b516","impliedFormat":99},{"version":"cd24b9b6ddc36df82c5d3e128d5d64e8de214ee89f203638e4c00a1af24d27f3","impliedFormat":99},{"version":"92df9de23ce83ddf43371881daa7e996b4bcdce88a349a6a2d9fd08433500d8d","impliedFormat":99},{"version":"da0b84be87479b7d7be8c2e4101a231ca55328efa99714bb54a35d03f689bd4d","impliedFormat":99},{"version":"282612c337fafe5695bb3617d1d4d51cfaa11e0c4923af9fb65852c8dd5028db","impliedFormat":99},{"version":"4b83e2822d39bafdf3744edf8c9ff0517b660bb786b3703cbdd74a5c71c566cd","impliedFormat":99},{"version":"aa5d645ea3ff7c41a3ffc327c6d85c7de11c281a5199426d79d7d9a23fcb7a83","impliedFormat":99},{"version":"73e040e9bf68c04a4d8ed505b66b0fc3736ce4e2c3eff0c70ba714b6d7ecdbbe","impliedFormat":99},{"version":"77d3851103a2fb69733773e35bf3e2006604c3909436791921fdcec7d8e7266b","impliedFormat":99},{"version":"d09933dd700b5fd595aa9921c48bd3a00ff8bf73b5b6a55935aa260282581706","impliedFormat":99},{"version":"5c834ed67b61fdd842a8f3e0fc92901d4f35474bc305d97380144ce2f607ed7a","impliedFormat":99},{"version":"da6f03bec40cc4be1a77ced505133e27442076f5c4873a5e01eb935fe1fb569a","impliedFormat":99},{"version":"15e582cc34c41201f053ad6a63269c13093141b8146ceb219290509fac585332","impliedFormat":99},{"version":"78e458eab6763a558f7f02df847f63fdb01ee3cef4919e76514228a6048870da","impliedFormat":99},{"version":"5a36d974ba70c571928fe8343254501b903c38590983df4d5e1a6e6e3d1d1cda","impliedFormat":99},{"version":"53eaebb4ff9eeb4b93499decc874f630f844612dee2cf7b44c4ae09a1b7cf64f","impliedFormat":99},{"version":"f262f10ff10bf39f760b5f56ed941b496082f840cb34f4ea765aaac84e3cebed","impliedFormat":99},{"version":"f5b262f0fe03e6514c5566b3f714b2a013801725583950c7284f0493bd2e2e91","impliedFormat":99},{"version":"4aa24ae79c1523df6c5e7660b3b41c75cf9f82908faf65d66c86c3cab4390d9a","impliedFormat":99},{"version":"4da8dbdd37fb1953481ff091d5af23a5b0956452a0e49781e957d1b33ff10f66","impliedFormat":99},{"version":"3786b7eefaf62129935c1268a30f5e1946b06d67586db003f13feda086f63269","impliedFormat":99},{"version":"e99d3af9aae3be20ead69859da9b19fd06b1da58faa2b3319e7c8eccbf130525","impliedFormat":99},{"version":"ffe74a08e03eca3460a47733db41b98d74cdeacfcb781f71bc5fcad97300ba9b","impliedFormat":99},{"version":"9d71a05a06f08b2f2ab08b66ca9dac1ca23fc697f34c258fca57cd89d93c961e","impliedFormat":99},{"version":"26301b0b384ea59d5429128dda4bbc586960b084799264dbf798e3d9e5d3a3f1","impliedFormat":99},{"version":"3efde945725457e42b3a4810cb90d04564b1fa44a1158fa88cb0594f0f1246a4","impliedFormat":99},{"version":"d841fac98fe80364d79d256678cf1082d6a6690f0cc8c91899005b575fe76eff","impliedFormat":99},{"version":"ec273e29d916d26c4231c3a9b8efb3ddb4ef448243e0bc8919081ed8f057023e","impliedFormat":99},{"version":"5ca92a8e1445d95869725101cd28e3b6a343beee53fca72f0d718e31288bd11f","impliedFormat":99},{"version":"8b41b5afbafe7b6c6b43ef8466da025ee3745b2ba3ce69bbb58a34794deb811c","impliedFormat":99},{"version":"60be140db9c3229468de970734037ad5a4ab2f4297c3e0a3486084943bf161d7","impliedFormat":99},{"version":"a1150a8796da8ce8dfc6defc6a7e6fef612e0a6713fbd5eff9e2a47d823838f0","impliedFormat":99},{"version":"45326b8f539942d683547becbf4b6189edf0c8291541f14feb958d59214e78cb","impliedFormat":99},{"version":"46bba6412696454f65b7dbaa75eea9dd12cce24de32b208c3aef5faabf91f3d3","impliedFormat":99},{"version":"bcc7494f86855366ced0fab58c5be2f48633519957320158bd97834f520ff477","impliedFormat":99},{"version":"e0ac5ac97e881b7dea0bd259c9c824abb1a25fe13f5e15e98eeba9cb88bd5b55","impliedFormat":99},{"version":"f2ec7c52bd4fc835d880524898f1eee0f81d46adaa2e7f99246ab17698b257d3","impliedFormat":99},{"version":"d6d918c5cda2429e4530e89b0832e1e2c465dd74a7371e9251f54092e0356d7d","impliedFormat":99},{"version":"0ac26b0761d9ab21bda5687100dda02ac873f04fc2e63dd5096ddc761ae3ac74","impliedFormat":99},{"version":"c8ff0b63346afa7496829d8d8c1e9cdfee6b367ab3e59fd55be7e9e735085280","impliedFormat":99},{"version":"c4bdc832eb5b68bac94c1194582c87a404f0c63db803c334e0f5cbdc569d0e2a","impliedFormat":99},{"version":"83b52889496f48360a5e578fd0f28c3e25b53d74b61debbb97ff9a355cec11c9","impliedFormat":99},{"version":"b675e40da933477838d2388ca57d9ca725870ce3b998593ad51fb1f4f65b1731","impliedFormat":99},{"version":"c66e5e7001cb59aa2f893389cd8c22e4f583e71d83d7baf3e6208061e49fc8bb","impliedFormat":99},{"version":"c54892665f8908a0ece28bce8645ce17cff887650a234c83748eb15d211b03fc","impliedFormat":99},{"version":"ee48aaea4959ec44f919041922880252ca2a6fbdd0126d66f896b652d1c31bda","impliedFormat":99},{"version":"eac98bf1f90e1a3ebb278bec416cbed397b12c02125ee0ff71bc4fab2a1908e6","impliedFormat":99},{"version":"fdb2af00500688a4d7043bf7c2d434388a6f79ff02c94912f3905e9b53756280","impliedFormat":99},{"version":"97cdfac4cb84dfff48652285f3dc17ef218b9c86392da6e609a8a926cc80381c","impliedFormat":99},{"version":"960ba74b3287cc4cc052635b5d55f1bf0c8ed2e5099960aacf80276530f7a23c","impliedFormat":99},{"version":"923e87bb7963af6c076afd0133a8cf509ebb198564e509b3a82465e8f9e9b31b","impliedFormat":99},{"version":"26378fde892f5c5c01f72bdf2374bc3f802c6ae5839d67af8ddc821d90d2f987","impliedFormat":99},{"version":"eacef4a482e552c59d1e849ae8dcb6faddba65fbd2b202d669d0710cc624b21c","impliedFormat":99},{"version":"6c045250c732fae826a7d2e08313a95631b9605246caf42cf1e3cfeac9860a6f","impliedFormat":99},{"version":"0f9e4a6a6ee409b4fe4974d3bda8aa78aecfb0ab82b54f6634942b5989b78112","impliedFormat":99},{"version":"3a45f71d69f810f5907eb96862ef9312bd8d2d8237a12c0b44ccb539d3ff57e2","impliedFormat":99},{"version":"328fcc5e2446d4a6a72178bb4232d3e670c12772b8a61c70201c9e1332f0392c","impliedFormat":99},{"version":"1f7f7c2bb12ad319a15ea28196837c2b99070f54b24accc72134d3712fcc7aeb","impliedFormat":99},{"version":"71ef86ebfaafa56bb3a51f38e11e99dae5eb8b20b9eaac8cdea06f9948511a84","impliedFormat":99},{"version":"4fdaff2afffe91a8e17a6426f38bc3363b061491b3e3ee4fe27fe1f63bfcbb51","impliedFormat":99},{"version":"08ee30a6ab526d5aa117a2a7de97ad0bff71a22d290da0d35c26d9738274b17a","impliedFormat":99},{"version":"0ccf5694dd47e2e22840be052be14810059746c01393a5e8c3191aa55062a6ee","impliedFormat":99},{"version":"9ff3e7bcf6c3757c0b91060868497b52efef1132d2b92aa72069fa8a866cda4b","impliedFormat":99},{"version":"a1f749ca2ac06e8cb51118a6b907df90f90c0cd80f46d604089407abeb932119","impliedFormat":99},{"version":"30cd48abc95a4b93efc154e756c0ad95f009bc623181bd667c34cd4a0c53b18b","impliedFormat":99},{"version":"1afd5c409520d9cfc7ba0090e724194b0f96406e79c42ebd56b62d5d8792571b","impliedFormat":99},{"version":"190fba113074ba015ed94391cf5a4af926cbd6ae61ec35eee70841071b3f1b85","impliedFormat":99},{"version":"de493ac034bf0419341839724ea2dd16aef2f7dd9aa5b409dc04048226e896c5","impliedFormat":99},{"version":"15fea98c30c1616f81fd64e0e30a88b5defb1cce87546b4b3a7dc6f585e21fe7","impliedFormat":99},{"version":"2e9996a8cbb27215f0eb63f91fb98a786d8883b7a55487a0c645169f60902fb9","impliedFormat":99},{"version":"69ac911cad5852ece5c4e7430bf024595cc23463e94a88c9ab391e8d68816967","impliedFormat":99},{"version":"fa33aa1ee39efc0d964b226d1f6e48717a5a157398783490ba04245bf53ac551","impliedFormat":99},{"version":"53e2856f8644978742fae88b3c7f570ab509dc4d13288b3912a4446993fa3bc7","impliedFormat":99},{"version":"7cf786964e26f0e2c3a904f93f6e31609e2636723df8c1ce248d39b55055c89f","impliedFormat":99},{"version":"6bff8bea27f0dedad4d7fe0357c0ee76f1d247e4c96ea3fec0c35cb5770bb9e5","impliedFormat":99},{"version":"eee6890b29f2bfef558721888b26a722b70937b65253dff66a48a3a9f542cc70","impliedFormat":99},{"version":"9f9a94c956302e773ae41b64e3ab1ffcb3a49be9ef06c73cf7b0d292e68a7e72","impliedFormat":99},{"version":"313ec9122ba198c2b5e244ac21a7ace6e2e666ab219b72cded594fec04c97d26","impliedFormat":99},{"version":"62951cac61f6e22aa74700dac7dfab171beb4d12f97f70e5db9be888ff0e5ed6","impliedFormat":99},{"version":"99484c7a277c488a16c49ac1affe465e4fbb5e4d57b8c2190092c5d7b4fe6fca","impliedFormat":99},{"version":"8b3f0012a7e5d117922f89928113b901b80dc344295597bc9b66fad4fd346a28","impliedFormat":99},{"version":"2f2dfea24dd48624f71de12000ea7e1d1d6d950b02b6d887d68f3a0749ad2866","impliedFormat":99},{"version":"50914a9162d152c14337a597d41e56929e18c1f2eb6a139355530bb2821e96fa","impliedFormat":99},{"version":"0f65f9b61383ffcfa1a409da90c35741cd81ece1a2dc6f2ebd094d81599bc5f6","impliedFormat":99},{"version":"884f8073c4687a2058be4f15a8f3d8ad613864a4f2d637bf8523fa52b32cf93f","impliedFormat":99},{"version":"693c4ea033e1d8cb4968972024b972aed022d155a338d67425381446dcea5491","impliedFormat":99},{"version":"5d5303992a1d04c953dbc3d7bc9fcb3266f2917fc3ff9f9aa8c95f9294b37345","impliedFormat":99},{"version":"b6024c6222886b95cb29ab236155a98f8e5dc41151233781815e81a83debf67b","impliedFormat":99},{"version":"94dab3752006a2cd2726462342f1775ef18ff4986404d016d317fe79a9d0a14c","impliedFormat":99},{"version":"727b3a462015bbed74b520861445761ebaecf94e09d95bbf59dfcf22afaccae9","impliedFormat":99},{"version":"2c0300921d8d04b21353c94a8f50a2b6c902feccd1303b6f136bedbb2cec5ed1","impliedFormat":99},{"version":"d496217c7f38f218fc162e8f3e6ed611343aa65615f730f82c494dee6c892bc0","impliedFormat":99},{"version":"282ed4ab5b5c4759d5c917c51a5b2f03ca1df4072275b6bccb936cf60078e973","impliedFormat":99},{"version":"2c96813e14e7edcd8e846f009b24fb1bd842b90e2dcd85481136e52588de7982","impliedFormat":99},{"version":"aa70da8072bb8b6e8fae35c7d394d543be8e5c946dad666225a3475010fd2bf0","impliedFormat":99},{"version":"d2c35cb9836cae1899ae9e7e114410dc128bcff4a79cc26318db285699e0223a","impliedFormat":99},{"version":"f89fbb50fd3736e09b418a2e66b98ff9a04820259856afe54bc67977e1acd05b","impliedFormat":99},{"version":"4c76aceec7002f299d9a57ec8e6623f3573bea208b1ea51cc5ea03bf140adad4","impliedFormat":99},{"version":"a0f217b01453d43058cea514325ac8bd3ac3a184265314429eec8059c62824b6","impliedFormat":99},{"version":"e06bc5a68917139f31f323293f575cf1eb75231ac23ac1b95341079364ef1873","impliedFormat":99},{"version":"31a4b6d0c23346d5fb30b52bd3a8f83113fc928ee6474338d5571361943d58ea","impliedFormat":99},{"version":"aecd83ca7059d21a33fb7ed01dfa06a36c545698dbe0017073dba45532a8487d","impliedFormat":99},{"version":"7fb874c17f3c769961d1b07b6bb0ef07b3ca3d49da344726d8b69608997ef190","impliedFormat":99},{"version":"979e969f86456425e505f6054f5d299f848223d70770a5283fa7c405020b47e1","impliedFormat":99},{"version":"2ad6c5849a68263e12b9f246ffd09b4713cef96d617618076adbe2f7907f3d12","impliedFormat":99},{"version":"acd7f9268858029bcec5eba752515b9351d4435b21f1956461242c706dcc0cf9","impliedFormat":99},{"version":"ea2b6112bfd326f1075896bf76c9108dfd08ccbae2482ba31f68ca43f0b59ca5","impliedFormat":99},{"version":"3f9368aa15d0cc227a3af7af3e3df431dadf0f7cd9897fcc54507f7eb68761cc","impliedFormat":99},{"version":"0f2d4be859066fc3ea8d04b583cd0774e1f9dce7f60b9890bcc0a10efb9fac33","impliedFormat":99},{"version":"ac09b9131c553c189311d9e94d3853b7942d0097925304fe043220a893701ce9","impliedFormat":99},{"version":"f1b34ea3d64f73fc79ce1f312589134db27aa78ef9e156a8f14f89f768e800ac","impliedFormat":99},{"version":"873da6c837a1ee62b5f9b286845be06dc887290a75c553bed7f431107d25a3b6","impliedFormat":99},{"version":"b2abee3c001c024d4e552c4a3319bf3fcc94a1f48bb0d21f5d300d9b4920bde9","impliedFormat":99},{"version":"f9740d044306830442cac761b593538117f46c5ea57a8dc6d61f0bee12e971b6","impliedFormat":99},{"version":"41c6aff52e4289763ea30f0849b712437aaeb420c8448aeb8047ee2eca4549f4","impliedFormat":99},{"version":"f5db101f7d90f614627bcab5f8d06d9ccd144a1735b475637940c54097786b67","impliedFormat":99},{"version":"8c575a8e1b6032e576577f28d74066f73aefa7a35d741d0015be36956bbc30aa","impliedFormat":99},{"version":"1989cb4fb2174c56b15f8b10d18ecb0c053e7b39f94582581d69767d7bfb9b32","impliedFormat":99},{"version":"4e32d557115e12d4d6f4efa3ae616143cfef39d32115e472a2134b5871ed9f40","impliedFormat":99},{"version":"47921880701610e8d8a5930d0c9ea03ee9c13773e6665f4ffc8378d5f8c8c168","impliedFormat":99},{"version":"41cbf6c58f2f4e1e5ee95a829b3f193f83952385fa303062f648040a314f939b","impliedFormat":99},{"version":"bb11cd0d046d21d4ae4a28fc4b0eb5d9336a728f9bd489807a6a313142903bc1","impliedFormat":99},{"version":"a96d6463ab2a5a4cf31b01946f1b0929dc3f8be9f28c7c43da29a9e6b7649db1","impliedFormat":99},{"version":"ec43d6b21fd1ed5a1afeb779ceba99e80fe010458bb0a67d9ef301426b1929e5","impliedFormat":99},{"version":"87b5287d316dc32aa408e3f98d3df0aaf72f1f33ef6d5bc1b6cc0b1e16838756","impliedFormat":99},{"version":"79ffce57ab318282b29bceb505812c490957124a3a96c7d280a342488b0859bf","impliedFormat":99},{"version":"c0d0005f448e886b3ce4f79749bb3bb01b030134c82106b0f564ced50a5728b8","impliedFormat":99},{"version":"c0dde896477af7420467456ee55e8ce9497bfd724306fc767df03aff584a1bf8","impliedFormat":99},{"version":"e12d269aa86b614a245ba3647e3858ed11eeaed1127355df17f0024097251291","impliedFormat":99},{"version":"5d8a9000bbbd72cbecbe92aef031548c7a79f07db99c909d6d80e7e97ae564dc","impliedFormat":99},{"version":"67070025bf1e4fb98f0c342614d4d1c9a62f80e66bb59f5fa5de5f149d9e8730","impliedFormat":99},{"version":"23bfc0bcfc61f5c90eb75940956ed13eba0a0d01b2e09ea87df4c2f5a8ffba25","impliedFormat":99},{"version":"2985ac10580fc18e9af90499e98df3bb2a2c57ecb81f177000961fd79dfaf7f5","impliedFormat":99},{"version":"848fe82ffb97a4714de0a5e71b5595915208cec3f7c54c9e4d3d880f1fd6d16f","impliedFormat":99},{"version":"d01a00191e9bc6876014e4f87c825e7d389405be9bf2919402adc4344b1d5307","impliedFormat":99},{"version":"577cd3fceddf4891e9a369a7f59ce576024c7d859ac961060296a1cbfa00c6e3","impliedFormat":99},{"version":"c0cb067049695bde19be2985ad914471cc2c2df64019a1899254546696d23aa1","impliedFormat":99},{"version":"3fcd1fad56c7b90a8ce8a5e81ff288c81bd7bf5402a3bf4efcea44cf324ddd1d","impliedFormat":99},{"version":"8f47a2e6bd2914f74471a693fc3389f243a97367d8bdd920f27198b6018872ad","impliedFormat":99},{"version":"d6e125557820886c2add872cfb3e9502d4113fd1dd22a1f76ded1f439837f119","impliedFormat":99},{"version":"6e688e8aeba98c268b195f80355a8d163d87ac135ad03c708ceda608e6e269b2","impliedFormat":99},{"version":"802a6978c1b38822934ce43a3505e13b555584848c50bc5db9deb2e896c0940e","impliedFormat":99},{"version":"f502c7d829f5774109007ec2262c23efc941dd1ce42acc140f293a7c5ccfd25b","impliedFormat":99},{"version":"af3444bd00030bae3bef81569f8703ecddc2e569cb6b728ec045f0d73d47572b","impliedFormat":99},{"version":"53102281f8a153bb051e0223a8dc51ff9c4cf92da127d91e3f60e74b4e8f41ca","impliedFormat":99},{"version":"e402e111fadcd36fa26ea1ad74f3defd6ef478f6d278a69c547e664b57770392","impliedFormat":99},{"version":"bf8f4b3b372e92a4e4942ce7f872b2b1e1bd1d3f8698af21627db2dee0dda813","impliedFormat":99},{"version":"0ff08be8d55c47d19f3d6bd79110a2ac67c6c72858250710ba2b689a74149ee2","impliedFormat":99},{"version":"77676a7a58c79c467b6afdb39bed7261a8d3ba510e9fd9b4dbb84a71dd947df3","impliedFormat":99},{"version":"dad5c38d723d08fc0134279b90fac87441ee99b71b0d30814b86954e0111d504","impliedFormat":99},{"version":"dd7510a9a4d30db5ac6418ef1d5381202c6b42c550efeb5fb24dd663eac3f6a2","impliedFormat":99},{"version":"cef653b7f2115c8e2a9b6558bf9a083dbcc37ce8fb6bae0e48cde3b92fdaacb2","impliedFormat":99},{"version":"2c87178f8b940592781cea818e840a825ad9cf5168593ff36469c5edb82c8ee2","impliedFormat":99},{"version":"34e0a7e03021f1f29f109cee7054216f94a6a769aa965070b3d00cf4648a8ce4","impliedFormat":99},{"version":"c85f04a8ff65051d2cffc664baa83b70583bd72b9811a50c77f880968c1188ea","impliedFormat":99},{"version":"ad48586787d5e217f4fcc229e3c3d8de8aa12979fdf1f186134e3684d56577ac","impliedFormat":99},{"version":"229d6bca5145c86846793cb3166c83abb256cfdb5c425f25ada8eee49c993e54","impliedFormat":99},{"version":"b8562e5aefa86c069ec1c61dff56ef0492e9fbd731cbcdd4d7fce28a8644e9f6","impliedFormat":99},{"version":"7b3749cff64a3e801c9c324338abf939c3bfdd96803cf4af87280497626d8a51","impliedFormat":99},{"version":"dd6c7d6abb025e7494d02fa9f118af4a5ab0217e03ae54dd836f1160cb7a9201","impliedFormat":99},{"version":"b8ecf3aa6da346b8dcf36e93c4dd9232bbf3a413fae23f5bcc950eaa62d0139d","impliedFormat":99},{"version":"440c9aba92c41b63d718656bd3758f8f98619dbe827448e47601faa51e7a42fa","impliedFormat":99},{"version":"e158b62ea32452d2348fcc677503f890127f3efe3daca5dcbdfe4ca96ce268f5","impliedFormat":99},{"version":"d9cf429fa9667112f53e9bb67bb7b32eeb3697f524d01b9781b65247f1733da4","impliedFormat":99},{"version":"d12caf569803d56c5f827e4d90b00da9e631e8dfc088fa836256c647c0ac21d3","impliedFormat":99},{"version":"ea7b50e95a07d4958009daa7820eeda23f7d215bed0d516d5c98271f5466645f","impliedFormat":99},{"version":"4e549cbc811726ceeb47b55c3a68ec89b7d4413710f03eda57fd43b85b73d8af","impliedFormat":99},{"version":"21c180c753baa409e924458db18bbe02c838c9b8a37605e042c3701488ecc561","impliedFormat":99},{"version":"2fcb9b13c206fa4f6e88a2c090e4d591e4a963f8fc53b70ddc67507a976b7dcf","impliedFormat":99},{"version":"a90cd2ec48f9216a2abeb96fb5256de64b71d9e10979b7073dcb9d76f8addb49","impliedFormat":99},{"version":"e67fbc9a974d14cab74cb47b4bed04205886bf534c7e2f17ecb8f7789d297b1c","impliedFormat":99},{"version":"82d76af0a89cd5eb4338771a2a5b27f3cbc689b22be0b840de75be4cfc61f864","impliedFormat":99},{"version":"a5866d75f24b41f3e88db8b580f0e892ea87a357be865ced4bce8bead6cd7a12","impliedFormat":99},{"version":"fe395a24df9ffd344cb825575d4b35c1cf69275208c0f99517c715bd7d08ff79","impliedFormat":99},{"version":"39e8edcbd5ac35c6cfdf2b1a794a9693a461a54efb2a475ab7fc08ab13504e26","impliedFormat":99},{"version":"ba3154f365b4217a0a46fce9efedfa70a155cebd3e85167243e6c29c72128ec6","impliedFormat":99},{"version":"b71e7f69e72d51d44ad171e6e93aedc2c33c339dab5fa2656e7b1ee5ba19b2ad","impliedFormat":99},{"version":"eb8a258495db43e8e4641def32bbbee1b73ecdc680407f948543bd9950668293","impliedFormat":99},{"version":"08fb78352391389bd98aedf175a40bdf4072ee1f73a1c9ccbbe93e7a8f1297bb","impliedFormat":99},{"version":"d17f54b297c4a0ba7be1621b4d696ef657764e3acddcc8380e9bfc66eeb324a3","impliedFormat":99},{"version":"451cdb6c6501f0afe810206659257a5b5d9c8625260c8950ad7309a40c500c3b","impliedFormat":99},{"version":"a715a2786c285a9e27ea2bbaa2ed249d3017e7139782f5ebb8eeedb777b26926","impliedFormat":99},{"version":"2dffb65044b6a28dcba73284ac6c274985b03a6ce4a3b33967d783df18f8b48c","impliedFormat":1},{"version":"f7e187abe606adf3c1e319e080d4301ba98cb9927fd851eded5bcac226b35fd1","impliedFormat":1},{"version":"335084b62e38b8882a84580945a03f5c887255ac9ba999af5df8b50275f3d94f","impliedFormat":1},{"version":"5d874fb879ab8601c02549817dceb2d0a30729cb7e161625dd6f819bbff1ec0b","impliedFormat":1},{"version":"ace68d700c2960e2d013598730888cde6d8825c54065c9f5077aaf3b2e55e3ad","impliedFormat":1},{"version":"86de522a6c6f7854738c1a88f3639e472e1778dff42ffd9f296476099cf170e6","impliedFormat":1},{"version":"4d7d964609a07368d076ce943b07106c5ebee8138c307d3273ba1cf3a0c3c751","impliedFormat":99},{"version":"0e48c1354203ba2ca366b62a0f22fec9e10c251d9d6420c6d435da1d079e6126","impliedFormat":99},{"version":"0662a451f0584bb3026340c3661c3a89774182976cd373eca502a1d3b5c7b580","impliedFormat":99},{"version":"c02203ae7f03fd2dd9c0da1a08a886734c54aae25fdf8543b1125589f20f0b52","impliedFormat":99},{"version":"409d9b2dffd896e5589be900b59d81149fd48dd811a6fca9311407e03b331e80","impliedFormat":1},{"version":"2bb615af134fe1c15f0d9f7694081d004640d38f95cb8216469116020d1e219c","impliedFormat":1},{"version":"2260604e0aa7d468ed3b9f2812a414eb70b680c45b3a691aca6c88a85babece7","impliedFormat":1},{"version":"6ef7ccbff794f08fe318744acdcccf356d5a00ddb74685a95bf8d9156d401ed8","impliedFormat":1},{"version":"3456acb6ff0d0a202eec1307f2e8b2d1cbba68dace120c47b7e38d7343da19f2","impliedFormat":1},{"version":"7a429fa77d22d12f8febc7ebbb00fa45c75c60b47ce840f92f03b05e9d16648d","impliedFormat":1},{"version":"4852930d1e33da62f75e66ae71bf7b6646d0e0aba7704ff3d1bdda15656dd7f7","impliedFormat":1},{"version":"9dc3f2a0efa278d6255bcd95b42ce28f8e14f177f6701bd6668999a34356f1c7","impliedFormat":1},{"version":"5483233566b27fecdef8a3f40420d60db822ffbdb0cf20073ac8fd0157fd2290","impliedFormat":1},{"version":"b42bc4e718dbeba955b71adc452e5023b8dda17aa57bb9050ec8c542a8e7e626","impliedFormat":99},{"version":"2091e884437c2fac7ef5b4c37a55a1d0291f3d9e774ca484054adf9088a49788","impliedFormat":1},{"version":"c2762b064c3f241efdcbfce2a3fb4fe926b9c705cbea1da8f2ee92a90bc44e27","impliedFormat":1},{"version":"6b33b56ce86bed582039802da1de9ff7f9c60946b710fb5a7a00ee8a089dc1a2","impliedFormat":1},{"version":"b4fbfaa34aacd768965b0135a0c4e7dbaa055a8a4d6ffe7bedf1786d3dc614de","impliedFormat":1},{"version":"be3daf180476b92514b9003e9bd1583a2a71ad80c9342f627ca325b863ca55d4","impliedFormat":1},{"version":"8ab9b0dd5ad04b64911bbf9ae853690d047c1e12651940bd08da5b6c8fae8b04","impliedFormat":1},{"version":"6fcb9ff90e597db84de7e94537a661dca09dc3c384e1414496d76d31f91232a3","impliedFormat":1},{"version":"ad68aac2dffb24c0330e5bcfe57aa0f2e829650c8dfe63d7329d58af7277990e","impliedFormat":1},{"version":"df0627eabd39ed947e03aedef8c677eb9ad91b733f8d6c7cdc48fc012a41ed8a","impliedFormat":1},{"version":"2164ae0de9e076bf50b097cc192d6600a7b3eb07a0e1cd3281f7f5d19d4f4638","impliedFormat":1},{"version":"e9759993d816a63028cb9a42120223941b0835c6b27aa8af69cc650a18c1bf91","impliedFormat":1},{"version":"f964f0ebc9cad8ce4873f24e82241b8eb609d304cbc1662a739443b24ef11c9e","impliedFormat":1},{"version":"f0f65a61b70d5ddb3d7f07a6e3f9d73a5da863172c815a3559c8bbb5c18bcc23","impliedFormat":1},{"version":"639c15ef2ce567ec3a62d9c51a43b65f1a8eabfdc88dc5ed57f1f23cc213189f","impliedFormat":1},{"version":"b6d80e669780b6591b159637ad0e8cf678cf6929fa0643be7d16aff7ca499bd6","impliedFormat":1},{"version":"d4e6925460a27b532a99e38bb0e579ed74b5f6422d70a210aeca9da358526f89","impliedFormat":1},{"version":"8a9d6ffa232e5599cebac02c653c01afa9480875139bab7d70654d1a557c7582","impliedFormat":99},{"version":"9ee450d9e0fbae0c5d862b03ae90d3690b725b4bd084c5daec5206aefa27c3f1","impliedFormat":99},{"version":"e2e459aac2973963ed39ec89eaba3f31ede317a089085bf551cc3a3e8d205bb4","impliedFormat":99},{"version":"bd3a31455afb2f7b1e291394d42434383b6078c848a9a3da80c46b3fa1da17d5","impliedFormat":99},{"version":"51053ea0f7669f2fe8fc894dcea5f28a811b4fefdbaa12c7a33ed6b39f23190b","impliedFormat":99},{"version":"5f1caf6596b088bd67d5c166a1b6b3cd487c95e795d41b928898553daf90db8d","impliedFormat":99},{"version":"eaeaddb037a447787e3ee09f7141d694231f2ac7378939f1a4f8b450e2f8f21f","impliedFormat":99},{"version":"7c76a8f04c519d13690b57d28a1efe81541d00f090a9e35dca43cde055fed31b","impliedFormat":99},{"version":"17c976add56f90dd5aad81236898bad57901d6bdac0bd16f3941514d42c6fcc7","impliedFormat":99},{"version":"0d793c82f81d7c076f8f137fa0d3e7e9b6a705b9f12e39a35c715097c55520c9","impliedFormat":99},{"version":"7c6fd782f657caea1bfc97a0ad6485b3ad6e46037505d18f21b4839483a66a1c","impliedFormat":99},{"version":"4281390dad9412423b5cc3afccf677278d262a8952991e1dfaa032055c6b13fb","impliedFormat":99},{"version":"02565e437972f3c420157d88ae89e8f3e033c2962e010483321c54792bce620a","impliedFormat":99},{"version":"1623082417056ce69446be4cf7d83f812640f9e9c5f1be99d6bc0fad0df081ab","impliedFormat":99},{"version":"0c1f67774332e01286cdd5e57386028dd3255576c8676723c10bd002948c1077","impliedFormat":99},{"version":"232c6c58a21eb801d382fb79af792c0ec4b2226a4c9e4cf64a52246538488468","impliedFormat":99},{"version":"196ce15505ddb7df64fa2b9525ec99ec348d66b021e76130220a9ac37840a04a","impliedFormat":99},{"version":"899a2d983c33f9c00808bf53720d3d74a4c04a06305049c5da8c9e694c0c0c74","impliedFormat":99},{"version":"942719a6fafe1205a3c07cecc1ea0c5d888ff5701a7fbbd75d2917070b2b7114","impliedFormat":99},{"version":"7ad9c5c8ca6f45cf8cc029f1e789177360ef8a1ac2d2e05e3157f943e70f1fa3","impliedFormat":99},{"version":"e9204156d21f5dd62fa4676de6299768b8826bb02708a6e96043989288c782c7","impliedFormat":99},{"version":"b892c877d4b18faad42fd174f057154101518281f961a402281b21225bf86e2f","impliedFormat":99},{"version":"755e75ad8e93039274b454954c1c9bb74a58ac9cef9ff37f18c6f1e866842e2e","impliedFormat":99},{"version":"53e7a7fa0388634e99cf1e1be2c9760c7c656c0358c520f7ec4302bd1c5e2c65","impliedFormat":99},{"version":"f81b440b0a50aa0e34f33160e2b8346127dbf01380631f4fc20e1d37f407bef9","impliedFormat":99},{"version":"0791871b50f78d061f72d2a285c9bfac78dba0e08f0445373ad10850c26a6401","impliedFormat":99},{"version":"d45d1d173b8db71a469df3c97a680ed979d91df737aa4462964d1770d3f5da1b","impliedFormat":99},{"version":"e616ad1ce297bf53c4606ffdd162a38b30648a5ab8c54c469451288c1537f92e","impliedFormat":99},{"version":"8b456d248bb6bc211daf1aae5dcb14194084df458872680161596600f29acb8d","impliedFormat":99},{"version":"1a0baa8f0e35f7006707a9515fe9a633773d01216c3753cea81cf5c1f9549cbd","impliedFormat":99},{"version":"7fa79c7135ff5a0214597bf99b21d695f434e403d2932a3acad582b6cd3fffef","impliedFormat":99},{"version":"fb6f6c173c151260d7a007e36aa39256dd0f5a429e0223ec1c4af5b67cc50633","impliedFormat":99},{"version":"eebfa1b87f6a8f272ff6e9e7c6c0f5922482c04420cde435ec8962bc6b959406","impliedFormat":99},{"version":"ab16001e8a01821a0156cf6257951282b20a627ee812a64f95af03f039560420","impliedFormat":99},{"version":"f77b14c72bd27c8eea6fffc7212846b35d80d0db90422e48cd8400aafb019699","impliedFormat":99},{"version":"53c00919cc1a2ce6301b2a10422694ab6f9b70a46444ba415e26c6f1c3767b33","impliedFormat":99},{"version":"5a11ae96bfae3fb5a044f0f39e8a042015fb9a2d0b9addc0a00f50bd8c2cc697","impliedFormat":99},{"version":"59259f74c18b507edb829e52dd326842368eaef51255685b789385cd3468938f","impliedFormat":99},{"version":"30015e41e877d8349b41c381e38c9f28244990d3185e245db72f78dfba3bbb41","impliedFormat":99},{"version":"52e70acadb4a0f20b191a3582a6b0c16dd7e47489703baf2e7437063f6b4295a","impliedFormat":99},{"version":"15b7ac867a17a97c9ce9c763b4ccf4d56f813f48ea8730f19d7e9b59b0ed6402","impliedFormat":99},{"version":"fb4a64655583aafcb7754f174d396b9895c4198242671b60116eecca387f058d","impliedFormat":99},{"version":"23dae33db692c3d1e399d5f19a127ae79324fee2047564f02c372e02dbca272d","impliedFormat":99},{"version":"4c8da58ebee817a2bac64f2e45fc629dc1c53454525477340d379b79319fff29","impliedFormat":99},{"version":"50e6a35405aea9033f9fded180627f04acf95f62b5a17abc12c7401e487f643f","impliedFormat":99},{"version":"c1a3ca43ec723364c687d352502bec1b4ffece71fc109fbbbb7d5fca0bef48f1","impliedFormat":99},{"version":"e88f169d46b117f67f428eca17e09b9e3832d934b265c16ac723c9bf7d580378","impliedFormat":99},{"version":"c138a966cc2e5e48f6f3a1def9736043bb94a25e2a25e4b14aed43bff6926734","impliedFormat":99},{"version":"b9f9097d9563c78f18b8fb3aa0639a5508f9983d9a1b8ce790cbabcb2067374b","impliedFormat":99},{"version":"925ad2351a435a3d88e1493065726bdaf03016b9e36fe1660278d3280a146daf","impliedFormat":99},{"version":"100e076338a86bc8990cbe20eb7771f594b60ecc3bfc28b87eb9f4ab5148c116","impliedFormat":99},{"version":"d2edbba429d4952d3cf5962dbfbe754aa9f7abcfcbdda800191f37e07ec3181b","impliedFormat":99},{"version":"8107fdc5308223459d7558b0a9fa9582fa2c662bd68d498c43dd9ab764856bc7","impliedFormat":99},{"version":"a35a8a48ad5d4aad45a79f6743f2308bdaea287c857c06402c98f9c3522a7420","impliedFormat":99},{"version":"e4aa88040fd946f04fe412197e1004fb760968ac3bd90d1a20bfb8b048f80ce0","impliedFormat":99},{"version":"f16df903c7a06f3edd65f6292fef3698d31445eaca70f11020201f8295c069b5","impliedFormat":99},{"version":"d889a5532ecd42d61637e65fac81ea545289b5366f33be030e3505a5056ee48a","impliedFormat":99},{"version":"6d8762dd63ee9f93277e47bf727276d6b8bdd1f44eb149cfa55923d65b9e36bc","impliedFormat":99},{"version":"bf7eebda1ab67091ac899798c1f0b002b46f3c52e20cccb1e7f345121fc7c6c2","impliedFormat":99},{"version":"9a3983d073297027d04edec69b54287c1fbbd13bbe767576fdab4ce379edc1df","impliedFormat":99},{"version":"8f42567aa98c36a58b8efb414a62c6ad458510a9de1217eee363fbf96dfd0222","impliedFormat":99},{"version":"8593dde7e7ffe705b00abf961c875baef32261d5a08102bc3890034ae381c135","impliedFormat":99},{"version":"53cf4e012067ce875983083131c028e5900ce481bc3d0f51128225681e59341b","impliedFormat":99},{"version":"6090fc47646aa054bb73eb0c660809dc73fb5b8447a8d59e6c1053d994bf006e","impliedFormat":99},{"version":"b6a9bf548a5f0fe46a6d6e81e695d367f5d02ce1674c3bc61fe0c987f7b2944f","impliedFormat":99},{"version":"d77fa89fff74a40f5182369cc667c9dcc370af7a86874f00d4486f15bdf2a282","impliedFormat":99},{"version":"0c10513a95961a9447a1919ba22a09297b1194908a465be72e3b86ab6c2094cc","impliedFormat":99},{"version":"acfce7df88ff405d37dc0166dca87298df88d91561113724fdcb7ad5e114a6ba","impliedFormat":99},{"version":"2fb0e1fc9762f55d9dbd2d61bbc990b90212e3891a0a5ce51129ed45e83f33ee","impliedFormat":99},{"version":"7be15512c38fdbed827641166c788b276bcfa67eda3a752469863dbc7de09634","impliedFormat":99},{"version":"cbba36c244682bbfaa3e078e1fb9a696227d227d1d6fc0c9b90f0a381a91f435","impliedFormat":99},{"version":"ec893d1310e425750d4d36eb09185d6e63d37a8860309158244ea84adb3a41b8","impliedFormat":99},{"version":"0d350b4b9b4fea30b1dbac257c0fc6ff01e53c56563f9f4691458d88de5e6f71","impliedFormat":99},{"version":"4642959656940773e3a15db30ed35e262d13d16864c79ded8f46fb2a94ed4c72","impliedFormat":99},{"version":"a2341c64daa3762ce6aefdefc92e4e0e9bf5b39458be47d732979fb64021fb4f","impliedFormat":99},{"version":"5640ea5f7dfd6871ab4684a4e731d48a54102fd42ea7de143626496e57071704","impliedFormat":99},{"version":"7f6170c966bbd9c55fd3e6bcc324b35f5ca27d70e509972f4b6b1c62b96c08ff","impliedFormat":99},{"version":"62cb7efe6e2beecb46e0530858383f27e59d302eb0a6161f66e4d6a98ae30ff5","impliedFormat":99},{"version":"a67ae9840f867db93aca8ec9300c0c927116d2543ecc0d5af8b7ab706cdda5ad","impliedFormat":99},{"version":"658b8dbb0eef3dcfbcaf37e90b69b1686ba45716d3b9fb6e14bb6f6f9ef52154","impliedFormat":99},{"version":"1e62ffb0b2bc05b7b04a354710596e60ac005cab6e12face413855c409239e9b","impliedFormat":99},{"version":"c92349bad69a4e56ac867121cda04887a79789adb418b4ee78948a477f0c4586","impliedFormat":99},{"version":"d49420a87cc4608acbd4e8ce774920f593891047d91c6b153f0da3df3349b9be","impliedFormat":99},{"version":"44376b040b0712ffe875ad014bb8c9f84d7648487cdf36e8bbe8f4888f860a03","impliedFormat":99},{"version":"4c704b137991192a3d2f9e23a3ded54bdb44f53ea5884c611c48637064e8c6cb","impliedFormat":99},{"version":"917af11888db0ac87046f9b31f8ccb081d2da9ba650d6aab9636a018f2d86259","impliedFormat":99},{"version":"d6c196e038cb164428f2f92feb0191de8a95d60aad8eb65bc703d3499d7ff888","impliedFormat":99},{"version":"b27723af585d0cf2e5f6a253b2989d084ba5c7ffe24130ab33d3c01f60f8f7c8","impliedFormat":99},{"version":"37f271a1de9b674667cffbd616832f4127c0a364d502b2b33e3e9c6b16fde1b8","impliedFormat":99},{"version":"0c796f53945fee54a07b295dbd1f1303c7a73cdd2c629e66fbfa5e29df16de9e","impliedFormat":99},{"version":"2b3045052668b317d06947a6ab1187755b2ad4885dd6640b6a8fe174e139ec5e","impliedFormat":99},{"version":"44ee21f3f866b5517804aadc860c89da792cca2d3ad7431d5742c147be7deb82","impliedFormat":99},{"version":"57bc6a334f498834fe779ea68e92a06c569e3b6757b608a092119589c34b7242","impliedFormat":99},{"version":"ccc8793b3493c8cf50af8e181da08e4e7ff327535724dfde8bf56249a385954f","impliedFormat":99},{"version":"c48b220c9a10db0df2d791b93d332575bb57033797da241c124f87c2171159ea","impliedFormat":99},{"version":"d1509856fe7e38720ef11b8e449d4ada04879e5ecfd2d09b41c2e4a07b3d8dd1","impliedFormat":99},{"version":"3883734e7cba8ceb7a314ca68c97ac3f69031a2fde7830e5b2e2339f10520497","impliedFormat":99},{"version":"54396051cf9f736287426d1f3c9ec0f8afad30a4d3e607f65ffd6205ec90bdce","impliedFormat":99},{"version":"4c5ed0d7c2b8dc59f2bcc2141a9479bc1ae8309d271145329b8074337507575d","impliedFormat":99},{"version":"2bdc0310704fe6b970799ee5214540c2d2ff57e029b4775db3687fbe9325a1e4","impliedFormat":99},{"version":"d9c92e20ad3c537e99a035c20021a79c66670da1c4946e1b66468ca0159e7afd","impliedFormat":99},{"version":"b62f1c33a042e7eb17ac850e53eb9ee1e7a7adbfa4aacf0d54ea9c692b64fc07","impliedFormat":99},{"version":"c5f8b0b4351f0883983eb2a2aaa98556cc56ed30547f447ea705dbfbe751c979","impliedFormat":99},{"version":"6a643b9e7a1a477674578ba8e7eed20b106adbef86dabe0faf7c2ba73dc5b263","impliedFormat":99},{"version":"6e434425d09e4a222f64090febcbbfbb8fb19b39cec68a36263a8e3231dab7ad","impliedFormat":99},{"version":"58afdddfd9bc4529afe96203e2001dcc150d6f46603b2930e14843a2adc0bef3","impliedFormat":99},{"version":"faa121086350e966ec3c19a86b64748221146b47b946745c6b6402d7ecf449d4","impliedFormat":99},{"version":"a9286d1583b12fd76bf08bcd1d8dad0c5e3c0618367fe3fe49326386fee528bd","impliedFormat":99},{"version":"141c5152b14aa1044b7411b83a6a9707f63e24298bfc566561a22d61b02177a4","impliedFormat":99},{"version":"dce464247d9d69227307f085606844dc1a6badc1e10d6f8e06f3a72d471e7766","impliedFormat":99},{"version":"26333aa1e58f4c7c6acb6cdb1490ba000c857f7e8a21608019ca9323ad97365e","impliedFormat":99},{"version":"b36269da8b9c370075ad842a17f7d284bae04bc07d743aa25cc396d2bbd922cd","impliedFormat":99},{"version":"1e5afd6a1d7f160c2da8ed1d298efcd5086b5a1bdb10e6d56f3ed9d70840aa5d","impliedFormat":99},{"version":"2e7c3024fa224f85f7c7044eded4dba89bf39c6189c20224fa41207462831e06","impliedFormat":99},{"version":"4ca05a8dfe3b861cf6dc4e763519778fc98b40655e71ddee5e8546390cf42b21","impliedFormat":99},{"version":"f96c214198c797da18198b7c660627faf40303ba4d1ac291ac431046ec018853","impliedFormat":99},{"version":"fa20380686e1f6c7429e3194dea61e9d68b7af55fa5fc6da5f1da8fc2b885c3d","impliedFormat":99},{"version":"d3a480946bced3c94e6b8ab3617330e59bf35c3273a96448d6e81ba354f6c20e","impliedFormat":99},{"version":"ff72b0d58aa1f69f3c7fa6e5a806aa588b5024d8bd81cb8314b6df32759cafdd","impliedFormat":99},{"version":"feccbe0137990c333898ac789870caf62bddf7b7f825cca3f5aac4388d867695","impliedFormat":99},{"version":"5d0b0e10dd5f4857dcf4703a4c86d92fe3e1d82a68ffc6739d777fc2ff6d6902","impliedFormat":99},{"version":"d002e1dad5ff22c6d7b9b4e8b09302b99fe6089f907e4e00310b1eea88d24a01","impliedFormat":99},{"version":"0497b91aa0292f7cafe54202e69cb467242426a414623aac0febc931c92b10f2","impliedFormat":99},{"version":"faf1f29f98e2a8db3737827234c5de88d2bf1546471c05b136578190ed647eb9","impliedFormat":99},{"version":"80634ab7f8f65c7b4663e807f8d961c683eaea3b0e58818524c847abb657b795","impliedFormat":99},{"version":"85e852e090c97b25243fb6c986cad3d2b48d0bb83cd1c369f6ff1cf9743ab490","impliedFormat":99},{"version":"12e856f6193309e09fbab3ce89f70e622c19b52cbeaad07b14d47ef19063e4dc","impliedFormat":99},{"version":"d3f4fda002f6200565ef1a5f6bcad4e28e150c209e95716e101d6c689ae11503","impliedFormat":99},{"version":"497a791143290119136bfcde6cd402e3b7d211df944188d1a4a511b8df5a9b13","impliedFormat":99},{"version":"1cb9dab41d415a2a401d52c6bede4ad5aa14a732b2914c01c16cc8b0fc69cf88","impliedFormat":99},{"version":"617108f6e6514fbfa7bf226cf99c33c8872a28517f5b7e855c657d4132afeb3d","impliedFormat":99},{"version":"194823a242a97327f6ac0af92f3d37fc078d4773149724fbb5176093eb7b0617","impliedFormat":99},{"version":"085f9e9b8f27c4833a6cf9228b1ae26d383bf7eb4e0677b5321029564336deff","impliedFormat":99},{"version":"34b81ae7140be9b70a7dfded8acebc06d62c5508617b196739e578595949724d","impliedFormat":99},{"version":"c7631702b00fbbac3682deeeaeaac4bfc0694bec74dda8db4afae1098310e18c","impliedFormat":99},{"version":"b0c04f92ff4c9da466ba563170892afe043ecd0f088deb3d3dc482a747d75bf0","impliedFormat":99},{"version":"c4d6664fa99f28b210a65e5feccc41723bf77d89e5f00afdbdaf25726a9ea4c3","impliedFormat":99},{"version":"f4940ce6889056747592fc93a331d7e33db8889d48e401397cfa15fa27ac4000","impliedFormat":99},{"version":"2e3ae7d41b13b4ebfdf76eb20d4282b72b4eafb9b75b0f850177d03e92f59d7b","impliedFormat":99},{"version":"e37392287850bebf777be5e4b573ef447b3437bf46f85969f9d9b4b37b7a8629","impliedFormat":99},{"version":"68771841743fe93f5732c94a93447cfc2ebce7de956330fcb704e82725f218be","impliedFormat":99},{"version":"6e58d2b1619cb5b2312a57fb1a0071f693ac0c7547f12d4e38c2b49629f71b9f","impliedFormat":99},{"version":"8363077b4b4520e9cfff74d0ae1d034b84f7429d35265e9e77daedeb428297f2","impliedFormat":99},{"version":"541cfa49f8c37ea962d96f4e591487524af58bfbf4faf45e904a4e1b25b7a7aa","impliedFormat":99},{"version":"ebb09c62607092b0aa7dbc658b186ee8cc39621de7f3ccf8acbd829f2418d976","impliedFormat":99},{"version":"f797dc6c71867b6da17755cfdbd06ef5ed5062e1b6fd354a07929a56546d4f4d","impliedFormat":99},{"version":"686bd9db685be2e1f812cf82d476c7702986ad177374dad64337635af24a0b9f","impliedFormat":99},{"version":"cc8520ff04dae6933f1eec93629b76197fb4a40a3a00da87c44e709cfa4af1ba","impliedFormat":99},{"version":"55880163bc61bc2478772370acce81a947301156cdce0d8459015f0e5a3f3f9c","impliedFormat":99},{"version":"d7591af9e3eee9e3406129e0dacb69eb2ac02f8d7ceb62767a6489cb280ca997","impliedFormat":99},{"version":"522356a026eb12397c71931ff85ce86065980138e2c8bce3fefc05559153eb80","impliedFormat":99},{"version":"1b998abad2ae5be415392d268ba04d9331e1b63d4e19fa97f97fe71ba6751665","impliedFormat":99},{"version":"81af071877c96ddb63dcf4827ecdd2da83ee458377d3a0cb18e404df4b5f6aa0","impliedFormat":99},{"version":"d087a17b172f43ff030d5a3ede4624c750b7ca59289e8af36bc49adb27c187af","impliedFormat":99},{"version":"e1cc224d0c75c8166ae984f68bfcdcd5d0e9c203fe7b8899c197e6012089694c","impliedFormat":99},{"version":"1025296be4b9c0cbc74466aab29dcd813eb78b57c4bef49a336a1b862d24cab0","impliedFormat":99},{"version":"18c8cf7b6d86f7250a7b723a066f3e3bf44fd39d2cb135eaffe2746e9e29cc01","impliedFormat":99},{"version":"c77cd0bddb5bec3652ff2e5dd412854a6c57eaa5b65cbf0b6a47aae37341eca9","impliedFormat":99},{"version":"e4a2ca50c6ded65a6829639f098560c60f5a11bc27f6d6d22c548fe3ec80894d","impliedFormat":99},{"version":"e989badc045124ca9516f28f49f670b8aeee1fb2150f6aefd87bb9df3175b052","impliedFormat":99},{"version":"d274cf19b989b9deff1304e4e874bc742816fca7aae3998c7feec0a1224079c7","impliedFormat":99},{"version":"0aefb67a9c212a540e2dedb089c4bbe274d32e5a179864d11c4eea7dc3644666","impliedFormat":99},{"version":"2767af8f266375ebd57c74932f35ce7231e16179d3066e87bcb67da9b2365245","impliedFormat":99},{"version":"34a1c0d17046ac6b326ed8fbe6e5a0b94aeef9e50119e78461b3f0e0c3a4618a","impliedFormat":99},{"version":"6fd58a158e4a9c661d506c053e10c7321edaa42b930e73b7a6d34eb81f2a71e8","impliedFormat":99},{"version":"60e18895fc4bff9e2f6fb58b74fcf83191386553e8ab0acc54660d65564e996c","impliedFormat":99},{"version":"41d624e8c6522001554fdddef30fed443b4c250ec8ddbb553bbe89e7f7daf2f4","impliedFormat":99},{"version":"b3034ec5a961ab98a41bc59c781bf950bb710834f1f99bf4b07bfbba77e2f04a","impliedFormat":99},{"version":"2115776fcd8001f094066e24d80b7473bbc2443a5488684f9f3a94a3842daadb","impliedFormat":99},{"version":"55e49ce04550294b3a40dcd9146d5611cfcd4fa317eb2dcb2c19dd28dea09f58","impliedFormat":99},{"version":"96149ea111d0a0017b95606821a16d4a1cf2470f1460549ba65ec63bf9224b5d","impliedFormat":99},{"version":"5b290d80e30d0858b30aab7ccff4dbfa68195f7a38f732a59cfe341764932910","impliedFormat":99},{"version":"a85ee477d4e97c2bfae6716b0faaaacef6b4f3de64e0b449c0347322e92a594e","impliedFormat":99},{"version":"8c11d3a3eac4c18abf364d20dde653c8b4d3c3ad85bb55da285209140dae256c","impliedFormat":99},{"version":"262fcc12bd0cb2fe7ce2115093ae2b083cf425329b7966d8857af78e1e33814d","impliedFormat":99},{"version":"24f4daf278786772d9cee29876e85f5f6712c65b741b997a900b1d942c8f217e","impliedFormat":99},{"version":"a2be1e277d805c54f038fee25fd291b5fdd76990be855454bd48e336b315fb8b","impliedFormat":99},{"version":"dce9350553d244fa5ad6cff4e9aea3664d918113ddff74ef84210b0481b79f74","impliedFormat":99},{"version":"8802c923b63c304b8e014600ff58fb9542323e842701aba9e69df60c7c979df5","impliedFormat":99},{"version":"b5a14e52ffa8efd7e31e7856bbf36a7bce32446283a9b51e0a819b04a94f2ce4","impliedFormat":99},{"version":"9cc999adecb60f81915c635cc91acdb0b79904370653acc283b97656b5b2cfa8","impliedFormat":99},{"version":"80249dc33a16d10faf6ec20ea50d4c72b0d92e55070bba0327de428e1d0979e7","impliedFormat":99},{"version":"7367f5f54504a630ff69d0445d4aecf9f8c22286f375842a9a4324de1b35066f","impliedFormat":99},{"version":"0b86afbb8d60fd89e3033c89d6410844d6cb6a11d87e85a3ef6f75f4f1bae8a8","impliedFormat":99},{"version":"9cfb95029f27b79f6c849bbb7d36a4318d8acf1c7b7d3618936c219ad5cddab7","impliedFormat":99},{"version":"2a4181e00cfe58bdce671461642f96301f1f8921d0f05bd1cc7750bbf25dd54a","impliedFormat":99},{"version":"24e33e2ece5223951e52df17904dcc52a4022be3eb639ab388e673903608eb37","impliedFormat":99},{"version":"506eaf48e9f57567649da05e18ddd5e43e4ad46d0227127d67f07152e4415f29","impliedFormat":99},{"version":"9e5247c2cdf36b8c44d22caa499decd252577b8b5f718b498f7a8b813d81a210","impliedFormat":99},{"version":"69abcf790968f38d1e58bccff7691aa2553d14daada9f96dcc5fe2b1f43762c3","impliedFormat":99},{"version":"5e88a51477d77e8ec02675edf32e7d1fccdc2af60972d530c3e961bd15730788","impliedFormat":99},{"version":"0620fa1ded997cd0cdc1340e9b34d3fe5e84f46ba109b4a69176df548e76081c","impliedFormat":99},{"version":"8508ed314834f8865469a0628cc8d6c31bf5ea2905f8a87f336a2168e66f91f4","impliedFormat":99},{"version":"9757602b417a9364a599c07507e8c9a4e567f78829eeb03a7c64b79ffb16caf9","impliedFormat":99},{"version":"e0bfc7204238bd5b19f0b9f3cd8aa9e31979835772102d2f4fa0e4728140bdbf","impliedFormat":99},{"version":"070ff67371e23b620cbf776e08881a3d1ff6cdf06c1cf6a753fb89b870c6f310","impliedFormat":99},{"version":"d2e8a7070ff0c6815be4ccca5071fe90d7923702e6348fa83275b452768f701a","impliedFormat":99},{"version":"63c057f6b98e622b13aa24a973bbdf0fef58d44e142a1c67753e981185465603","impliedFormat":99},{"version":"2b857bdc485905b1be1cee2e47f60fc50e4113f4f7c2c7301cdc0f14c013278e","impliedFormat":99},{"version":"4abccbf2fc4841cf06c0ff49f6178d8f190f2645acda5d365e61a48877b8b03e","impliedFormat":99},{"version":"b4ababf5c8f64e398617d5f683ad6c8694f19f589485580623a927121cfab64b","impliedFormat":99},{"version":"f856d3559afde2a5e3f0e4e877d0397fe673eea71ac3683abb7c6cef429c192d","impliedFormat":99},{"version":"8148fe494a3556aec26a46b0deba7a85d78883b285e408ebf69ff1cfd1531c00","impliedFormat":99},{"version":"0942f7d40c91c30a5936d896de2194238ad65a45e7540bab7f7f588b70242bb8","impliedFormat":99},{"version":"b808dbc3d555d643bd6410da582c2d7512b39dc8331acef7d4752fff0f390b5f","impliedFormat":99},{"version":"65971cd38702bdce2440a7322eccccf978a37e481b44e22dd0b34aee30e0b6dd","impliedFormat":99},{"version":"c6f038949f364df4f690cebfe93324f54d53c9c50aec6c8e5508b7f6a6ea4df7","impliedFormat":99},{"version":"58a0bdd8fa7be3a362ce850e4af11c7a4f82abcbfad36201463f7b28ebf53e7e","impliedFormat":99},{"version":"cc9f07af7679c686e5e68c3933a4430af6ea651ed0c1cfcf0db7c60576d05ccc","impliedFormat":99},{"version":"d45698ab81cc9a9722ec492e7442de1136be3c2a5c830b7c700c3cae020bbf70","impliedFormat":99},{"version":"18441c1a35fed75775881c3b918c3ea4a630f02e43c8179225a268055907b140","impliedFormat":99},{"version":"bbe0ac66e24ba0c5d30dfc8f0579e3c660f8e1f3b8f234c7cbdd9fd2db9ed22f","impliedFormat":99},{"version":"63e65622cd147ea99f39f8833c65d7c2b7a0595c86ce71e92e04b07d1f38d3ad","impliedFormat":99},{"version":"6a840e9604c761dd515f8c76ea08c648beed01129b75133e0d54e24372802302","impliedFormat":99},{"version":"7b853ab7e6a660ca2dfdc36eff9d3cb5215b3e10acbe65a09ed6d9be52c38d9b","impliedFormat":99},{"version":"cb1f24cd504d21fe92ea004fab2b3e496248b4230c3133c239fbc37413a872b7","impliedFormat":99},{"version":"d7ec8da78b951af56a738ab0586815263a433ef3517c4e3ea6aad5dfd65c4a04","impliedFormat":99},{"version":"6adb1517628439ae88aeb0419f4fa89eacda98f89791fcd05fa92ad2cdc389af","impliedFormat":99},{"version":"87e256c8149c5487ef2c47297770c4e0e622271ac1c8902dc0b31795062a1410","impliedFormat":99},{"version":"99c98d7abbf313f8978c0df4fae66f5caf05b1e7075a2a3f0e8cd28c5abb56d2","impliedFormat":99},{"version":"3d7c052002e317d7ff01dbe4c6cf82aa20b6ef751101139c38c547636d872ffe","impliedFormat":99},{"version":"353fd6acf4bc2232c850bcf24fa6512a85517623f84dabe4dc4a22fcd0a69f00","impliedFormat":99},{"version":"f9c4bdf33b97ce2f7c4fa422c32ce85f8f4cafa4421e02172279ee5ebd097804","impliedFormat":99},{"version":"1f098514ce3fb820e89bde510a34b939f281581a7c1e9d39527ec90cec46f7c8","impliedFormat":99},{"version":"54b21f4fe217619f1b1dc43b92f86b741c55400b5f35bfd42f8ea51b2f6248a1","impliedFormat":99},{"version":"48d9c8e386b3ba47dd187ee4b118c49d658cdac580879984b1dc364cf5a994ca","impliedFormat":99},{"version":"b69cecaec600733bb42800ac1f4be532036f3e8c88e681f692b4654475275261","impliedFormat":99},{"version":"bb8e4982de3a8add33577b084a2a0a3c3e9ebf5a1ec17ddfe6677130ec19b97d","impliedFormat":99},{"version":"5a8aa1adc0a8d6cf8a106fd8cc422e28ca130292d452b75d17678d24ab31626b","impliedFormat":99},{"version":"f4d331bd8e86deaaeedc9d69d872696f9d263bcb8b8980212181171a70bf2b03","impliedFormat":99},{"version":"c4717c87eecbb4f01c31838d859b0ac5487c1538767bba9b77a76232fa3f942e","impliedFormat":99},{"version":"90a8959154cd1c2605ac324459da3c9a02317b26e456bb838bd4f294135e2935","impliedFormat":99},{"version":"5a68e0660309b9afb858087f281a88775d4c21f0c953c5ec477a49bb92baa6ec","impliedFormat":99},{"version":"38e6bb4a7fc25d355def36664faf0ecfed49948b86492b3996f54b4fd9e6531e","impliedFormat":99},{"version":"a8826523bac19611e6266fe72adcc0a4b1ebc509531688608be17f55cba5bb19","impliedFormat":99},{"version":"4dc964991e81d75b24363d787fefbae1ee6289d5d9cc9d29c9cec756ffed282b","impliedFormat":99},{"version":"e42a756747bc0dbc1b182fe3e129bfa90e8fb388eee2b15e97547e02c377c5ef","impliedFormat":99},{"version":"8b5b2e11343212230768bc59c8be400d4523849953a21f47812e60c0c88184b3","impliedFormat":99},{"version":"d96b4e9f736167c37d33c40d1caae8b26806cdd435c1d71a3a3c747365c4163c","impliedFormat":99},{"version":"363b0e97b95b3bcc1c27eb587ae16dfa60a6d1369994b6da849c3f10f263fd04","impliedFormat":99},{"version":"6c7278e2386b1993c5d9dfa7381c617dc2d206653b324559f7ef0595a024a3da","impliedFormat":99},{"version":"f5d731a9084db49b8ffd42bc60aecb28f90966e489261d7ec5f00c853efc3865","impliedFormat":99},{"version":"4dcc76850d97256f83a7d45b40327725db3aa7ee02dee3b1e860ca81ce591694","impliedFormat":99},{"version":"70fa22a23b35e04482f13ab7f697a057506503e21ced87d933359e3224c92ed5","impliedFormat":99},{"version":"709622bea0f7188c66bcee996bd4f24221c69d67e1d04797a11ebdd1311096cd","impliedFormat":99},{"version":"e8ad189c7d2932a01feadccefca9c873bee40d202fb53f708f1e7b1efce4ffef","impliedFormat":99},{"version":"ed3dbe543bbf46c4365e3eb5faa3fa87f0fe0c3db4b2476b8f430838432e2b8c","impliedFormat":99},{"version":"1ad2f20d17cad8ed17df10daf3f9050161fd42a86d5b7afd0a1dacac216e9c14","impliedFormat":99},{"version":"4e6502d4dc180cdff48d77f6ee04007167bef42f7b5488dbadedb0ddb1e9cdf1","impliedFormat":99},{"version":"e41e03387b7c74aae146473ff507c26b07699cfcd953f79dd174bfd624bcb5d0","impliedFormat":99},{"version":"ff671a3c1efcc1a96ca6f418c7a9616ae4a4c6110ece811fc1ec8013a3a24e6b","impliedFormat":99},{"version":"a105278208759f167642ea5b37b78661edf4b0350824ad2f961a329e5976b9b6","impliedFormat":99},{"version":"6f9a389203f44e1c344e5e5d8c0ddad05f0f2e033d0657297894cd8e6ca4747f","impliedFormat":99},{"version":"636ddb4225f892b1033182ae24af259fe30d5209a2b9e69d7374c3268818b9d3","impliedFormat":99},{"version":"c00c3b2b915c5cd789a78f86c98c211c78646872ed84ddc478994e97c6560a0a","impliedFormat":99},{"version":"592640ac835589f476f9cefbffdfeef79dc327bb9b25c0a3f92549fcd8e8c514","impliedFormat":99},{"version":"24033c6280d58689e7cdb5af09e2766c6b44a3747dbb0d844f155bd0621024f0","impliedFormat":99},{"version":"1914db9d25d18ff046611a41a8129ad01c829d5f9565f16660c7d09c66f776c6","impliedFormat":99},{"version":"054c4bef46bc70b9fbb18481f501bac861cd54af683fe5942e5c7e7d3b0c1fb5","impliedFormat":99},{"version":"d6ce9fe8c2849756dae3c9e11de07966bb58b6638a462098a3a1b23d78b56ef0","impliedFormat":99},{"version":"0f149ffde075123eb05b9aefdd405d5dc1acd729f94b3dedaf9f48d9fbbe2348","impliedFormat":99},{"version":"193a5fc1bfbc703c3772e05dfffb1c821ef30bb2d787f906fc26c38718bb35bb","impliedFormat":99},{"version":"dfdc408e78629b12771eca9a58edbeeb2f4783e79841368a069b8eb65ce447ce","impliedFormat":99},{"version":"513601842e2f161c0e7c3bc35c433f793f338b5d7d0465423d071486f43b65e4","impliedFormat":99},{"version":"5270479971ab757c197fa22d4eb07bf7bfc886440a76da240e095d5ffb2e95bc","impliedFormat":99},{"version":"8f5d63fde9f0ace19cfcec1a2bc4bc0efec47b89465216817204448dc6dfd5a2","impliedFormat":99},{"version":"65323bbeb0b10634c92484812f6a0020d3ca38a888c2a536962b425cb77d8e77","impliedFormat":1},{"version":"767183261649b963ccc7daa3d2ae38cc604ce60fc3a453a15a8afa9a4daba71f","impliedFormat":1},{"version":"5fb2b92475a3963e7b4ee8152cc6c3ae066081364b4abaeea695a5001db32e63","impliedFormat":1},{"version":"890d6c959fe26e8bd017bbb9b25623c227368fa1983a8966055c960b14de1452","impliedFormat":1},{"version":"4b5ed80412f64641dc5caf5af1c98d8083315bcf5f4d9bceea7b6aac4a1b865b","impliedFormat":1},{"version":"81957f051f71d2f4b0b20fbe8bfc40cbaa4d9a441ee3af3ec82646a96076429d","impliedFormat":1},{"version":"e4630dcc04c04cfed62e267a2233cae1367a7366d5cadcf0d2c0d367fd43e8d4","impliedFormat":1},{"version":"f7f13164c6c9b9e638ac98ffd06041a334cb20564d24d37185e29408d00cea8f","impliedFormat":1},{"version":"eec0d8defb7ed885473e742b9298a2f253f2113688787c2495b4f8228bc22590","impliedFormat":1},{"version":"de2cddc05d2aff0460f1bb27f796e9134b049e4fab33716b4d658628e0976105","impliedFormat":1},{"version":"4bd3e56fca57ce532152c64036a2153d61f2c1acfc27b4d679b1f4829988b9f4","impliedFormat":1},{"version":"7640a64392d0920c04d091373eb8ca038d6e80cc5b202bddcb0ea0937f90def4","impliedFormat":1},{"version":"ec817057681d50c1c0d2a3c805aee50e6df7c51c60484fdf590c81b9a5001931","impliedFormat":1},{"version":"bf6c2b7d7ef94e5d5add264d87aa2321e2e1d875d74e2ff1a5870b3fd0fa4506","impliedFormat":99},{"version":"da85d4bf5436447eea22ed6404226fa97f44ae375559ac97b5d3d5d86c1d5b72","impliedFormat":99},{"version":"e86e6db08b9106c95115542563d5a49d20447cf08cd2994dbd86c1896c49dc08","impliedFormat":99},{"version":"c3bbaa7348f9e5ca7e7c67c18aa0db9cfbfb1485ab4c13b73e8e0a15766b99de","impliedFormat":99},{"version":"338d21e6e39eac5d7df7fbad9179a489c4689471775cedc24a4eacd2b4acfc97","impliedFormat":1},{"version":"71c894f7dbb289f6b9907e4d70f0ccaa746be732a7d65354e6bcd23405fcc1e6","impliedFormat":1},{"version":"0cb45071af866142b4198636d458bd6d2f564b7d79896907a75b01d66c135625","impliedFormat":1},{"version":"e151f7178771544d572824da291a8e2c45325c0cc2dbfe513de06c9d3cf771fc","impliedFormat":1},{"version":"16d707a765a9a3114e9911c1a57634fb3c90d678539c2d6d793c30cc87e759f3","impliedFormat":1},{"version":"4ce2e4991a21c8e6a98905d0dc3a9efaf75e8e8812a2b930f77ed8aa4435784d","impliedFormat":1},{"version":"4b86cb06a21c36b5ff47731a046e0109cb41d540e17215b8f95829e30da1bb94","impliedFormat":1},{"version":"7cc83c9b21c59ab3b08196adbeb13d999e16c56a5bbf89864d6e01cc1a6e6204","impliedFormat":1},{"version":"102334bccff335c3ef1c556fabac2c2f12bf93ce1a5cd8ce826ed188707496ed","impliedFormat":1},{"version":"c9144f4f50f868501918f526697deb558eb9d82bcad179b3807609246ba6b32b","impliedFormat":1},{"version":"8bb219fc6b96eb8fee00d73aa6e570b01885a01be42f2b85d93a1fa102f52ccd","impliedFormat":1},{"version":"fcc36716f4a5bb4ac1babbd30a3c55483def152357c0d17c570ecc406ef8f159","impliedFormat":1},{"version":"66c695ccbaa50b938c0e058b28b3a004fc8954e7e0f7f01177bae4bb8e92cc0f","impliedFormat":1},{"version":"6e01462f84beeb73382f987fae1bc554f0ed6d9f70056106f417a9f6088bdbc5","impliedFormat":1},{"version":"1b46f9a444f79e8aaa88e9c7ccff9f131ab101015b8933ea3a8fc7cc2021adc9","impliedFormat":1},{"version":"7749ee7c2eb72db8f09271082b925580321c546d8b2aef68960f3f4bf483d454","impliedFormat":1},{"version":"3d77e968a4a37fe3857daf2227ccaa7efb978830a6873de10d6a887daabda9cb","impliedFormat":1},{"version":"0ee14e6d06ffdcc74c5fc496224c15e6275bda1c413ffc86b0ad19d1452898a6","impliedFormat":1},{"version":"b10364cad5f3ba55bb99c69d21eb4a0df657c7a36027a2618f8739ed69142570","impliedFormat":1},{"version":"c7c4c05e6788ee40a4f1e374ab1355d3a8dcd1c947afadc8ac1dfdd0bb0ea41b","impliedFormat":1},{"version":"0a5e955193cb8aea98e00bf54042651f8c8b9b00c87337ff3c0ce8960345b5ba","impliedFormat":1},{"version":"5ad71db5434af4e0d796a387bb7f4b7c1837199b866723921e5bd67fb01c2f0f","impliedFormat":1},{"version":"212318bbf00acfc4451a1eec1f9f6f91918427d7dc71717f7dadcb84b6ad2190","impliedFormat":99},{"version":"b1a02c272b834972bef5cb8d9c79acb0352966ed5ae3a37482cec39da5e51276","impliedFormat":1},{"version":"25197fdcec1f0b168131c901881f9689b950c546a8d5d3620a9028765e9c91d8","impliedFormat":1},{"version":"c2a5d0ee3f7dd09d0741ba10eb9d07ccc714ee5f7fad3e550fe8ad99eedda1a5","impliedFormat":1},{"version":"81af227428e65ccfec74d0e439a810fcc2f33f3fa0e74730d486edf14ad2e367","impliedFormat":1},{"version":"2e6b2ac20f09b0351d256155e9b8d8854434ed9a01ba7e55a87a5d13e4365f63","impliedFormat":1},{"version":"3b0b108ad2bfedd6aba6c50b5b6aa969a75644935e40a749ecc2d28de9d9e788","impliedFormat":1},{"version":"221e3b82ae572a418be0a8e112681c64aae84166f2c25f4fd39297d0a6958b92","impliedFormat":1},{"version":"8a5fea1b0a68c64d9d830e878ea4e81efac6be802b4af1aa29cdfaad9be210f0","impliedFormat":1},{"version":"367fd06f031fee62713fa846885d31c8cfa8101b7e3ab129f1d89d9d5e719124","impliedFormat":1},{"version":"7163a9b5ad66c4e388aaeb18acf502e7c5afdbc52cb163bac5faf5d140abedfe","impliedFormat":1},{"version":"a9347756f992e52cd1ad3a5a7f35f3176e05795f44f4299f2809f5458699981a","impliedFormat":1},{"version":"853bece6815b265980b443f83d4ed245ffcccce293aa60dc1bce18aeaec827c8","impliedFormat":99},{"version":"dd6585c64a7e2247adc774fe92a3c5bebac28af2c1bc06bbdafeb58a2813d725","impliedFormat":1},{"version":"e0feff26b376e6eda473fea2273a6e96c5b380276a9ad9d3730cb607a0bcf1ce","impliedFormat":1},{"version":"4a286cb32756749c240e70cdb3e751b676fd0305f9d35928e3d3976e0d3c39b1","impliedFormat":1},{"version":"5b9716db2e3ca48d084e8baff9e2db5b2824ac7f7413e001dc33976e9f8e9636","impliedFormat":1},{"version":"a678ccb35281041ff3ed9179fdbbedac94d8642b3efdff5dfd8e1d803ad1f193","impliedFormat":99},{"version":"dc62e0d530ec9d6b960e09c39f3eb0e1f0384511facc30f07e441b0abef2c5c0","impliedFormat":1},{"version":"9da9c5a6b9c0020c1e8f2d087168d2ea5d43ad70fec8d8b31be7db2e2296ef55","impliedFormat":1},{"version":"690bc2bd40e8d87f033168d99e4cde82607b8e0a181163350e7de07ccc98f5b1","impliedFormat":1},{"version":"4619bbac2522271def9ec6d67b1b421a8fe4b85a90bc2f92ddd8f4b7a08f728e","impliedFormat":1},{"version":"9019d34b102c683cf2810e38477cd5e8964e46a15870abcd27c108c31d90970d","impliedFormat":1},{"version":"dd0b8ff0d6d5922e247969e6b3df41cae2d7294d000b056f9f93eda3e5bc31f9","impliedFormat":1},{"version":"b53e04ce667e2497d2e1e5826eb739840b6d83e73abeba7d267416990cf7c900","impliedFormat":99},{"version":"466d30b0f75773a2677ad69bc7d94facb224e061e0276c18b22a50d922e7a6be","impliedFormat":1},{"version":"858520cadc012c1c8ff47ddc61686f50f4ee52c9b87a7c10b8fb84b60ababc32","impliedFormat":1},{"version":"09e286c715f875d3772a8c196677934495eb7cc0b0222ddbf6756f4f3c57830d","impliedFormat":1},{"version":"f45c90fb3bc0f1bc18aabaeaf52747c633152994792d6c119ddd7d29e9d53414","impliedFormat":1},{"version":"29b553ef6920613307fa4edbd656a105bf159c7db2438fd84fe624a4ef6fc491","impliedFormat":1},{"version":"a69b64cc44b49bdadaa0de322b4b347b16fcb9c7fc08029a0372a082cb0f4467","impliedFormat":1},{"version":"7596bc71c0939bf0b534c1ead88b0c13c6ce7a8ffed9e47fd176036b3a464062","impliedFormat":1},{"version":"51cafc266445e20b92529192d8eb0ff3385ac1bc44fe125e84561563f338ec80","impliedFormat":1},{"version":"86a9434282d3ac8a6438ad0d6bec7f9e6463106edb2dc63c26a9dc63a6050d24","impliedFormat":1},{"version":"c16cffd6aa4a2c0701bd16332f4dfe6517a17f770f00218867d1fd4b13617fe2","impliedFormat":1},{"version":"ff1e570657ad6fb9247c2d7160d8c318796b88ab5db739336515fb04547a2d20","impliedFormat":1},{"version":"2ef29f5b7766615f2dc6b2fad24f5ce9e64204f6bdc035f3c9f90ade189196b5","impliedFormat":1},{"version":"ff4a940841cc11f423a911011edef12b47541e48c02cd5be4e8aa0addb0cf3f7","impliedFormat":1},{"version":"2ce39f6923be247a53eb5ea78ee1b5df3be8086253b8dd70be2584f5d8c2537a","impliedFormat":1},{"version":"bac47ef1b5d6cbf8c3e80f672e8f9ecf1cbab10da5fd25b7f228702306fceff8","impliedFormat":1},{"version":"3ef21503ad78f542c2efbd785f22a8c77e3798a2462be8a25a806937d4d85a3a","impliedFormat":1},{"version":"bd1ff4e0676496bf4f98f4f3ee31765bb49339aafa8b076952ec27cb041db0c7","impliedFormat":1},{"version":"5b89a6e06ccb15548326fac4c3ccb65892d8b10cf52fccb2867d0eb9a0b27bfd","impliedFormat":1},{"version":"2aba54f9c5acaf97b2f54e15dd52b88a26069c04e40118c5c1b4e1c7d0b13704","impliedFormat":1},{"version":"22b47c263603277f4caae17f9b5aa564f600a9b770f05920e68bee09394e2178","impliedFormat":1},{"version":"bdb92c931b192ef315b53cd48aa02e4398c251a8ea8800492cf0f43cb038ba28","impliedFormat":1},{"version":"eb37622408d5a60a38a9141acc5ce584f031df61fa67eeba98d495704fa14ddd","impliedFormat":1},{"version":"d787f15bf7abaa3a0d38c657e4281b13f86cc38b8845094a6977d583a9347ea2","impliedFormat":1},{"version":"8cb8894f63c1636f90fb7730fe50e421cdf56c779d0ba298010f0be89022cd39","impliedFormat":1},{"version":"749fb78249cdfc1fbb9ef8cef948a13f85f9942ca5489f1468736922500d78e1","impliedFormat":1},{"version":"30fd5d3577a7e58f873b83049dfbd2f173c350851c17b1e9a4b0878020626b97","impliedFormat":1},{"version":"66231c5bc015e15786504a220d622ddc6aac651b2a49f9cbf3fb945e27e733cd","impliedFormat":1},{"version":"819175b71a0809ed8bd0e76470a5e1deac5e02897862d4b633c17238ffc22b97","impliedFormat":1},{"version":"5426089e9fcec830597afd777d68bfe372de694dea4a8e7e68e3ca28acc8a6db","impliedFormat":1},{"version":"8e302e6fa5c43ca2384fe54b39fbdf0c320224a6919d71da5efc423366551314","impliedFormat":1},{"version":"fdc1bebcfdb5da0d3db8b11a94e68e0f40aff9f126ba06512c74e83cbab03a03","impliedFormat":1},{"version":"9139c1f3d72a1419734da74c4cbed997d073dafdb8fba63f9088a6fce6f23c99","impliedFormat":1},{"version":"79314b827217deb6d8518be67e201505f4da047bfd8fee11457f997403e0e7e9","impliedFormat":1},{"version":"5e788a039b7435497ef94c30ceff9f92ae097522e53ee75652407f1fba79579d","impliedFormat":1},{"version":"8782f99016b5b587eeb2e57c913a0a9470200941afda788224ce960fae47eeb4","impliedFormat":1},{"version":"c471dc722410fa62a4ff2c7f033cc15814087f5b445b5e9fbda596cd4c228a2e","impliedFormat":1},{"version":"0548857ee66b6fad6f26fdfaa76ee25334fa62454997c3a954726c166deb6a5a","impliedFormat":1},{"version":"a1ffd087cb5a5f76ff56226148d0acf8d223a9474eaf9d97dbd45fa6a19c1e58","impliedFormat":1},{"version":"cc5f3ec646bf93a7f13e27a9bb72f42b2a094a551a015296361cfe7f0d4350d2","impliedFormat":1},{"version":"f9e8a5ef3b0cbc104b6e66b936e5e76119630186ede7d3bef2cf53df506ca5a6","impliedFormat":1},{"version":"3644cfe268c1fe7de7b18619b385f8fdae10531ebd0ea4193ca6ab8bc8175e72","impliedFormat":1},{"version":"a05cfa018e37d5f3a5f39773145e5e77d18f32819ba3e115cd49b468f3ac139e","impliedFormat":1},{"version":"e2ecb11f739a7f3556659fee61d144d3ca1d715436ceb727f5701cd12461a65b","impliedFormat":1},{"version":"6ec1463df8c2070371669bdaee719272607903467a19f9883348166b50af8d54","impliedFormat":1},{"version":"cc08bd4e50ec465e694826816b4797e6f6a4a5211e98bb76bb05342439c7ce38","impliedFormat":1},{"version":"96cfa668e8ad2f88bf255184086129046467ff400f678de888c2cddf82b999ec","impliedFormat":1},{"version":"8d27a16268750bef7f8f2816fdcb28a9500fb9e6ba5a1e5981a053d35b416c3d","impliedFormat":1},{"version":"d90ff671df07b5dc26709a9ff6688a96fbf467e6835bee3ad8e96af26871d42c","impliedFormat":1},{"version":"7a0555e1186c549e113b9603b37994dbdb9b0aea18c1ebaccbade9fba289d260","impliedFormat":1},{"version":"ad1eab49ed8d2c7027c7d5b8333217688ef1bf628c6b68ca7674329c262433c5","impliedFormat":1},{"version":"c8d412a9b07756667bf4779a960226b71418a858cb6801188992f4e9ed023839","impliedFormat":1},{"version":"7801e1a8f4396ec3a8eb0fae480baf1fe9ea036a5d68868337a7bcc50bf769e4","impliedFormat":1},{"version":"9dfbe649c60c743bf0cbf473639551cf743a1acdead36e3d66a8e3feee648879","impliedFormat":1},{"version":"c214b33fb74b0ea35c672b1923e51ab30a1e3e8f876a09e94148a35f3cd2f5db","impliedFormat":1},{"version":"e3846aa20e866fce307a39d7efc4e90eef08ea0884b956738458fe724684e591","impliedFormat":1},{"version":"c19feddfc23f04fd9cda6b24568894eb79852a26b3f9733cc0472b91bfc1c0a1","impliedFormat":1},{"version":"9ac8b88f902bd4c2212ae16b11d26421e50669f0a0643586083281176f9d9132","impliedFormat":1},{"version":"5180e5bae39bbb8baf8aeba9100814e4f4d017d41638a4e609ca5c3ce83993ea","impliedFormat":1},{"version":"b69e0431f9b7f6e6c5f0754e8a3dad3f263684ed4c7406d4be7649eeb7d9af27","impliedFormat":1},{"version":"a10e2f2466f0ed484ef74a385bfb5e63f2b202d51dbf1bb4c51c294a70ba92ca","impliedFormat":1},{"version":"5347737b57f1c1cce11c140228c4e4068eca4c2435b1e4beb4d46e60c5d5e55e","impliedFormat":1},{"version":"631b3d9fcc0fd5e08affcdb01b76f5d34e1f1c607031d03a6d621cf2aa63b2e8","impliedFormat":1},{"version":"ef7ee4e86977bf10f68dc2e1a3378bbebb4e97dc476bac72ca9315cc7e89e3e2","impliedFormat":1},{"version":"3a21d83e527b6d812d75c719134026ffc18efe0f01c76e6441b29d77add09e26","impliedFormat":1},{"version":"91406250d53804ad5f3a42af40a5e17f1ea3e54c493076f6f931e77efa6db566","impliedFormat":1},{"version":"1fb51788ac6acb1e6cba5cf7e99b03d07ca8b4120550defd561b331dfa8e816d","impliedFormat":1},{"version":"3cc15f1ebcd824e7752f390dab07e92b15e02514f2c9ceb1737ee42d4e3164e3","impliedFormat":1},{"version":"830c34482ca4bce8c4fa2f14cff1197fce2017471752441e95b25112827ceef3","impliedFormat":1},{"version":"f00b89d69f241f3e74269c2de5d3cd564fea760fd4d2a403820ed5b077819724","impliedFormat":1},{"version":"d2e41732e6551589732bb50507b48762982fbe68fcb739f7a4fdacf7a2eb6bb1","impliedFormat":1},{"version":"b62750f035b864e25b966d2a5bd32a716d8a0f5e9befaa3638603ec8df578b37","impliedFormat":1},{"version":"8933e7bf77f729d2ae382fe434a1038fa304caf15c71a4c16c90c19e9ca7626f","impliedFormat":1},{"version":"20463dff6b7f9ab3573ceb503f0674d34c3571328bec2152db193e732a29bb7a","impliedFormat":1},{"version":"528e1e94b95de11acf4545f8b930b460e18ef044579a24a8b1b2d40c068fa89e","impliedFormat":1},{"version":"fc8a3cf4a55f7d1ae3f2efdda84bbeaeea605a92e535ac52b99deed6366917d5","impliedFormat":99},{"version":"4d0d2708fe857d7a1a936da40fb357b2f67f22b0e0c4994211ee6a6ccbd48a33","impliedFormat":1},{"version":"21a572262a50e7b603382800b727abae5b7d52ccd71ae163f8dc4cac379f7274","impliedFormat":1},{"version":"e674342d40884888334a6cf55ac4276abd77f36f51687f56a47d5910fd9ea033","impliedFormat":1},{"version":"ac04b4535689f4fd637d97c9811d5fafe4d2209d497c0eae539c3e99d81978fc","impliedFormat":1},{"version":"c3a31b99b4de2d53784cf340ee9b36907f2b859dcb34dd75c08425248e9e3525","impliedFormat":1},{"version":"f03893fc4406737e85fd952654fd0a81c6a787b4537427b80570fea3a6e4e8b6","impliedFormat":1},{"version":"518ee71252a0acf9fce679a78f13630ab81d24a9b4ee0b780e418a4859cc5e9f","impliedFormat":1},{"version":"3946840c77ebba396a071303e6e4993eaa15f341af507a04b8b305558410f41e","impliedFormat":1},{"version":"2fba8367edfbc4db7237afc46fd04f11a5cc68a5ff60a374f8f478fcc65aa940","impliedFormat":1},{"version":"8d6e54930ac061493fa08de0f2fd7af5a1292de5e468400c4df116fd104585a2","impliedFormat":1},{"version":"38c6778d12f0d327d11057ef49c9b66e80afb98e540274c9d10e5c126345c91d","impliedFormat":1},{"version":"2ac9c98f2e92d80b404e6c1a4a3d6b73e9dc7a265c76921c00bbcc74d6aa6a19","impliedFormat":1},{"version":"8464225b861e79722bf523bb5f9f650b5c4d92a0b0ede063cc0f3cf7a8ddd14a","impliedFormat":1},{"version":"266fb71b46300d4651ff34b6f088ac26730097d9b30d346b632128a2c481a380","impliedFormat":1},{"version":"e747335bc7db47d79474deaa7a7285bf1688359763351705379d49efcddc6d75","impliedFormat":1},{"version":"20f99f0f0fdf0c71d336110b7f28f11f86e632cf4cf0145a76b37926ffaa5e67","impliedFormat":1},{"version":"148e0a838139933abaeee7afc116198e20b5a3091c5e63f9d6460744f9ad61a0","impliedFormat":1},{"version":"72c0d33dd598971c1caa9638e46d561489e9db6f0c215ced7431d1d2630e26d3","impliedFormat":1},{"version":"611f0ccef4b1eebe00271c7e303d79309d94141b6d937c9c27b627a6c5b9837f","impliedFormat":1},{"version":"e2d98375b375d8baa7402848dca7c6cd764da6abf65ecfaa05450a81a488157f","impliedFormat":1},{"version":"b6254476d1ab4ce8525ae5f0f7e31a74d43f79eecd1503c4de3c861ee3040927","impliedFormat":1},{"version":"65f702c9b0643dc0d37be10d70da8f8bbd6a50c65c83f989f48674afb3703d06","impliedFormat":1},{"version":"5734aa7e99741993aa742bf779c109ced2d70952401efe91a56f87ed7c212d1b","impliedFormat":1},{"version":"96f46fdc3e6b3f94cd2e68eca6fd069453f96c3dea92a23e9fcf4e4e5ba6ecdb","impliedFormat":1},{"version":"bde86caf9810f742affde41641c953a5448855f03635bf3677edf863107d2beb","impliedFormat":1},{"version":"6df9dfe35560157af609b111a548dc48381c249043f68bcdf9cf7709851ac693","impliedFormat":1},{"version":"9ba8d6c8359e51801a4722ce0cbf24f259115114a339524bb1fdb533e9d179da","impliedFormat":1},{"version":"8b1f2a75b36d4a5b52771e1bfd94706b1ec9cd03b0825d4b3c7bcf45e5759eab","impliedFormat":1},{"version":"97d50788c0ec99494913915997ab16e03fb25db0d11f7d1d7395275fa0255b66","impliedFormat":1},{"version":"aea313472885609bd9f7cd0efdc6bc17112f8734699b743e7fbd873d272ca147","impliedFormat":1},{"version":"116f362c8b60668e7a99f19a46108ceac87b970e98678a83ae5b2a18382db181","impliedFormat":1},{"version":"b4fbfaa34aacd768965b0135a0c4e7dbaa055a8a4d6ffe7bedf1786d3dc614de","impliedFormat":1},{"version":"87b9b8fd9faf5298d4054bfa6bf6a159571afa41dfdbd3a23ea2a3d0fab723bd","impliedFormat":1},{"version":"cde5f66590c3a1af8b32b89444c7e975de93a3f4b7fc878087abf4187c7949fc","impliedFormat":1},{"version":"31ad2c3e09a73713d4c52f325e0fa0cf920ea3ea6bccb1fc4b271d9313183883","impliedFormat":1},{"version":"5906db268438b1a7a124f8690a92031288a8e42e6aea0f525158031b324427d7","impliedFormat":1},"9d0212c2cc9a1861a04945317484a3840186a591c580ba7d865195e09f676fed",{"version":"ac309244296f378db62f70d2dbeaf859340db6380ceac650e3e21713760abb8c","impliedFormat":99},{"version":"82738d9afed59be7ee7b5f1602747adfb22136ff31af4d4a2cc8651ef77eaf19","impliedFormat":1},{"version":"aae374b21c7c3fe8a312b0ea6cfa3bd1376401fe6fa0de4da7506c2ed594aef4","impliedFormat":1},{"version":"2813548f7105435705b6a5c6c8459dadde0476ab2ebae6b2644cf2259960dc6d","impliedFormat":99},{"version":"e0f4c3a6747fac775e2d740f92e60a6da762e4f34d0a2057e22784fb5204181a","impliedFormat":1},{"version":"da107b61f72658beedd678c0c8fd0cedb3a02f679bbcea9d7bdea8e814dcadce","impliedFormat":99},{"version":"75ec6a6e61de058d8d450b229d54504ef1a47328b7e61d9cdc49e283559f3687","impliedFormat":1},{"version":"a469460e21a0286fb87a7df9539ff99e6c831ee11e1f929ce6ad68b8aaca7e3d","impliedFormat":1},{"version":"1b8e0cff7e05b290d2581f93d0b9f9b1d17971034825617b55ad3f398a2870f4","impliedFormat":1},{"version":"d23b8c70c6565fef9286c65bd6ff34ae3ad7084e0ec5e177f125a42d2a7c1886","impliedFormat":1},{"version":"4759dfcd0778dd0b9449affcc374781a863536a25dcfaa7c71d74317f8448b1a","impliedFormat":1},{"version":"aab65cc378cd64bd82cf63fbe1f6d5804c1594a4fc328468b405093d0c6aa727","impliedFormat":1},{"version":"681abfae63f06f15e42cd6f4c6f8a185da32c002e53af81652c59caa84370172","impliedFormat":1},{"version":"14021cbd3905a3e48bb4f45f51e813d6c3acefc6a3b3613658252ed402a62104","impliedFormat":1},{"version":"546dccc430d25c23cd0e7d1e2121c4a5321a77ae743846c57add1b2b20df2fc1","impliedFormat":99},"6b5264d129bb6e3f65b5553b7005d5b1811d3204f4a6dab7218d79850a7ff71f","00baf8d71fc2e708420ac2ab77ccf2f8d499bd4da2bab54725f0acfaae2da9fe","2aa379d2d3e650bca8757a980cb7877e9847239f7e0f9287727450b66f38f5f8","b99fbb7e9c3c63652f31683b2a3213332b0fb147fff430995069a389170e6beb","06e8240f7c91eee0683c46e9aa652c30b7afeaec10a3cd7bb3b8c1d70b839676","a4476955c8deb7fce80a6494b08a332460863fcc4dd3b7d02005c74fe0919af5","1996b32940bc356f4e46aad705f46a7bc930809e6e319ecf7100097622796fb8","df62fa4978b479fe2a1bd9b70e6a7ca53682ede9c1e986dfd279dbb574c2ec17","be909b597f540f13f699368601ef1f80d2c6a0eb13b7c25d77c16a81b7bccbaf","3108d959beb0384494ff15005f80c73c9091e9c2eef7e7d2d404da02689c869d","9ad916059bc206162efec6963e770c5e21a9963ca80ddcb68686c79bef407789","0a23ad11c6d4f2127dafdbafbd5ba52e826993645db43b9e929bdad60062c6a5","62f0a53d41e919f83951036dd16274f9d57a24f6c0248f8503c473f4ecbe1b83","cb4d24ddb0a4d39a942367741be416ba592616238c2b11cb6afdfe8697fee763","619f25d306951d24563a0af1e64e9f4d7ee12fc22986c692f57cc813a032a421","8721e8f87b1838e37c65a70ea25792f9433be3537e02a118aff6fcbb07d705a9","aa3686489dd5bee2c7c2c0670f146548dbaf0ac8584445183e626519c61df4b4","2a5626899c9ef081497ad60e3816de98eced594fbb5c1bde2d841f73576790d7","fad8e3f975a05b5ff655b6afe0663a379e7ae1f996a7f1d3dcef786f029cd380","6d57cba2d54bc283b1997cdb28fcae2e6db823c019fb1654b071b18841925242","e4342d2d10d61aa1910c7c31bb1f41e994c647f917797f7967bcdd7aded4aa8b","e96c884d377b37bf05828920bf61ccb4fcbfcb304e5f10c71d50f8c89dbb0050","6982e1258ca4ce7e1377e434cd26a8d0da24f1eb3a77bc98db1ccc4cf2834956","6950b36869822d70ccd3edbbf6edab74f71e08580e9da93952d5b0315fc2f427","d2b0473ba1daf7fcec89bf501f69cd51b1ab586e3cf1655c9577a3f249227afd","9f8096010dab34a0ad50919b7332ba8655d37deb3eb909ef701a8b68f5f0ba1b","a0dd80d4c2d18c084615f38faa30fed67d7324a790db5bbd2793939e81b8c65c","51a37b5053b38b181df53419e4e82249997c5f0a2e375d881c67fcc109dfc2ea","6fb90e0ea8bf3ca665f201c85c5205eb054e1535dc3822cce3831c1ede6bd0f7","cbeca205171b66b37b05bbb0cd49c23e6164323a5c4b8bb306d6edd7d8661d20","20dad0ab55de1778c0c8165c5a2c2694f54c8808d5f96d629623557b385b3368","6a996e09fb64a1cb344d222df0d082ea4511f9e5d0dce7bc670fd8871bfd6d51","00f318e52a267fbd2d313988155c38799c7ef09cd9c159f79c7627fbcac7fef9","4543a6d3775864807f18676f73591dcfcb798062b8651b329f85cf8826b1f0e4","ec77af20618b71127c6a70b25672273e47dd1ba26e6dc86514e24a741c2b8e80","dc23950fa8350317997f3fcb6d6caf978be6d7efb3d71193b13d09c7e087236e","a24861793569f99770cb85ac262bde7d07e095803ddd5393980f847ee371864a","da6e695ccee5bcfaddd295cfd99ff99e78ca353719a9a900dc76a3d87e8e3337","9f06910f20a06c30d4488c2d161ca1afa4eb64776f12fb464126ff879b100228","19bd918518b8f6c7440dc4cd1ec2698b2432bd2a690f811c1f1db81da640bf1c","20d6480ecc09d57d74996a12ed0787cbf78c665fb40b32e7581561a6e6d631e7","d4890cba7f810fd878e2439a52545ce618ee38f263a35f50d9fbf9793585db4c","35856f17225ca7f900231f2872e3cc5826c2ddade4f553cc72c4364463365c6e","05072be76233d02857b54b5a8160a4255b9d43ef7e00bc52e654c1ede07af8f3","26ddea48c1d7ea3f1056f7f2b757feeb9db7bf5c39876df7dd1fc10ed18f0f30","b9b06fda6577108f9474748520fbd1ce333c8b56c5ba76052686aec4890695f2","2552b3922a39273e20356f962d90a87c7af143b9750a934b2bd2c60d3b8edb40","ac892c3bcd6f2110b536aa92e388eca8b232f98a6ccd8b55ed434f0968a672ef","1227522d73480ed7f1d7cfca60305715aca21918bcd4acf36e7c3b4c93e077ba","53726e6d62fc1f7ca1ab4f1d46c45c0f622c607cac2e2be2e0c65b3684434d65","48bc9febfd0b20cd4fde3a4a09247dfd575f9518604a19b2d771d7f5a0c0cd3b","2e7d3f9645e11cb09fc1ad06c1b9204fdb0a994f5b5069965cc3a526fe6dbcb5","c01465d4591d20fb7df15c141344943909c580cfbe5ac8185d941093382f6ea1",{"version":"090cde3dad7dd7c319957176fd61360b1fee094ec00f0f05643ca9a8c936f44b","signature":"9734bbf4d6aa65a4c80a7cdcd3e286683ca1b5a7f5ddd00045d4a07c529bffee"},"7c0bf882d6ee38f1dd4101968b974e5fc4988c4f054fa591f88af17551725817","610cfdb2fdb1254cc7cc8a402c0552c95219eab61715624564e735a040017101","eaa81dc97b34c5a525761a156c63e330c45b413d1877ed8fc6114e0c454dc67a","41ed8ba5ea11f5abdb3d4c08ac1ce6779807b2e91cfd790dd7b72977411017d7","0ec1bfed07a6d24818f831b74f17831514a069a34fdb477492154ce78c0a7db6","087531ff23756247371028767094105223e8f01a3142ae266e751b83c65beb60","60c33be4d1b6260fd0ae951f238fa669aa2f496174d241ac9ecede8e19d88648","b7e1a789632119015f97dd582336dacbc8da3c002fa720cbc5a56b2262a10088","5ee61de8125ecdaafa2ac402eb267b973659265cefbffbee2bba51946379263f","1e515aa2c8f22365dc95d9c43d460a5e736d405255520565ebfe9e2f93513d87","e96c0d8b6d463bcaf75d6867ea81087522291285d77cdcfd22f45f649e468211","f227a5804e49c01c5799817d79e4bda78dc6df1505a59fe475e6f3c1a3adc703","99ad0de867b13c566c6057d5b718f3189668caa843725156a6d882c36efb4f45","2317d75e2a0a5c034279ef0f977d00037d253645a21de50e74f286d36a9cf10b","b024076d7f6548631cecbb00322d143b03d16303e379911a13732f849959fa07","0c2d54efbb0378781eda5ea905ed24e831437f40b2b05f060aa14e8bccb9555d","1ca87070089afd8bea3fc2f475444d8f61b79ea6c226f522f262935d051c3ce1","bbe51a0918f60a2c3cf48e07279b0dc8164dc5e7dc169aaa36c92f77aaa3d594","0900eadd947c39726925ad51707f1ef739971afff30dc6ef3547c514ff40484f","d973b07acb5359197d4ca81141c9ced85e2d162d9f86063e4dac992d4af0fd62","49285b21e7b59fbb1d0d6ff2779ad9413c450da6fc23ca2ec661fdcce8a6ad4a","d1986184a09a52db8228cb2bb2a61a8c05c9354e5b93cec8e2628d8579c892d7",{"version":"f31c4f2e95ea48a5359b8b12d88e7f9df3e84c55297384c7ba6321fee2bca54c","affectsGlobalScope":true},"4638acacbde71b13a7dfc70bb2262b56fc4594e40232f87f3a6faedb760b109a","d1986184a09a52db8228cb2bb2a61a8c05c9354e5b93cec8e2628d8579c892d7","26a6caeefda9c5179718f70e14e8f6e1f550e86c3d18537cf637b07275b8d21c",{"version":"0e298df8752b8bdcafdf4c8e8560df048c3c5688fa683f14a827490e0fe0cf0f","impliedFormat":1},{"version":"035a5df183489c2e22f3cf59fc1ed2b043d27f357eecc0eb8d8e840059d44245","impliedFormat":1},{"version":"a4809f4d92317535e6b22b01019437030077a76fec1d93b9881c9ed4738fcc54","impliedFormat":1},{"version":"5f53fa0bd22096d2a78533f94e02c899143b8f0f9891a46965294ee8b91a9434","impliedFormat":1},{"version":"d934a06d62d87a7e2d75a3586b5f9fb2d94d5fe4725ff07252d5f4651485100f","impliedFormat":1},{"version":"0d14fa22c41fdc7277e6f71473b20ebc07f40f00e38875142335d5b63cdfc9d2","impliedFormat":1},{"version":"b104e2da53231a529373174880dc0abfbc80184bb473b6bf2a9a0746bebb663d","impliedFormat":99},{"version":"3d4bb4d84af5f0b348f01c85537da1c7afabc174e48806c8b20901377c57b8e4","impliedFormat":99},{"version":"a2500b15294325d9784a342145d16ef13d9efb1c3c6cb4d89934b2c0d521b4ab","impliedFormat":99},{"version":"79d5c409e84764fabdd276976a31928576dcf9aea37be3b5a81f74943f01f3ff","impliedFormat":99},{"version":"8ea020ea63ecc981b9318fc532323e31270c911a7ade4ba74ab902fcf8281c45","impliedFormat":99},{"version":"c81e1a9b03e4de1225b33ac84aaf50a876837057828e0806d025daf919bf2d51","impliedFormat":99},{"version":"bb7264d8bd6152524f2ef5dae5c260ae60d459bf406202258bd0ce57c79e5a6d","impliedFormat":99},{"version":"fb66165c4976bc21a4fde14101e36c43d46f907489b7b6a5f2a2679108335d4a","impliedFormat":99},{"version":"628c2e0a0b61be3e44f296083e6af9b5a9b6881037dd43e7685ee473930a4404","impliedFormat":99},{"version":"4776f1e810184f538d55c5da92da77f491999054a1a1ee69a2d995ab2e8d1bc0","impliedFormat":99},{"version":"11544c4e626eab113df9432e97a371693c98c17ae4291d2ad425af5ef00e580b","impliedFormat":99},{"version":"e1847b81166d25f29213d37115253c5b82ec9ee78f19037592aa173e017636d5","impliedFormat":99},{"version":"fe0bd60f36509711c4a69c0e00c0111f5ecdc685e6c1a2ae99bd4d56c76c07fc","impliedFormat":99},{"version":"b8f3f4ee9aae88a9cec9797d166209eb2a7e4beb8a15e0fc3c8b90c9682c337d","impliedFormat":99},{"version":"ea3c4f5121fe2e86101c155ebe60b435c729027ae50025b2a4e1d12a476002ae","impliedFormat":99},{"version":"372db10bea0dbe1f8588f82b339152b11847e6a4535d57310292660c8a9acfc5","impliedFormat":99},{"version":"6f9fba6349c16eed21d139d5562295e8d5aafa5abe6e8ebcde43615a80c69ac1","impliedFormat":99},{"version":"1474533e27d0e3e45a417ea153d4612f0adbff055f244a29606a1fae6db56cda","impliedFormat":99},{"version":"c7fd8a79d0495955d55bfea34bbdb85235b0f27b417a81afc395655ef43d091d","impliedFormat":99},{"version":"987405949bfafbb1c93d976c3352fe33bfb85303a79fc5d9588b681e4af6c3b3","impliedFormat":99},{"version":"867bc1f5a168fd86d12d828dfafd77c557f13b4326588615b19e301f6856f70c","impliedFormat":99},{"version":"6beddab08d635b4c16409a748dcd8de38a8e444a501b8e79d89f458ae88579d1","impliedFormat":99},{"version":"1dea5c7bf28569228ffcc83e69e1c759e7f0133c232708e09cfa4d7ed3ec7079","impliedFormat":99},{"version":"6114545678bb75e581982c990597ca3ba7eeef185256a14c906edfc949db2cd1","impliedFormat":99},{"version":"5c8625f8dbbd94ab6ca171d621049c810cce4fce6ec1fd1c24c331d9858dce17","impliedFormat":99},{"version":"af36e5f207299ba2013f981dffacd4a04cdce2dd4bd255fff084e7257bf8b947","impliedFormat":99},{"version":"c69c720b733cdaa3b4542f4c1206d9f0fcf3696f87a6e88adb15db6882fbcd69","impliedFormat":99},{"version":"9c37e66916cbbe7d96301934b665ec712679c3cb99081ccaae4034b987533a59","impliedFormat":99},{"version":"2e1a163ab5b5c2640d7f5a100446bbcaeda953a06439c901b2ae307f7088dc30","impliedFormat":99},{"version":"f0b3406d2bc2c262f218c42a125832e026997278a890ef3549fa49e62177ce86","impliedFormat":99},{"version":"756cf223ca25eb36c413b2a286fa108f19a5ac39dc6d65f2c590dc118f6150df","impliedFormat":99},{"version":"70ce03da8740ca786a1a78b8a61394ecf812dd1acf2564d0ce6be5caf29e58d9","impliedFormat":99},{"version":"e0f5707d91bb950edb6338e83dd31b6902b6620018f6aa5fd0f504c2b0ea61f5","impliedFormat":99},{"version":"0dc7ae20eab8097b0c7a48b5833f6329e976f88af26055cdae6337141ff2c12e","impliedFormat":99},{"version":"76b6db79c0f5b326ff98b15829505efd25d36ce436b47fe59781ac9aec0d7f1b","impliedFormat":99},{"version":"786f3f186af874ea3e34c2aeef56a0beab90926350f3375781c0a3aa844cd76e","impliedFormat":99},{"version":"63dbc8fa1dcbfb8af6c48f004a1d31988f42af171596c5cca57e4c9d5000d291","impliedFormat":99},{"version":"aa235b26568b02c10d74007f577e0fa21a266745029f912e4fba2c38705b3abe","impliedFormat":99},{"version":"3d6d570b5f36cf08d9ad8d93db7ddc90fa7ccc0c177de2e9948bb23cde805d32","impliedFormat":99},{"version":"9a60faaa0d582db70f85a94a3439bd83720a9468928b76b4db561a1a0137fa90","impliedFormat":99},{"version":"627e2ac450dcd71bdd8c1614b5d3a02b214ad92a1621ebeb2642dffb9be93715","impliedFormat":99},{"version":"813514ef625cb8fc3befeec97afddfb3b80b80ced859959339d99f3ad538d8fe","impliedFormat":99},{"version":"624f8a7a76f26b9b0af9524e6b7fa50f492655ab7489c3f5f0ddd2de5461b0c3","impliedFormat":99},{"version":"d6b6fa535b18062680e96b2f9336e301312a2f7bdaeb47c4a5b3114c3de0c08b","impliedFormat":99},{"version":"818e8f95d3851073e92bcad7815367dd8337863aaf50d79e703ac479cca0b6a4","impliedFormat":99},{"version":"29b716ff24d0db64060c9a90287f9de2863adf0ef1efef71dbaba33ebc20b390","impliedFormat":99},{"version":"2530c36527a988debd39fed6504d8c51a3e0f356aaf2d270edd492f4223bdeff","impliedFormat":99},{"version":"2553cfd0ec0164f3ea228c5badd1ba78607d034fc2dec96c781026a28095204b","impliedFormat":99},{"version":"6e943693dbc91aa2c6c520e7814316469c8482d5d93df51178d8ded531bb29ee","impliedFormat":99},{"version":"e74e1249b69d9f49a6d9bfa5305f2a9f501e18de6ab0829ab342abf6d55d958b","impliedFormat":99},{"version":"16f60d6924a9e0b4b9961e42b5e586b28ffd57cdfa236ae4408f7bed9855a816","impliedFormat":99},{"version":"493c2d42f1b6cfe3b13358ff3085b90fa9a65d4858ea4d02d43772c0795006ec","impliedFormat":99},{"version":"3702c7cbcd937d7b96e5376fe562fd77b4598fe93c7595ee696ebbfefddac70f","impliedFormat":99},{"version":"848621f6b65b3963f86c51c8b533aea13eadb045da52515e6e1407dea19b8457","impliedFormat":99},{"version":"c15b679c261ce17551e17a40a42934aeba007580357f1a286c79e8e091ee3a76","impliedFormat":99},{"version":"156108cedad653a6277b1cb292b18017195881f5fe837fb7f9678642da8fa8f2","impliedFormat":99},{"version":"0a0bb42c33e9faf63e0b49a429e60533ab392f4f02528732ecbd62cfc2d54c10","impliedFormat":99},{"version":"70fa95cd7cb511e55c9262246de1f35f3966c50e8795a147a93c538db824cdc8","impliedFormat":99},{"version":"bc28d8cec56b5f91c8a2ec131444744b13f63c53ce670cb31d4dffdfc246ba34","impliedFormat":99},{"version":"7bd87c0667376e7d6325ada642ec29bf28e940cb146d21d270cac46b127e5313","impliedFormat":99},{"version":"0318969deede7190dd3567433a24133f709874c5414713aac8b706a5cb0fe347","impliedFormat":99},{"version":"3770586d5263348c664379f748428e6f17e275638f8620a60490548d1fada8b4","impliedFormat":99},{"version":"ff65e6f720ba4bf3da5815ca1c2e0df2ece2911579f307c72f320d692410e03d","impliedFormat":99},{"version":"edb4f17f49580ebcec71e1b7217ad1139a52c575e83f4f126db58438a549b6df","impliedFormat":99},{"version":"353c0cbb6e39e73e12c605f010fddc912c8212158ee0c49a6b2e16ede22cdaab","impliedFormat":99},{"version":"e125fdbea060b339306c30c33597b3c677e00c9e78cd4bf9a15b3fb9474ebb5d","impliedFormat":99},{"version":"ee141f547382d979d56c3b059fc12b01a88b7700d96f085e74268bc79f48c40a","impliedFormat":99},{"version":"1d64132735556e2a1823044b321c929ad4ede45b81f3e04e0e23cf76f4cbf638","impliedFormat":99},{"version":"8b4a3550a3cac035fe928701bc046f5fac76cca32c7851376424b37312f4b4ca","impliedFormat":99},{"version":"5fd7f9b36f48d6308feba95d98817496274be1939a9faa5cd9ed0f8adf3adf3a","impliedFormat":99},{"version":"15a8f79b1557978d752c0be488ee5a70daa389638d79570507a3d4cfc620d49d","impliedFormat":99},{"version":"d4c14ea7d76619ef4244e2c220c2caeec78d10f28e1490eeac89df7d2556b79f","impliedFormat":99},{"version":"8096207a00346207d9baf7bc8f436ef45a20818bf306236a4061d6ccc45b0372","impliedFormat":99},{"version":"040f2531989793c4846be366c100455789834ba420dfd6f36464fe73b68e35b6","impliedFormat":99},{"version":"c5c7020a1d11b7129eb8ddffb7087f59c83161a3792b3560dcd43e7528780ab0","impliedFormat":99},{"version":"d1f97ea020060753089059e9b6de1ab05be4cb73649b595c475e2ec197cbce0f","impliedFormat":99},{"version":"b5ddca6fd676daf45113412aa2b8242b8ee2588e99d68c231ab7cd3d88b392fa","impliedFormat":99},{"version":"77404ec69978995e3278f4a2d42940acbf221da672ae9aba95ffa485d0611859","impliedFormat":99},{"version":"4e6672fb142798b69bcb8d6cd5cc2ec9628dbea9744840ee3599b3dcd7b74b09","impliedFormat":99},{"version":"609653f5b74ef61422271a28dea232207e7ab8ad1446de2d57922e3678160f01","impliedFormat":99},{"version":"9f96251a94fbff4038b464ee2d99614bca48e086e1731ae7a2b5b334826d3a86","impliedFormat":99},{"version":"cacbb7f3e679bdea680c6c609f4403574a5de8b66167b8867967083a40821e2a","impliedFormat":99},{"version":"ee4cf97e8bad27c9e13a17a9f9cbd86b32e9fbc969a5c3f479dafb219209848c","impliedFormat":99},{"version":"3a4e35b6e99ed398e77583ffc17f8774cb4253f8796c0e04ce07c26636fed4a9","impliedFormat":99},{"version":"08d323cb848564baef1ecbe29df14f7ad84e5b2eaf2e02ea8cb422f069dcb2fa","impliedFormat":99},{"version":"a05b53646fa669b87d8b97c1fb7c0183d771680fdd1276b12e68bed4e84cf556","impliedFormat":99},{"version":"c3b9c02a31b36dd3a4067f420316c550f93d463e46b2704391100428e145fd7f","impliedFormat":99},{"version":"b2a4d01fcf005530c3f8689ac0197e5fd6b75eb031e73ca39e5a27d41793a5d8","impliedFormat":99},{"version":"e99d9167596f997dd2da0de0751a9f0e2f4100f07bddf049378719191aee87f6","impliedFormat":99},{"version":"40cc853264e24e0578580194c76e25628acdd1111b54ec8abf59b834c4942839","impliedFormat":99},{"version":"403971c465292dedc8dff308f430c6b69ec5e19ea98d650dae40c70f2399dc14","impliedFormat":99},{"version":"fd3774aa27a30b17935ad360d34570820b26ec70fa5fcfd44c7e884247354d37","impliedFormat":99},{"version":"7b149b38e54fe0149fe500c5d5a049654ce17b1705f6a1f72dd50d84c6a678b9","impliedFormat":99},{"version":"3eb76327823b6288eb4ed4648ebf4e75cf47c6fbc466ed920706b801399f7dc3","impliedFormat":99},{"version":"c6a219d0d39552594a4cc75970768004f99684f28890fc36a42b853af04997b7","impliedFormat":99},{"version":"2110d74b178b022ca8c5ae8dcc46e759c34cf3b7e61cb2f8891fd8d24cb614ef","impliedFormat":99},{"version":"38f5e025404a3108f5bb41e52cead694a86d16ad0005e0ef7718a2a31e959d1e","impliedFormat":99},{"version":"8db133d270ebb1ba3fa8e2c4ab48df2cc79cb03a705d47ca9f959b0756113d3d","impliedFormat":99},{"version":"fc9294185089a62f8287130bc100fa5ab11f3e6af8874127bbdf7600f19913ee","impliedFormat":99},{"version":"f06e5783d10123b74b14e141426a80234b9d6e5ad94bfc4850ea912719f4987c","impliedFormat":99},{"version":"de9466be4b561ad0079ac95ca7445c99fdf45ef115a93af8e2e933194b3cdf4c","impliedFormat":99},{"version":"0c1eed961c15e1242389b0497628709f59d7afd50d5a1955daa10b5bd3b68fc2","impliedFormat":99},{"version":"5e07a9f7f130e5404c202bf7b0625a624c9d266b980576f5d62608ef21d96eab","impliedFormat":99},{"version":"2f97d5063ab69bf32d6417d71765fc154dc6ff7c16700db7c4af5341a965c277","impliedFormat":99},{"version":"a8a9459dd76ef5eeef768da4ce466c5539d73b26334131bd1dd6cbd74ce48fa2","impliedFormat":99},{"version":"123ff203ffba727213e5095b9a59091cdbc9d1d94bae0d6adb98060ef410016c","impliedFormat":99},{"version":"9e4d81dd52d5a8b6c159c0b2f2b5fbe2566f12fcc81f7ba7ebb46ca604657b45","impliedFormat":99},{"version":"9ee245e7c6aa2d81ee0d7f30ff6897334842c469b0e20da24b3cddc6f635cc06","impliedFormat":99},{"version":"e7d5132674ddcd01673b0517eebc44c17f478126284c3eabd0a552514cb992bb","impliedFormat":99},{"version":"a820710a917f66fa88a27564465a033c393e1322a61eb581d1f20e0680b498f1","impliedFormat":99},{"version":"19086752f80202e6a993e2e45c0e7fc7c7fc4315c4805f3464625f54d919fa2e","impliedFormat":99},{"version":"141aebe2ee4fecd417d44cf0dabf6b80592c43164e1fbd9bfaf03a4ec377c18e","impliedFormat":99},{"version":"72c35a5291e2e913387583717521a25d15f1e77d889191440dc855c7e821b451","impliedFormat":99},{"version":"ec1c67b32d477ceeebf18bdeb364646d6572e9dd63bb736f461d7ea8510aca4f","impliedFormat":99},{"version":"fb555843022b96141c2bfaf9adcc3e5e5c2d3f10e2bcbd1b2b666bd701cf9303","impliedFormat":99},{"version":"f851083fc20ecc00ff8aaf91ba9584e924385768940654518705423822de09e8","impliedFormat":99},{"version":"c8d53cdb22eedf9fc0c8e41a1d9a147d7ad8997ed1e306f1216ed4e8daedb6b3","impliedFormat":99},{"version":"6c052f137bab4ba9ed6fd76f88a8d00484df9d5cb921614bb4abe60f51970447","impliedFormat":99},{"version":"d888e70d2e4a05f47573548bf836cab96575aab3b1c264693100f279514ac8ca","impliedFormat":99},{"version":"7d5c2df0c3706f45b77970232aa3a38952561311ccc8fcb7591e1b7a469ad761","impliedFormat":99},{"version":"2c41502b030205006ea3849c83063c4327342fbf925d8ed93b18309428fdd832","impliedFormat":99},{"version":"d12eecede214f8807a719178d7d7e2fc32f227d4705d123c3f45d8a3b5765f38","impliedFormat":99},{"version":"c8893abd114f341b860622b92c9ffc8c9eb9f21f6541bd3cbc9a4aa9b1097e42","impliedFormat":99},{"version":"825674da70d892b7e32c53f844c5dfce5b15ea67ceda4768f752eed2f02d8077","impliedFormat":99},{"version":"2c676d27ef1afbc8f8e514bb46f38550adf177ae9b0102951111116fa7ea2e10","impliedFormat":99},{"version":"a6072f5111ea2058cb4d592a4ee241f88b198498340d9ad036499184f7798ae2","impliedFormat":99},{"version":"ab87c99f96d9b1bf93684b114b27191944fef9a164476f2c6c052b93eaac0a4f","impliedFormat":99},{"version":"13e48eaca1087e1268f172607ae2f39c72c831a482cab597076c6073c97a15e7","impliedFormat":99},{"version":"19597dbe4500c782a4252755510be8324451847354cd8e204079ae81ab8d0ef6","impliedFormat":99},{"version":"f7d487e5f0104f0737951510ea361bc919f5b5f3ebc51807f81ce54934a3556f","impliedFormat":99},{"version":"efa8c5897e0239017e5b53e3f465d106b00d01ee94c9ead378a33284a2998356","impliedFormat":99},{"version":"fe3c53940b26832930246d4c39d6e507c26a86027817882702cf03bff314fa1d","impliedFormat":99},{"version":"53ee33b91d4dc2787eccebdbd396291e063db1405514bb3ab446e1ca3fd81a90","impliedFormat":99},{"version":"c4a97da118b4e6dde7c1daa93c4da17f0c4eedece638fc6dcc84f4eb1d370808","impliedFormat":99},{"version":"71666363fbdb0946bfc38a8056c6010060d1a526c0584145a9560151c6962b4f","impliedFormat":99},{"version":"1326f3630d26716257e09424f33074a945940afd64f2482e2bbc885258fca6bb","impliedFormat":99},{"version":"cc2eb5b23140bbceadf000ef2b71d27ac011d1c325b0fc5ecd42a3221db5fb2e","impliedFormat":99},{"version":"d04f5f3e90755ed40b25ed4c6095b6ad13fc9ce98b34a69c8da5ed38e2dbab5a","impliedFormat":99},{"version":"280b04a2238c0636dad2f25bbbbac18cf7bb933c80e8ec0a44a1d6a9f9d69537","impliedFormat":99},{"version":"0e9a2d784877b62ad97ed31816b1f9992563fdda58380cd696e796022a46bfdf","impliedFormat":99},{"version":"1b1411e7a3729bc632d8c0a4d265de9c6cbba4dc36d679c26dad87507faedee3","impliedFormat":99},{"version":"c478cfb0a2474672343b932ea69da64005bbfc23af5e661b907b0df8eb87bcb7","impliedFormat":99},{"version":"1a7bff494148b6e66642db236832784b8b2c9f5ad9bff82de14bcdb863dadcd9","impliedFormat":99},{"version":"65e6ad2d939dd38d03b157450ba887d2e9c7fd0f8f9d3008c0d1e59a0d8a73b4","impliedFormat":99},{"version":"f72b400dbf8f27adbda4c39a673884cb05daf8e0a1d8152eec2480f5700db36c","impliedFormat":99},{"version":"347f6fe4308288802eb123596ad9caf06755e80cfc7f79bbe56f4141a8ee4c50","impliedFormat":99},{"version":"5f5baa59149d3d6d6cef2c09d46bb4d19beb10d6bee8c05b7850c33535b3c438","impliedFormat":99},{"version":"a8f0c99380c9e91a73ecfc0a8582fbdefde3a1351e748079dc8c0439ea97b6db","impliedFormat":99},{"version":"be02e3c3cb4e187fd252e7ae12f6383f274e82288c8772bb0daf1a4e4af571ad","impliedFormat":99},{"version":"82ca40fb541799273571b011cd9de6ee9b577ef68acc8408135504ae69365b74","impliedFormat":99},{"version":"e671e3fc9b6b2290338352606f6c92e6ecf1a56459c3f885a11080301ca7f8de","impliedFormat":99},{"version":"a2e4b90260194318b1fa1e6b0554d257a0862c10e982c8907d30d1e7f3d463af","impliedFormat":99},{"version":"5559ab4aa1ba9fac7225398231a179d63a4c4dccd982a17f09404b536980dae8","impliedFormat":99},{"version":"2d7b9e1626f44684252d826a8b35770b77ce7c322734a5d3236b629a301efdcf","impliedFormat":99},{"version":"5b8dafbb90924201f655931d429a4eceb055f11c836a6e9cbc7c3aecf735912d","impliedFormat":99},{"version":"0b9be1f90e5e154b61924a28ed2de133fd1115b79c682b1e3988ac810674a5c4","impliedFormat":99},{"version":"7a9477ba5fc17786ee74340780083f39f437904229a0cd57fc9a468fd6567eb8","impliedFormat":99},{"version":"3da1dd252145e279f23d85294399ed2120bf8124ed574d34354a0a313c8554b6","impliedFormat":99},{"version":"e5c4080de46b1a486e25a54ddbb6b859312359f9967a7dc3c9d5cf4676378201","impliedFormat":99},{"version":"cfe1cdf673d2db391fd1a1f123e0e69c7ca06c31d9ac8b35460130c5817c8d29","impliedFormat":99},{"version":"b9701f688042f44529f99fd312c49fea853e66538c19cfcbb9ef024fdb5470cc","impliedFormat":99},{"version":"6daa62c5836cc12561d12220d385a4a243a4a5a89afd6f2e48009a8dd8f0ad83","impliedFormat":99},{"version":"c74550758053cf21f7fea90c7f84fa66c27c5f5ac1eca77ce6c2877dbfdec4d1","impliedFormat":99},{"version":"bd8310114a3a5283faac25bfbfc0d75b685a3a3e0d827ee35d166286bdd4f82e","impliedFormat":99},{"version":"1459ae97d13aeb6e457ccffac1fbb5c5b6d469339729d9ef8aeb8f0355e1e2c9","impliedFormat":99},{"version":"1bf03857edaebf4beba27459edf97f9407467dc5c30195425cb8a5d5a573ea52","impliedFormat":99},{"version":"f6b4833d66c12c9106a3299e520ed46f9a4c443cefc22c993315c4bb97a28db1","impliedFormat":99},{"version":"746c02f8b99bd90c4d135badaab575c6cfce0d030528cf90190c8914b0934ea3","impliedFormat":99},{"version":"a858ba8df5e703977dee467b10af084398919e99c9e42559180e75953a1f6ef6","impliedFormat":99},{"version":"d2dcd6105c195d0409abd475b41363789c63ae633282f04465e291a68a151685","impliedFormat":99},{"version":"0b569ed836f0431c2efaef9b6017e8b700a7fed319866d7667f1189957275045","impliedFormat":99},{"version":"9371612fd8638d7f6a249a14843132e7adb0b5c84edba9ed7905e835b644c013","impliedFormat":99},{"version":"0c72189b6ec67331476a36ec70a2b8ce6468dc4db5d3eb52deb9fefbd6981ebb","impliedFormat":99},{"version":"af8dd6bb70bfcb2c6b2de0d42240c2c952b9040af259a287e78eaf883ef1ce0d","impliedFormat":99},{"version":"7e4a27fd17dbb256314c2513784236f2ae2023573e83d0e65ebddfda336701db","impliedFormat":99},{"version":"131ecac1c7c961041df80a1dc353223af4e658d56ba1516317f79bd5400cffeb","impliedFormat":99},{"version":"f3a55347fb874828e442c2916716d56552ac3478204c29c0d47e698c00eb5d28","impliedFormat":99},{"version":"49ebbdfe7427d784ccdc8325bdecc8dda1719a7881086f14751879b4f8d70c21","impliedFormat":99},{"version":"c1692845412646f17177eb62feb9588c8b5d5013602383f02ae9d38f3915020c","impliedFormat":99},{"version":"b1b440e6c973d920935591a3d360d79090b8cf58947c0230259225b02cf98a83","impliedFormat":99},{"version":"defc2ae12099f46649d12aa4872ce23ba43fba275920c00c398487eaf091bbae","impliedFormat":99},{"version":"620390fbef44884902e4911e7473531e9be4db37eeef2da52a34449d456b4617","impliedFormat":99},{"version":"e60440cbd3ec916bc5f25ada3a6c174619745c38bfca58d3554f7d62905dc376","impliedFormat":99},{"version":"86388eda63dcb65b4982786eec9f80c3ef21ca9fb2808ff58634e712f1f39a27","impliedFormat":99},{"version":"022cd098956e78c9644e4b3ad1fe460fac6914ca9349d6213f518386baf7c96b","impliedFormat":99},{"version":"dfc67e73325643e92f71f94276b5fb3be09c59a1eeee022e76c61ae99f3eda4b","impliedFormat":99},{"version":"8c3d6c9abaa0b383f43cac0c227f063dc4018d851a14b6c2142745a78553c426","impliedFormat":99},{"version":"ee551dc83df0963c1ee03dc32ce36d83b3db9793f50b1686dc57ec2bbffc98af","impliedFormat":99},{"version":"968832c4ffd675a0883e3d208b039f205e881ae0489cc13060274cf12e0e4370","impliedFormat":99},{"version":"c593ca754961cfd13820add8b34da35a114cda7215d214e4177a1b0e1a7f3377","impliedFormat":99},{"version":"ed88c51aa3b33bb2b6a8f2434c34f125946ba7b91ed36973169813fdad57f1ec","impliedFormat":99},{"version":"a9ea477d5607129269848510c2af8bcfd8e262ebfbd6cd33a6c451f0cd8f5257","impliedFormat":99},{"version":"772b2865dd86088c6e0cab71e23534ad7254961c1f791bdeaf31a57a2254df43","impliedFormat":1},{"version":"21717957404f5b57e7c66b38d5ea832cc7eb5e81a6152242cf2e21893b1fcc5d","impliedFormat":1},{"version":"539dd525bf1d52094e7a35c2b4270bee757d3a35770462bcb01cd07683b4d489","impliedFormat":1},{"version":"86c0791444b64f452f8e513dd07c697313dfc5842916d73abbd2dabd28930367","impliedFormat":1},{"version":"7a705c800602314ac1e6ac059e2c0842fedace663a44bc240e0dc6bfefa2020b","impliedFormat":1},{"version":"8e42a36680c916db7b8951fea71ec2ce0092b82e44c8a33a436902244f0cc907","impliedFormat":1},{"version":"3e2f739bdfb6b194ae2af13316b4c5bb18b3fe81ac340288675f92ba2061b370","affectsGlobalScope":true,"impliedFormat":1},{"version":"921394bdf2d9f67c9e30d98c4b1c56a899ac06770e5ce3389f95b6b85a58e009","affectsGlobalScope":true,"impliedFormat":1},{"version":"247389ec5593d19a2784587be69ea6349e784578070db0b30ba717bec269db38","impliedFormat":1},{"version":"ab82804a14454734010dcdcd43f564ff7b0389bee4c5692eec76ff5b30d4cf66","impliedFormat":1},{"version":"a1fe8b42e276de4de80e53ea6611cef3d416a9c074c9c590ab09874bd6772eba","affectsGlobalScope":true,"impliedFormat":1},{"version":"420845f2661ac73433cbdc45f36d1f7ca7ea4eca60c3cbd077adf3355387cb63","impliedFormat":99},{"version":"bae8d023ef6b23df7da26f51cea44321f95817c190342a36882e93b80d07a960","impliedFormat":1},{"version":"26a770cec4bd2e7dbba95c6e536390fffe83c6268b78974a93727903b515c4e7","impliedFormat":1}],"root":[[552,558],[560,607],[621,638],641,642,645,1557,[1573,1652]],"options":{"allowJs":true,"allowSyntheticDefaultImports":true,"emitDecoratorMetadata":true,"esModuleInterop":true,"experimentalDecorators":true,"jsx":4,"module":99,"noFallthroughCasesInSwitch":true,"skipLibCheck":true,"strict":true,"strictNullChecks":false,"target":2},"referencedMap":[[1651,1],[552,2],[1652,3],[1648,4],[1649,2],[1650,5],[1638,6],[1642,7],[1643,8],[1631,9],[1632,10],[1633,11],[1634,12],[1639,13],[1640,7],[1641,7],[1644,14],[1645,15],[1635,14],[1636,16],[1637,17],[1646,18],[1647,19],[553,20],[1657,2],[1851,21],[1520,2],[397,2],[1558,2],[1563,2],[1572,22],[1561,2],[1567,2],[1570,2],[1565,23],[1569,2],[1571,24],[1568,25],[1566,2],[1559,2],[1564,26],[1562,27],[1560,2],[1482,28],[1504,2],[1505,2],[1417,29],[1407,30],[1452,31],[1484,32],[1502,2],[1113,33],[1475,31],[1446,28],[1422,34],[1476,35],[1385,36],[1486,28],[1473,33],[1402,28],[1491,37],[1401,31],[1481,33],[1411,31],[1428,38],[1384,39],[1457,40],[1404,28],[1500,28],[1444,41],[1412,29],[1393,29],[1390,29],[1480,42],[1454,32],[1449,38],[1429,43],[1420,44],[1511,32],[1477,28],[1413,29],[1424,45],[1425,32],[1426,32],[1406,46],[1391,31],[1427,33],[1436,47],[1510,30],[1392,33],[1455,48],[1430,38],[1488,33],[1382,29],[1414,29],[1403,29],[1509,33],[1493,38],[1465,33],[1458,33],[1512,33],[1461,49],[1463,50],[1464,33],[1459,33],[1423,31],[1466,32],[1494,38],[1415,29],[1409,28],[1394,31],[1506,30],[1410,28],[1467,33],[1419,29],[1498,28],[1386,33],[1501,51],[1431,52],[1383,39],[1508,28],[1507,28],[1474,37],[1471,33],[1400,31],[1472,33],[1115,33],[1114,33],[1499,40],[1485,33],[1497,38],[1489,29],[1492,33],[1408,31],[1487,28],[1456,53],[1483,54],[1490,33],[1437,30],[1439,55],[1405,33],[1387,56],[1389,57],[1432,38],[1416,29],[1399,58],[1453,38],[1418,40],[1434,59],[1496,60],[1513,45],[1514,61],[1503,51],[1468,45],[1470,33],[1469,2],[1448,38],[1441,2],[1451,31],[1442,38],[1447,30],[1440,51],[1479,62],[1388,63],[1450,38],[1435,45],[1478,2],[1104,30],[1556,64],[1460,51],[1462,45],[1495,45],[1106,38],[1553,65],[1522,66],[1554,67],[1521,37],[1105,68],[1111,52],[1108,30],[1110,30],[1518,69],[1109,70],[1112,31],[1515,38],[1519,69],[1555,71],[1516,38],[1517,72],[1107,2],[1085,30],[1093,73],[1094,74],[1097,75],[1095,76],[1091,77],[1096,78],[1090,79],[1092,80],[1102,81],[1098,82],[1100,83],[1101,84],[1103,85],[1850,86],[1661,87],[1662,88],[1799,87],[1800,89],[1781,90],[1782,91],[1665,92],[1666,93],[1736,94],[1737,95],[1710,87],[1711,96],[1704,87],[1705,97],[1796,98],[1794,99],[1795,2],[1810,100],[1811,101],[1680,102],[1681,103],[1812,104],[1813,105],[1814,106],[1815,107],[1672,108],[1673,109],[1798,110],[1797,111],[1783,87],[1784,112],[1676,113],[1677,114],[1700,2],[1701,115],[1818,116],[1816,117],[1817,118],[1819,119],[1820,120],[1823,121],[1821,122],[1824,99],[1822,123],[1825,124],[1828,125],[1826,126],[1827,127],[1829,128],[1678,108],[1679,129],[1804,130],[1801,131],[1802,132],[1803,2],[1779,133],[1780,134],[1724,135],[1723,136],[1721,137],[1720,138],[1722,139],[1831,140],[1830,141],[1833,142],[1832,143],[1709,144],[1708,87],[1687,145],[1685,146],[1684,92],[1686,147],[1836,148],[1840,149],[1834,150],[1835,151],[1837,148],[1838,148],[1839,148],[1726,152],[1725,92],[1742,153],[1740,154],[1741,99],[1738,155],[1739,156],[1675,157],[1674,87],[1732,158],[1663,87],[1664,159],[1731,160],[1769,161],[1772,162],[1770,163],[1771,164],[1683,165],[1682,87],[1774,166],[1773,92],[1752,167],[1751,87],[1707,168],[1706,87],[1778,169],[1777,170],[1746,171],[1745,172],[1743,173],[1744,174],[1735,175],[1734,176],[1733,177],[1842,178],[1841,179],[1759,180],[1758,181],[1757,182],[1806,183],[1805,2],[1750,184],[1749,185],[1747,186],[1748,187],[1728,188],[1727,92],[1671,189],[1670,190],[1669,191],[1668,192],[1667,193],[1763,194],[1762,195],[1693,196],[1692,92],[1697,197],[1696,198],[1761,199],[1760,87],[1807,2],[1809,200],[1808,2],[1766,201],[1765,202],[1764,203],[1844,204],[1843,205],[1846,206],[1845,207],[1792,208],[1793,209],[1791,210],[1730,211],[1729,2],[1776,212],[1775,213],[1703,214],[1702,87],[1754,215],[1753,87],[1660,216],[1659,2],[1713,217],[1714,218],[1719,219],[1712,220],[1716,221],[1715,222],[1717,223],[1718,224],[1768,225],[1767,92],[1699,226],[1698,92],[1849,227],[1848,228],[1847,229],[1786,230],[1785,87],[1756,231],[1755,87],[1691,232],[1689,233],[1688,92],[1690,234],[1788,235],[1787,87],[1695,236],[1694,87],[1790,237],[1789,87],[1653,2],[1654,2],[1655,238],[1656,239],[1857,240],[609,241],[610,242],[608,243],[611,244],[612,245],[613,246],[614,247],[615,248],[616,249],[617,250],[618,251],[619,252],[620,253],[154,254],[155,254],[156,255],[94,256],[157,257],[158,258],[159,259],[92,2],[160,260],[161,261],[162,262],[163,263],[164,264],[165,265],[166,265],[167,266],[168,267],[169,268],[170,269],[95,2],[93,2],[171,270],[172,271],[173,272],[214,273],[174,274],[175,275],[176,274],[177,276],[178,277],[180,278],[181,279],[182,279],[183,279],[184,280],[185,281],[186,282],[187,283],[188,284],[189,285],[190,285],[191,286],[192,2],[193,2],[194,287],[195,288],[196,287],[197,289],[198,290],[199,291],[200,292],[201,293],[202,294],[203,295],[204,296],[205,297],[206,298],[207,299],[208,300],[209,301],[210,302],[211,303],[96,274],[97,2],[98,304],[99,305],[100,2],[101,306],[102,2],[145,307],[146,308],[147,309],[148,309],[149,310],[150,2],[151,257],[152,311],[153,308],[212,312],[213,313],[1858,2],[643,2],[218,314],[482,30],[219,315],[217,316],[484,317],[483,318],[1859,30],[215,319],[480,2],[216,320],[83,2],[85,321],[479,30],[249,30],[1860,2],[1861,2],[1079,322],[1862,322],[1067,323],[1078,324],[735,325],[669,326],[734,327],[731,328],[737,329],[668,330],[732,331],[733,332],[738,333],[739,334],[740,334],[741,334],[742,333],[743,334],[745,335],[746,336],[747,2],[744,328],[748,336],[713,337],[656,338],[978,339],[882,340],[712,341],[979,337],[646,2],[649,342],[683,343],[980,2],[681,2],[682,2],[794,344],[981,345],[796,346],[650,347],[651,348],[727,2],[730,349],[729,350],[687,351],[982,352],[983,2],[863,2],[864,353],[984,354],[997,2],[998,2],[1068,355],[999,356],[1000,357],[670,358],[671,359],[672,360],[673,361],[985,362],[987,363],[988,364],[989,365],[990,364],[996,366],[986,365],[991,365],[992,364],[993,365],[994,364],[995,365],[1001,345],[1002,345],[1003,345],[1004,367],[970,345],[1006,368],[1007,345],[1008,369],[1020,370],[1009,368],[1010,371],[1011,368],[971,345],[1005,345],[1012,345],[1013,372],[1014,345],[1015,368],[1016,345],[1017,345],[1018,373],[1019,345],[1022,374],[1024,375],[1025,376],[1026,377],[1027,378],[1028,379],[1029,380],[1030,381],[1031,382],[1032,383],[1033,375],[1034,384],[1035,385],[848,386],[884,387],[883,388],[887,389],[685,390],[896,391],[872,392],[899,393],[898,394],[903,386],[890,395],[889,394],[1038,396],[1039,397],[1040,398],[1041,2],[1042,399],[1043,400],[1044,401],[1045,397],[1046,397],[1047,397],[1037,402],[1048,2],[1036,403],[1049,404],[1050,405],[1051,406],[850,407],[851,408],[724,409],[869,410],[852,411],[853,412],[854,413],[855,414],[856,415],[857,416],[858,414],[860,417],[859,414],[861,415],[862,407],[866,418],[865,419],[867,420],[868,407],[967,421],[966,422],[696,356],[678,423],[658,424],[657,425],[659,426],[653,427],[871,428],[1052,429],[663,2],[674,430],[1054,431],[772,2],[648,432],[654,433],[676,434],[652,435],[728,436],[675,437],[660,426],[895,426],[677,438],[647,439],[661,440],[655,441],[664,442],[665,442],[666,442],[667,442],[1053,442],[936,443],[787,444],[788,445],[789,446],[790,447],[791,447],[793,448],[798,449],[799,450],[800,447],[803,451],[805,452],[806,453],[804,454],[807,447],[808,447],[802,447],[809,455],[811,456],[814,457],[815,458],[816,459],[792,460],[817,447],[818,461],[819,462],[820,463],[821,464],[822,465],[823,466],[826,467],[825,468],[751,469],[752,470],[753,465],[754,447],[756,471],[940,472],[757,447],[755,465],[758,447],[760,473],[761,474],[764,475],[939,476],[765,447],[938,477],[759,447],[766,2],[768,478],[769,479],[824,480],[770,2],[912,481],[774,482],[785,483],[775,2],[776,484],[763,447],[778,485],[777,447],[779,447],[767,2],[781,486],[780,465],[782,447],[750,465],[771,447],[773,487],[783,447],[784,488],[749,2],[827,469],[828,489],[829,447],[830,490],[831,491],[832,490],[833,447],[834,492],[835,493],[836,447],[839,494],[840,495],[838,496],[933,497],[934,498],[935,499],[841,500],[842,447],[843,447],[844,447],[845,501],[846,469],[847,447],[879,502],[878,503],[877,504],[880,502],[881,502],[885,505],[886,502],[888,506],[892,507],[893,502],[897,508],[894,509],[849,447],[937,510],[901,511],[900,512],[902,507],[904,513],[875,472],[876,514],[891,515],[905,469],[907,447],[908,447],[906,516],[909,469],[910,469],[911,517],[913,481],[914,518],[915,519],[801,520],[812,447],[916,447],[917,469],[918,470],[919,521],[920,469],[921,447],[922,522],[923,523],[924,524],[925,447],[929,525],[926,526],[927,447],[928,469],[930,447],[931,466],[932,447],[813,527],[786,528],[662,328],[873,529],[684,328],[795,530],[1056,340],[1021,531],[1055,532],[1023,532],[714,533],[1057,531],[726,534],[810,535],[870,536],[1059,537],[1061,538],[977,539],[709,540],[719,541],[951,542],[941,543],[948,544],[947,2],[762,545],[958,546],[949,547],[942,548],[955,2],[874,549],[943,550],[952,2],[976,551],[950,2],[953,552],[680,553],[944,328],[945,554],[946,555],[972,556],[963,557],[969,558],[965,559],[964,560],[975,561],[679,344],[797,562],[956,563],[959,564],[960,565],[974,566],[973,352],[954,567],[968,568],[962,569],[957,570],[961,571],[1069,2],[1070,572],[695,573],[1071,574],[704,575],[705,576],[1072,577],[697,545],[720,578],[721,579],[698,2],[706,580],[1073,581],[701,582],[722,583],[707,584],[700,585],[723,586],[702,2],[703,587],[1074,2],[708,588],[710,589],[1076,590],[699,582],[1075,591],[717,592],[1077,593],[718,594],[692,550],[693,550],[694,595],[1062,357],[1063,596],[1064,596],[688,597],[689,357],[1058,597],[1060,597],[725,597],[686,357],[716,598],[837,357],[690,426],[691,599],[1066,600],[1065,357],[736,545],[711,2],[1863,2],[1864,601],[1550,602],[1531,603],[1529,604],[1530,2],[1549,605],[1528,606],[1532,607],[1535,608],[1533,609],[1525,610],[1527,611],[1534,612],[1526,611],[1524,613],[1523,2],[1547,614],[1546,606],[1536,606],[1548,615],[1545,616],[1551,617],[1537,618],[1538,616],[1544,616],[1543,616],[1542,616],[1539,616],[1541,616],[1540,616],[1552,619],[715,2],[179,2],[1421,51],[1658,2],[559,2],[84,2],[1443,2],[1856,620],[1855,2],[1433,2],[640,621],[639,2],[1853,622],[1854,623],[1395,51],[1396,51],[1398,624],[1397,625],[505,626],[510,627],[517,628],[500,629],[253,2],[261,630],[401,631],[404,632],[376,2],[389,633],[396,634],[278,2],[378,2],[259,2],[375,635],[421,636],[260,2],[251,637],[403,638],[405,639],[406,640],[477,641],[370,642],[323,643],[383,644],[384,645],[382,646],[381,2],[377,647],[402,648],[262,649],[447,2],[448,650],[289,651],[263,652],[290,651],[326,651],[229,651],[399,653],[398,2],[388,654],[495,2],[238,2],[516,655],[455,656],[456,657],[452,658],[534,2],[353,2],[457,659],[453,660],[539,661],[538,662],[533,2],[304,2],[356,663],[355,2],[532,664],[454,30],[309,665],[316,666],[318,667],[308,2],[313,668],[315,669],[317,670],[312,671],[310,2],[314,672],[535,2],[531,2],[537,673],[536,2],[307,674],[526,675],[529,676],[297,677],[296,678],[295,679],[542,30],[294,680],[283,2],[544,2],[545,30],[546,681],[221,2],[385,682],[386,683],[387,684],[225,2],[390,2],[245,685],[220,2],[469,30],[227,686],[468,687],[467,688],[458,2],[459,2],[466,2],[461,2],[464,689],[460,2],[462,690],[465,691],[463,690],[258,2],[255,2],[256,651],[410,2],[415,692],[416,693],[414,694],[412,695],[413,696],[408,2],[475,659],[250,659],[504,697],[511,698],[515,699],[344,700],[343,2],[338,2],[491,701],[499,702],[371,703],[372,704],[450,705],[360,2],[473,706],[348,30],[365,707],[476,708],[361,2],[364,709],[362,2],[474,710],[471,711],[470,2],[472,2],[368,2],[446,712],[233,713],[346,714],[350,715],[366,716],[369,717],[358,718],[351,719],[498,720],[424,721],[342,722],[230,723],[497,724],[226,725],[417,726],[409,2],[418,727],[435,728],[407,2],[434,729],[91,2],[429,730],[254,2],[449,731],[425,2],[239,2],[241,2],[380,2],[433,732],[257,2],[281,733],[367,734],[287,735],[347,2],[432,2],[411,2],[437,736],[438,737],[379,2],[440,738],[442,739],[441,740],[391,2],[431,723],[444,741],[341,742],[430,743],[436,744],[266,2],[270,2],[269,2],[268,2],[273,2],[267,2],[276,2],[275,2],[272,2],[271,2],[274,2],[277,745],[265,2],[333,746],[332,2],[337,747],[334,748],[336,749],[339,747],[335,748],[246,750],[325,751],[494,752],[492,2],[521,753],[523,754],[487,755],[522,756],[234,757],[231,757],[264,2],[248,758],[247,759],[243,760],[244,761],[252,762],[280,762],[291,762],[327,763],[292,763],[236,764],[235,2],[331,765],[330,766],[329,767],[328,768],[237,769],[478,770],[279,771],[486,772],[451,773],[481,774],[485,775],[374,776],[373,777],[354,778],[340,779],[322,780],[324,781],[321,782],[443,783],[345,2],[509,2],[242,784],[445,785],[493,786],[352,2],[282,787],[359,788],[357,789],[284,790],[419,791],[488,2],[285,792],[420,792],[507,2],[506,2],[508,2],[490,2],[489,2],[422,793],[349,2],[319,794],[240,795],[298,2],[224,796],[286,2],[513,30],[223,2],[525,797],[306,30],[519,659],[305,798],[502,799],[303,797],[228,2],[527,800],[301,30],[302,30],[293,2],[222,2],[300,801],[299,802],[288,803],[363,283],[423,283],[439,2],[427,804],[426,2],[311,674],[232,2],[320,30],[496,685],[503,805],[86,30],[89,806],[90,807],[87,30],[88,2],[400,305],[395,808],[394,2],[393,809],[392,2],[501,810],[512,811],[514,812],[518,813],[520,814],[524,815],[528,816],[551,817],[530,818],[540,819],[541,820],[543,821],[547,822],[550,685],[549,2],[548,823],[1852,824],[644,825],[1099,2],[428,826],[1438,2],[1445,51],[1148,51],[1149,51],[1151,827],[1150,51],[1176,828],[1196,829],[1193,829],[1190,830],[1186,2],[1188,830],[1197,830],[1195,829],[1191,830],[1192,2],[1194,829],[1189,51],[1187,830],[1256,831],[1255,51],[1257,832],[1258,2],[1378,51],[1376,51],[1377,51],[1375,51],[1379,51],[1313,51],[1314,51],[1312,51],[1310,51],[1311,51],[1315,51],[1147,51],[1143,51],[1142,51],[1139,51],[1144,51],[1146,51],[1141,51],[1145,51],[1140,51],[1250,51],[1248,51],[1251,51],[1160,51],[1247,833],[1246,51],[1249,51],[1252,51],[1254,834],[1367,51],[1370,51],[1368,51],[1372,51],[1371,51],[1369,51],[1381,835],[1305,51],[1306,51],[1307,51],[1308,836],[1380,2],[1241,837],[1374,51],[1373,2],[1366,838],[1361,839],[1362,51],[1365,840],[1360,51],[1363,840],[1364,839],[1345,51],[1334,51],[1347,51],[1331,51],[1323,51],[1341,51],[1324,51],[1338,51],[1238,51],[1333,51],[1316,51],[1253,51],[1340,51],[1240,841],[1352,842],[1325,843],[1239,51],[1350,51],[1343,51],[1337,51],[1318,51],[1358,51],[1328,51],[1349,51],[1332,51],[1348,51],[1321,51],[1319,844],[1346,845],[1357,51],[1353,51],[1359,51],[1354,51],[1339,51],[1330,51],[1355,51],[1320,51],[1344,51],[1342,51],[1317,51],[1329,51],[1351,51],[1356,51],[1327,51],[1326,846],[1336,51],[1322,51],[1335,51],[1181,51],[1182,51],[1177,51],[1183,2],[1185,51],[1178,51],[1180,51],[1184,847],[1179,2],[1117,51],[1119,51],[1120,51],[1125,51],[1116,51],[1121,51],[1118,51],[1129,51],[1122,51],[1123,2],[1128,51],[1126,848],[1127,844],[1124,2],[1135,51],[1137,51],[1136,51],[1138,51],[1152,51],[1166,51],[1157,51],[1161,849],[1159,51],[1154,850],[1163,51],[1162,851],[1155,850],[1156,51],[1164,51],[1158,51],[1165,850],[1309,51],[1214,852],[1219,853],[1230,854],[1212,852],[1202,852],[1216,852],[1223,855],[1221,852],[1208,856],[1204,857],[1205,852],[1201,858],[1220,852],[1209,852],[1198,51],[1227,852],[1228,852],[1217,852],[1206,852],[1225,852],[1210,852],[1224,859],[1211,852],[1200,860],[1226,861],[1213,852],[1215,852],[1231,852],[1130,51],[1131,51],[1132,51],[1133,51],[1259,862],[1218,862],[1260,863],[1261,862],[1262,2],[1263,862],[1175,51],[1264,2],[1265,51],[1266,51],[1229,862],[1267,862],[1268,2],[1269,862],[1203,2],[1222,51],[1270,51],[1207,2],[1271,2],[1272,51],[1273,2],[1274,862],[1275,51],[1276,2],[1277,862],[1278,2],[1279,2],[1280,2],[1281,51],[1282,2],[1283,2],[1284,51],[1285,2],[1286,2],[1287,2],[1288,862],[1289,51],[1290,51],[1291,51],[1292,2],[1293,51],[1294,2],[1295,2],[1296,2],[1297,51],[1298,51],[1299,2],[1300,862],[1301,2],[1302,2],[1303,51],[1304,2],[1199,51],[1134,2],[1153,2],[1173,51],[1174,51],[1169,51],[1170,51],[1167,51],[1172,51],[1171,51],[1168,51],[1232,837],[1234,864],[1235,51],[1236,51],[1237,51],[1242,865],[1243,837],[1233,51],[1245,866],[1244,867],[81,2],[82,2],[13,2],[14,2],[16,2],[15,2],[2,2],[17,2],[18,2],[19,2],[20,2],[21,2],[22,2],[23,2],[24,2],[3,2],[25,2],[26,2],[4,2],[27,2],[31,2],[28,2],[29,2],[30,2],[32,2],[33,2],[34,2],[5,2],[35,2],[36,2],[37,2],[38,2],[6,2],[42,2],[39,2],[40,2],[41,2],[43,2],[7,2],[44,2],[49,2],[50,2],[45,2],[46,2],[47,2],[48,2],[8,2],[54,2],[51,2],[52,2],[53,2],[55,2],[9,2],[56,2],[57,2],[58,2],[60,2],[59,2],[61,2],[62,2],[10,2],[63,2],[64,2],[65,2],[11,2],[66,2],[67,2],[68,2],[69,2],[70,2],[1,2],[71,2],[72,2],[12,2],[76,2],[74,2],[79,2],[78,2],[73,2],[77,2],[75,2],[80,2],[121,868],[133,869],[118,870],[134,871],[143,872],[109,873],[110,874],[108,875],[142,823],[137,876],[141,877],[112,878],[130,879],[111,880],[140,881],[106,882],[107,876],[113,883],[114,2],[120,884],[117,883],[104,885],[144,886],[135,887],[124,888],[123,883],[125,889],[128,890],[122,891],[126,892],[138,823],[115,893],[116,894],[129,895],[105,871],[132,896],[131,883],[119,894],[127,897],[136,2],[103,2],[139,898],[1080,2],[1083,2],[1084,899],[1081,900],[1082,901],[1088,902],[1087,903],[1089,903],[1086,2],[560,904],[565,905],[566,906],[562,907],[563,908],[564,909],[561,910],[572,911],[569,912],[570,913],[573,914],[571,913],[568,915],[555,915],[556,915],[577,916],[575,917],[576,917],[574,659],[578,918],[567,919],[581,920],[582,921],[580,922],[579,659],[1578,659],[1579,923],[1584,924],[1583,925],[1580,926],[1581,927],[1582,928],[584,929],[585,930],[583,915],[586,931],[1587,932],[1588,933],[1590,934],[1593,935],[1591,936],[1589,659],[1592,937],[1586,938],[588,939],[1585,659],[587,915],[1595,940],[1596,941],[1597,942],[1594,943],[1598,940],[1599,944],[1600,945],[589,915],[591,946],[1601,947],[1603,948],[1604,949],[1602,950],[1605,951],[1606,952],[596,953],[1607,954],[1611,955],[1608,956],[1613,957],[1612,958],[593,659],[592,915],[595,959],[597,960],[594,915],[1610,961],[1614,962],[600,963],[599,964],[601,963],[598,915],[1618,965],[1615,966],[602,967],[590,915],[558,915],[606,968],[603,915],[605,969],[604,915],[607,970],[1616,971],[621,972],[1576,973],[1575,974],[635,975],[622,976],[627,977],[624,915],[629,978],[630,978],[633,979],[626,980],[631,977],[632,981],[628,980],[625,915],[623,915],[634,982],[638,983],[1573,984],[1619,659],[1574,985],[637,986],[636,915],[1577,987],[554,2],[557,14],[1620,988],[1627,989],[1621,990],[1617,991],[1623,992],[1557,993],[1622,994],[1624,995],[1625,996],[1626,997],[1628,659],[1629,659],[1630,998],[1609,999],[641,1000],[642,1001],[645,1002]],"semanticDiagnosticsPerFile":[[626,[{"start":434,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":891,"length":7,"code":2769,"category":1,"messageText":{"messageText":"No overload matches this call.","category":1,"code":2769,"next":[{"messageText":"The last overload gave the following error.","category":1,"code":2770,"next":[{"messageText":"Argument of type 'string | number | symbol' is not assignable to parameter of type 'string | FunctionComponent<{ className: string; title: string; 'aria-label': string; style: { color?: string; fontSize?: FontSize<string | number>; accentColor?: AccentColor; alignContent?: AlignContent; ... 852 more ...; glyphOrientationVertical?: GlyphOrientationVertical; }; ... 273 more ...; \"aria-valuetext\"?: st...'.","category":1,"code":2345,"next":[{"messageText":"Type 'number' is not assignable to type 'string | FunctionComponent<{ className: string; title: string; 'aria-label': string; style: { color?: string; fontSize?: FontSize<string | number>; accentColor?: AccentColor; alignContent?: AlignContent; ... 852 more ...; glyphOrientationVertical?: GlyphOrientationVertical; }; ... 273 more ...; \"aria-valuetext\"?: st...'.","category":1,"code":2322}]}]}]},"relatedInformation":[{"file":"./node_modules/@types/react/index.d.ts","start":16286,"length":13,"messageText":"The last overload is declared here.","category":1,"code":2771}]}]],[632,[{"start":6761,"length":3,"code":2769,"category":1,"messageText":{"messageText":"No overload matches this call.","category":1,"code":2769,"next":[{"messageText":"The last overload gave the following error.","category":1,"code":2770,"next":[{"messageText":"Object literal may only specify known properties, and 'ref' does not exist in type 'Partial<unknown> & Attributes'.","category":1,"code":2353}]}]},"relatedInformation":[{"file":"./node_modules/@types/react/index.d.ts","start":17916,"length":12,"messageText":"The last overload is declared here.","category":1,"code":2771}]}]],[1557,[{"start":1007,"length":39,"messageText":"Cannot find module 'three/examples/jsm/capabilities/WebGL' or its corresponding type declarations.","category":1,"code":2307}]],[1573,[{"start":1714,"length":8,"code":2339,"category":1,"messageText":"Property 'children' does not exist on type 'unknown'."},{"start":1854,"length":4,"code":2339,"category":1,"messageText":"Property 'head' does not exist on type 'unknown'."}]],[1574,[{"start":11536,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":12873,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":13271,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":13372,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":13483,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":14478,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":14568,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":14738,"length":6,"messageText":"Expected 1 arguments, but got 0.","category":1,"code":2554,"relatedInformation":[{"file":"./node_modules/@types/react/index.d.ts","start":64745,"length":15,"messageText":"An argument for 'initialValue' was not provided.","category":3,"code":6210}]},{"start":26578,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":26739,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":28202,"length":7,"code":2769,"category":1,"messageText":{"messageText":"No overload matches this call.","category":1,"code":2769,"next":[{"messageText":"The last overload gave the following error.","category":1,"code":2770,"next":[{"messageText":"Argument of type 'string | number | symbol' is not assignable to parameter of type 'string | FunctionComponent<{ \"aria-hidden\": boolean; className: string; title: string; style?: CSSProperties; children?: ReactNode; draggable?: Booleanish; onClick?: MouseEventHandler<...>; ... 270 more ...; \"aria-valuetext\"?: string; }> | ComponentClass<...>'.","category":1,"code":2345,"next":[{"messageText":"Type 'number' is not assignable to type 'string | FunctionComponent<{ \"aria-hidden\": boolean; className: string; title: string; style?: CSSProperties; children?: ReactNode; draggable?: Booleanish; onClick?: MouseEventHandler<...>; ... 270 more ...; \"aria-valuetext\"?: string; }> | ComponentClass<...>'.","category":1,"code":2322}]}]}]},"relatedInformation":[{"file":"./node_modules/@types/react/index.d.ts","start":16286,"length":13,"messageText":"The last overload is declared here.","category":1,"code":2771}]},{"start":38187,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":39162,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":39200,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":39448,"length":15,"code":2741,"category":1,"messageText":"Property 'index' is missing in type '{ goto: ReactElement<unknown, string | JSXElementConstructor<any>> | ReactPortal; }' but required in type 'FootnoteProps'.","relatedInformation":[{"start":37849,"length":5,"messageText":"'index' is declared here.","category":3,"code":2728}],"canonicalHead":{"code":2322,"messageText":"Type '{ goto: ReactElement<unknown, string | JSXElementConstructor<any>> | ReactPortal; }' is not assignable to type 'FootnoteProps'."}},{"start":39468,"length":11,"messageText":"Spread types may only be created from object types.","category":1,"code":2698},{"start":39573,"length":5,"code":2339,"category":1,"messageText":"Property 'index' does not exist on type 'unknown'."},{"start":39594,"length":9,"code":2741,"category":1,"messageText":"Property 'index' is missing in type '{ is: \"reference\"; inline: true; }' but required in type 'FootnoteProps'.","relatedInformation":[{"start":37849,"length":5,"messageText":"'index' is declared here.","category":3,"code":2728}],"canonicalHead":{"code":2322,"messageText":"Type '{ is: \"reference\"; inline: true; }' is not assignable to type 'FootnoteProps'."}},{"start":39608,"length":11,"messageText":"Spread types may only be created from object types.","category":1,"code":2698},{"start":39823,"length":8,"code":2339,"category":1,"messageText":"Property 'children' does not exist on type 'unknown'."},{"start":39864,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":53653,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":53686,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":53726,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":56578,"length":4,"code":2322,"category":1,"messageText":{"messageText":"Type '{ children: Element; icon: Element; intent: any; minimal: true; interactive: true; multiline: true; }' is not assignable to type 'IntrinsicAttributes & TagProps'.","category":1,"code":2322,"next":[{"messageText":"Property 'icon' does not exist on type 'IntrinsicAttributes & TagProps'.","category":1,"code":2339}]}},{"start":59137,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503}]],[1582,[{"start":744,"length":4,"code":2339,"category":1,"messageText":"Property 'then' does not exist on type 'FileEntry[]'."},{"start":750,"length":7,"messageText":"Parameter 'entries' implicitly has an 'any' type.","category":1,"code":7006}]],[1612,[{"start":5986,"length":4,"code":2339,"category":1,"messageText":"Property 'then' does not exist on type 'FileEntry[]'."},{"start":5992,"length":7,"messageText":"Parameter 'fetched' implicitly has an 'any' type.","category":1,"code":7006}]],[1616,[{"start":1725,"length":4,"code":2322,"category":1,"messageText":"Type 'Element' is not assignable to type 'string'.","relatedInformation":[{"file":"./src/lib/blueprintjs/Button.tsx","start":451,"length":4,"messageText":"The expected type comes from property 'icon' which is declared here on type 'IntrinsicAttributes & ButtonProps'","category":3,"code":6500}]}]],[1620,[{"start":5052,"length":8,"code":2339,"category":1,"messageText":"Property 'children' does not exist on type 'unknown'."}]],[1622,[{"start":504,"length":39,"messageText":"Cannot find module 'three/examples/jsm/capabilities/WebGL' or its corresponding type declarations.","category":1,"code":2307}]],[1624,[{"start":1962,"length":8,"code":2339,"category":1,"messageText":"Property 'children' does not exist on type 'unknown'."}]],[1626,[{"start":13036,"length":9,"code":2339,"category":1,"messageText":"Property 'positions' does not exist on type 'Graph'."},{"start":13079,"length":10,"code":2339,"category":1,"messageText":"Property 'velocities' does not exist on type 'Graph'."},{"start":13116,"length":10,"code":2339,"category":1,"messageText":"Property 'velocities' does not exist on type 'Graph'."},{"start":13224,"length":9,"code":2339,"category":1,"messageText":"Property 'positions' does not exist on type 'Graph'."},{"start":13298,"length":9,"code":2339,"category":1,"messageText":"Property 'positions' does not exist on type 'Graph'."},{"start":13335,"length":10,"code":2339,"category":1,"messageText":"Property 'velocities' does not exist on type 'Graph'."},{"start":21915,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":21920,"length":3,"messageText":"Parameter 'rot' implicitly has an 'any' type.","category":1,"code":7006},{"start":21925,"length":4,"messageText":"Parameter 'tilt' implicitly has an 'any' type.","category":1,"code":7006},{"start":21931,"length":7,"messageText":"Parameter 'camDist' implicitly has an 'any' type.","category":1,"code":7006},{"start":31567,"length":1,"messageText":"Parameter 'p' implicitly has an 'any' type.","category":1,"code":7006},{"start":38866,"length":3,"messageText":"Parameter 'now' implicitly has an 'any' type.","category":1,"code":7006}]],[1628,[{"start":515,"length":2,"messageText":"Parameter 'at' implicitly has an 'any' type.","category":1,"code":7006},{"start":530,"length":2,"code":2339,"category":1,"messageText":"Property 'op' does not exist on type 'Boundary'."},{"start":556,"length":2,"code":2339,"category":1,"messageText":"Property 'at' does not exist on type 'Boundary'."},{"start":574,"length":6,"code":2339,"category":1,"messageText":"Property 'target' does not exist on type 'Boundary'."},{"start":803,"length":9,"messageText":"Parameter 'direction' implicitly has an 'any' type.","category":1,"code":7006},{"start":825,"length":9,"code":2339,"category":1,"messageText":"Property 'direction' does not exist on type 'Ray'."},{"start":905,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":1338,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":1343,"length":8,"messageText":"Parameter 'isCenter' implicitly has an 'any' type.","category":1,"code":7006},{"start":1379,"length":7,"code":2339,"category":1,"messageText":"Property 'gridPos' does not exist on type 'GridNode'."},{"start":1432,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":1460,"length":3,"code":2339,"category":1,"messageText":"Property 'vel' does not exist on type 'GridNode'."},{"start":1493,"length":8,"code":2339,"category":1,"messageText":"Property 'isCenter' does not exist on type 'GridNode'."},{"start":1523,"length":8,"code":2339,"category":1,"messageText":"Property 'isPhoton' does not exist on type 'GridNode'."},{"start":1550,"length":6,"code":2339,"category":1,"messageText":"Property 'weight' does not exist on type 'GridNode'."},{"start":1618,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1696,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1803,"length":2,"messageText":"Parameter 'op' implicitly has an 'any' type.","category":1,"code":7006},{"start":1825,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1836,"length":3,"messageText":"Parameter 'ray' implicitly has an 'any' type.","category":1,"code":7006},{"start":2341,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":3176,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":3185,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":4064,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":4157,"length":6,"messageText":"Parameter 'prefix' implicitly has an 'any[]' type.","category":1,"code":7006},{"start":4560,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":4601,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":4981,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":5025,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":5096,"length":1,"messageText":"Parameter 'c' implicitly has an 'any' type.","category":1,"code":7006},{"start":5165,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":5490,"length":8,"code":2339,"category":1,"messageText":"Property 'isCenter' does not exist on type 'GridNode'."},{"start":5534,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":5543,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":5660,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":5700,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":6137,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6149,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":6152,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":6155,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":6180,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6318,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6386,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6490,"length":13,"messageText":"Object literal's property 'freeQueue' implicitly has an 'any[]' type.","category":1,"code":7018},{"start":7481,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":7486,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":7495,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":7517,"length":1,"messageText":"Parameter 'c' implicitly has an 'any' type.","category":1,"code":7006},{"start":7678,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":8634,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":8656,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":8659,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":8960,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":9000,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":9082,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":9541,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":9652,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":9657,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":9743,"length":6,"messageText":"Parameter 'prefix' implicitly has an 'any[]' type.","category":1,"code":7006},{"start":11417,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":11422,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":11637,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":11705,"length":1,"messageText":"Parameter 'n' implicitly has an 'any' type.","category":1,"code":7006},{"start":11755,"length":1,"messageText":"Binding element 'a' implicitly has an 'any' type.","category":1,"code":7031},{"start":11758,"length":1,"messageText":"Binding element 'b' implicitly has an 'any' type.","category":1,"code":7031},{"start":12187,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":12192,"length":4,"messageText":"Parameter 'keep' implicitly has an 'any' type.","category":1,"code":7006},{"start":12198,"length":4,"messageText":"Parameter 'from' implicitly has an 'any' type.","category":1,"code":7006},{"start":13095,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":13292,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":13297,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":13302,"length":3,"messageText":"Parameter 'dir' implicitly has an 'any' type.","category":1,"code":7006},{"start":13391,"length":8,"code":2339,"category":1,"messageText":"Property 'isPhoton' does not exist on type 'GridNode'."},{"start":13450,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":13488,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":13639,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":13644,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":13649,"length":3,"messageText":"Parameter 'dir' implicitly has an 'any' type.","category":1,"code":7006},{"start":13654,"length":8,"messageText":"Parameter 'reversed' implicitly has an 'any' type.","category":1,"code":7006},{"start":13811,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":13852,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":13892,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":13943,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":13982,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14024,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":14180,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":14578,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":14583,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":14646,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":14712,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":14717,"length":1,"messageText":"Parameter 'a' implicitly has an 'any' type.","category":1,"code":7006},{"start":14720,"length":1,"messageText":"Parameter 'b' implicitly has an 'any' type.","category":1,"code":7006},{"start":14982,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":14985,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":15073,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15109,"length":2,"messageText":"Parameter 'n1' implicitly has an 'any' type.","category":1,"code":7006},{"start":15113,"length":2,"messageText":"Parameter 'n2' implicitly has an 'any' type.","category":1,"code":7006},{"start":15117,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":15141,"length":3,"messageText":"Parameter 'ray' implicitly has an 'any' type.","category":1,"code":7006},{"start":15210,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":15213,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15216,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":15274,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15378,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15381,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":15767,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":15772,"length":1,"messageText":"Parameter 'a' implicitly has an 'any' type.","category":1,"code":7006},{"start":15775,"length":1,"messageText":"Parameter 'b' implicitly has an 'any' type.","category":1,"code":7006},{"start":15894,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15897,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":15964,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16015,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16930,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":16935,"length":8,"messageText":"Parameter 'attacker' implicitly has an 'any' type.","category":1,"code":7006},{"start":16945,"length":6,"messageText":"Parameter 'target' implicitly has an 'any' type.","category":1,"code":7006},{"start":17162,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":17165,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":17260,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":17494,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":17497,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":17500,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":18935,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":18940,"length":2,"messageText":"Parameter 'dt' implicitly has an 'any' type.","category":1,"code":7006},{"start":18944,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":23139,"length":6,"messageText":"Parameter 'prefix' implicitly has an 'any[]' type.","category":1,"code":7006},{"start":23680,"length":1,"messageText":"Parameter 'c' implicitly has an 'any' type.","category":1,"code":7006},{"start":29556,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":29613,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":29616,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":29995,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":30000,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":30005,"length":3,"messageText":"Parameter 'rot' implicitly has an 'any' type.","category":1,"code":7006},{"start":30010,"length":4,"messageText":"Parameter 'tilt' implicitly has an 'any' type.","category":1,"code":7006},{"start":30016,"length":7,"messageText":"Parameter 'camDist' implicitly has an 'any' type.","category":1,"code":7006},{"start":31003,"length":3,"messageText":"Parameter 'ctx' implicitly has an 'any' type.","category":1,"code":7006},{"start":31008,"length":6,"messageText":"Parameter 'canvas' implicitly has an 'any' type.","category":1,"code":7006},{"start":31016,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":31021,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":31026,"length":3,"messageText":"Parameter 'cam' implicitly has an 'any' type.","category":1,"code":7006},{"start":31031,"length":2,"messageText":"Parameter 'dt' implicitly has an 'any' type.","category":1,"code":7006},{"start":34189,"length":1,"messageText":"Parameter 'p' implicitly has an 'any' type.","category":1,"code":7006},{"start":35683,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":35686,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":37084,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":37143,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":37146,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":39638,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":40051,"length":3,"messageText":"Variable 'raf' implicitly has type 'any' in some locations where its type cannot be determined.","category":1,"code":7034},{"start":40814,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":41945,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":42123,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":42266,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":42575,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":42811,"length":3,"messageText":"Parameter 'now' implicitly has an 'any' type.","category":1,"code":7006},{"start":43539,"length":3,"messageText":"Variable 'raf' implicitly has an 'any' type.","category":1,"code":7005},{"start":43940,"length":6,"messageText":"Parameter 'active' implicitly has an 'any' type.","category":1,"code":7006}]],[1629,[{"start":515,"length":2,"messageText":"Parameter 'at' implicitly has an 'any' type.","category":1,"code":7006},{"start":530,"length":2,"code":2339,"category":1,"messageText":"Property 'op' does not exist on type 'Boundary'."},{"start":556,"length":2,"code":2339,"category":1,"messageText":"Property 'at' does not exist on type 'Boundary'."},{"start":574,"length":6,"code":2339,"category":1,"messageText":"Property 'target' does not exist on type 'Boundary'."},{"start":803,"length":9,"messageText":"Parameter 'direction' implicitly has an 'any' type.","category":1,"code":7006},{"start":825,"length":9,"code":2339,"category":1,"messageText":"Property 'direction' does not exist on type 'Ray'."},{"start":905,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":1338,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":1343,"length":8,"messageText":"Parameter 'isCenter' implicitly has an 'any' type.","category":1,"code":7006},{"start":1379,"length":7,"code":2339,"category":1,"messageText":"Property 'gridPos' does not exist on type 'GridNode'."},{"start":1432,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":1460,"length":3,"code":2339,"category":1,"messageText":"Property 'vel' does not exist on type 'GridNode'."},{"start":1493,"length":8,"code":2339,"category":1,"messageText":"Property 'isCenter' does not exist on type 'GridNode'."},{"start":1523,"length":8,"code":2339,"category":1,"messageText":"Property 'isPhoton' does not exist on type 'GridNode'."},{"start":1550,"length":6,"code":2339,"category":1,"messageText":"Property 'weight' does not exist on type 'GridNode'."},{"start":1618,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1696,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1803,"length":2,"messageText":"Parameter 'op' implicitly has an 'any' type.","category":1,"code":7006},{"start":1825,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1836,"length":3,"messageText":"Parameter 'ray' implicitly has an 'any' type.","category":1,"code":7006},{"start":2341,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":3176,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":3185,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":4185,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":4194,"length":5,"messageText":"Parameter 'scale' implicitly has an 'any' type.","category":1,"code":7006},{"start":4243,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":4370,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":5026,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":5119,"length":6,"messageText":"Parameter 'prefix' implicitly has an 'any[]' type.","category":1,"code":7006},{"start":5522,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":5563,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":5943,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":5987,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":6058,"length":1,"messageText":"Parameter 'c' implicitly has an 'any' type.","category":1,"code":7006},{"start":6127,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6452,"length":8,"code":2339,"category":1,"messageText":"Property 'isCenter' does not exist on type 'GridNode'."},{"start":6496,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6505,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":6622,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":6662,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":7099,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":7111,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":7114,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":7117,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":7142,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":7280,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":7348,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":7452,"length":13,"messageText":"Object literal's property 'freeQueue' implicitly has an 'any[]' type.","category":1,"code":7018},{"start":8443,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":8448,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":8457,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":8479,"length":1,"messageText":"Parameter 'c' implicitly has an 'any' type.","category":1,"code":7006},{"start":8640,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":9501,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":9519,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":9522,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":9823,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":9863,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":9945,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":10404,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":10515,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":10520,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":10606,"length":6,"messageText":"Parameter 'prefix' implicitly has an 'any[]' type.","category":1,"code":7006},{"start":12280,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":12285,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":12500,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":12568,"length":1,"messageText":"Parameter 'n' implicitly has an 'any' type.","category":1,"code":7006},{"start":12618,"length":1,"messageText":"Binding element 'a' implicitly has an 'any' type.","category":1,"code":7031},{"start":12621,"length":1,"messageText":"Binding element 'b' implicitly has an 'any' type.","category":1,"code":7031},{"start":13050,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":13055,"length":4,"messageText":"Parameter 'keep' implicitly has an 'any' type.","category":1,"code":7006},{"start":13061,"length":4,"messageText":"Parameter 'from' implicitly has an 'any' type.","category":1,"code":7006},{"start":13958,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":14155,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":14160,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":14165,"length":3,"messageText":"Parameter 'dir' implicitly has an 'any' type.","category":1,"code":7006},{"start":14254,"length":8,"code":2339,"category":1,"messageText":"Property 'isPhoton' does not exist on type 'GridNode'."},{"start":14313,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14351,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":14502,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":14507,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":14512,"length":3,"messageText":"Parameter 'dir' implicitly has an 'any' type.","category":1,"code":7006},{"start":14517,"length":8,"messageText":"Parameter 'reversed' implicitly has an 'any' type.","category":1,"code":7006},{"start":14674,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":14715,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14755,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14806,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14845,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14887,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":15043,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":15441,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":15446,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":15509,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15575,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":15580,"length":1,"messageText":"Parameter 'a' implicitly has an 'any' type.","category":1,"code":7006},{"start":15583,"length":1,"messageText":"Parameter 'b' implicitly has an 'any' type.","category":1,"code":7006},{"start":15845,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15848,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":15936,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15972,"length":2,"messageText":"Parameter 'n1' implicitly has an 'any' type.","category":1,"code":7006},{"start":15976,"length":2,"messageText":"Parameter 'n2' implicitly has an 'any' type.","category":1,"code":7006},{"start":15980,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":16004,"length":3,"messageText":"Parameter 'ray' implicitly has an 'any' type.","category":1,"code":7006},{"start":16073,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":16076,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16079,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":16137,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16241,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16244,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":16630,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":16635,"length":1,"messageText":"Parameter 'a' implicitly has an 'any' type.","category":1,"code":7006},{"start":16638,"length":1,"messageText":"Parameter 'b' implicitly has an 'any' type.","category":1,"code":7006},{"start":16757,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16760,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":16827,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16878,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":17793,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":17798,"length":8,"messageText":"Parameter 'attacker' implicitly has an 'any' type.","category":1,"code":7006},{"start":17808,"length":6,"messageText":"Parameter 'target' implicitly has an 'any' type.","category":1,"code":7006},{"start":18025,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":18028,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":18123,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":18357,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":18360,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":18363,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":29771,"length":4,"messageText":"Parameter 'dims' implicitly has an 'any' type.","category":1,"code":7006},{"start":29788,"length":9,"code":2339,"category":1,"messageText":"Property 'available' does not exist on type 'GPUPhysics'."},{"start":29816,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":29843,"length":10,"code":2339,"category":1,"messageText":"Property 'frameCount' does not exist on type 'GPUPhysics'."},{"start":29868,"length":4,"code":2339,"category":1,"messageText":"Property 'dims' does not exist on type 'GPUPhysics'."},{"start":29890,"length":16,"code":2339,"category":1,"messageText":"Property 'gridCapacityRing' does not exist on type 'GPUPhysics'."},{"start":29921,"length":12,"code":2339,"category":1,"messageText":"Property 'poolCapacity' does not exist on type 'GPUPhysics'."},{"start":29948,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":30467,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":30561,"length":19,"code":2339,"category":1,"messageText":"Property 'usedOffscreenCanvas' does not exist on type 'GPUPhysics'."},{"start":30619,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'getExtension' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'getExtension' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":30690,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":30785,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":30805,"length":6,"code":2339,"category":1,"messageText":"Property 'canvas' does not exist on type 'GPUPhysics'."},{"start":30834,"length":11,"code":2339,"category":1,"messageText":"Property 'gridProgram' does not exist on type 'GPUPhysics'."},{"start":30929,"length":11,"code":2339,"category":1,"messageText":"Property 'gridProgram' does not exist on type 'GPUPhysics'."},{"start":30957,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":30974,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":31057,"length":11,"code":2339,"category":1,"messageText":"Property 'freeProgram' does not exist on type 'GPUPhysics'."},{"start":31147,"length":11,"code":2339,"category":1,"messageText":"Property 'freeProgram' does not exist on type 'GPUPhysics'."},{"start":31175,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":31192,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":31292,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'createBuffer' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'createBuffer' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31317,"length":10,"code":2339,"category":1,"messageText":{"messageText":"Property 'bindBuffer' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'bindBuffer' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31331,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'ARRAY_BUFFER' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'ARRAY_BUFFER' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31361,"length":10,"code":2339,"category":1,"messageText":{"messageText":"Property 'bufferData' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'bufferData' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31375,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'ARRAY_BUFFER' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'ARRAY_BUFFER' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31440,"length":11,"code":2339,"category":1,"messageText":{"messageText":"Property 'STATIC_DRAW' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'STATIC_DRAW' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31465,"length":4,"code":2339,"category":1,"messageText":"Property 'quad' does not exist on type 'GPUPhysics'."},{"start":31490,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":31694,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":31718,"length":18,"code":2339,"category":1,"messageText":{"messageText":"Property 'getUniformLocation' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'getUniformLocation' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31742,"length":11,"code":2339,"category":1,"messageText":"Property 'gridProgram' does not exist on type 'GPUPhysics'."},{"start":31781,"length":8,"code":2339,"category":1,"messageText":"Property 'gridAPos' does not exist on type 'GPUPhysics'."},{"start":31795,"length":17,"code":2339,"category":1,"messageText":{"messageText":"Property 'getAttribLocation' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'getAttribLocation' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31818,"length":11,"code":2339,"category":1,"messageText":"Property 'gridProgram' does not exist on type 'GPUPhysics'."},{"start":31852,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":32015,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":32039,"length":18,"code":2339,"category":1,"messageText":{"messageText":"Property 'getUniformLocation' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'getUniformLocation' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":32063,"length":11,"code":2339,"category":1,"messageText":"Property 'freeProgram' does not exist on type 'GPUPhysics'."},{"start":32102,"length":8,"code":2339,"category":1,"messageText":"Property 'freeAPos' does not exist on type 'GPUPhysics'."},{"start":32116,"length":17,"code":2339,"category":1,"messageText":{"messageText":"Property 'getAttribLocation' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'getAttribLocation' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":32139,"length":11,"code":2339,"category":1,"messageText":"Property 'freeProgram' does not exist on type 'GPUPhysics'."},{"start":32173,"length":4,"code":2339,"category":1,"messageText":"Property '_fbo' does not exist on type 'GPUPhysics'."},{"start":32183,"length":17,"code":2339,"category":1,"messageText":{"messageText":"Property 'createFramebuffer' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'createFramebuffer' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":32215,"length":9,"code":2339,"category":1,"messageText":"Property 'available' does not exist on type 'GPUPhysics'."},{"start":32262,"length":9,"code":2339,"category":1,"messageText":"Property 'available' does not exist on type 'GPUPhysics'."},{"start":32292,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":32340,"length":7,"code":2339,"category":1,"messageText":"Property 'message' does not exist on type 'unknown'."},{"start":32352,"length":7,"code":2339,"category":1,"messageText":"Property 'message' does not exist on type 'unknown'."},{"start":32401,"length":2,"messageText":"Parameter 'gl' implicitly has an 'any' type.","category":1,"code":7006},{"start":32405,"length":5,"messageText":"Parameter 'vsSrc' implicitly has an 'any' type.","category":1,"code":7006},{"start":32412,"length":5,"messageText":"Parameter 'fsSrc' implicitly has an 'any' type.","category":1,"code":7006},{"start":32442,"length":4,"messageText":"Parameter 'type' implicitly has an 'any' type.","category":1,"code":7006},{"start":32448,"length":3,"messageText":"Parameter 'src' implicitly has an 'any' type.","category":1,"code":7006},{"start":32741,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":33302,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":33407,"length":2,"messageText":"Parameter 'gl' implicitly has an 'any' type.","category":1,"code":7006},{"start":33411,"length":1,"messageText":"Parameter 'w' implicitly has an 'any' type.","category":1,"code":7006},{"start":33414,"length":1,"messageText":"Parameter 'h' implicitly has an 'any' type.","category":1,"code":7006},{"start":34055,"length":10,"messageText":"Parameter 'ringRadius' implicitly has an 'any' type.","category":1,"code":7006},{"start":34067,"length":4,"messageText":"Parameter 'dims' implicitly has an 'any' type.","category":1,"code":7006},{"start":34102,"length":16,"code":2339,"category":1,"messageText":"Property 'gridCapacityRing' does not exist on type 'GPUPhysics'."},{"start":34127,"length":9,"code":2339,"category":1,"messageText":"Property 'sliceSize' does not exist on type 'GPUPhysics'."},{"start":34166,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":34229,"length":16,"code":2339,"category":1,"messageText":"Property 'gridCapacityRing' does not exist on type 'GPUPhysics'."},{"start":34299,"length":9,"code":2339,"category":1,"messageText":"Property 'sliceSize' does not exist on type 'GPUPhysics'."},{"start":34331,"length":10,"code":2339,"category":1,"messageText":"Property 'gridOffset' does not exist on type 'GPUPhysics'."},{"start":34456,"length":6,"code":2339,"category":1,"messageText":"Property 'atlasW' does not exist on type 'GPUPhysics'."},{"start":34482,"length":6,"code":2339,"category":1,"messageText":"Property 'atlasH' does not exist on type 'GPUPhysics'."},{"start":34605,"length":19,"code":7053,"category":1,"messageText":{"messageText":"Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'GPUPhysics'.","category":1,"code":7053,"next":[{"messageText":"No index signature with a parameter of type 'string' was found on type 'GPUPhysics'.","category":1,"code":7054}]}},{"start":34679,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridPos' does not exist on type 'GPUPhysics'."},{"start":34742,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridPos2' does not exist on type 'GPUPhysics'."},{"start":34806,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridVel' does not exist on type 'GPUPhysics'."},{"start":34869,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridVel2' does not exist on type 'GPUPhysics'."},{"start":34933,"length":16,"code":2339,"category":1,"messageText":"Property '_tex_gridRewired' does not exist on type 'GPUPhysics'."},{"start":35001,"length":8,"code":2339,"category":1,"messageText":"Property '_gridBuf' does not exist on type 'GPUPhysics'."},{"start":35454,"length":1,"messageText":"Parameter 'n' implicitly has an 'any' type.","category":1,"code":7006},{"start":35477,"length":12,"code":2339,"category":1,"messageText":"Property 'poolCapacity' does not exist on type 'GPUPhysics'."},{"start":35498,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexW' does not exist on type 'GPUPhysics'."},{"start":35536,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":35666,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexW' does not exist on type 'GPUPhysics'."},{"start":35692,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexH' does not exist on type 'GPUPhysics'."},{"start":35718,"length":12,"code":2339,"category":1,"messageText":"Property 'poolCapacity' does not exist on type 'GPUPhysics'."},{"start":35759,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":35775,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":35797,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":35818,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":35874,"length":8,"code":2339,"category":1,"messageText":"Property '_poolBuf' does not exist on type 'GPUPhysics'."},{"start":35907,"length":12,"code":2339,"category":1,"messageText":"Property 'poolCapacity' does not exist on type 'GPUPhysics'."},{"start":36140,"length":1,"messageText":"Parameter 'n' implicitly has an 'any' type.","category":1,"code":7006},{"start":36163,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":36184,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":36222,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":36377,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":36403,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":36429,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":36579,"length":19,"code":7053,"category":1,"messageText":{"messageText":"Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'GPUPhysics'.","category":1,"code":7053,"next":[{"messageText":"No index signature with a parameter of type 'string' was found on type 'GPUPhysics'.","category":1,"code":7054}]}},{"start":36653,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freePos' does not exist on type 'GPUPhysics'."},{"start":36712,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freePos2' does not exist on type 'GPUPhysics'."},{"start":36772,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freeVel' does not exist on type 'GPUPhysics'."},{"start":36831,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freeVel2' does not exist on type 'GPUPhysics'."},{"start":36891,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredA' does not exist on type 'GPUPhysics'."},{"start":36955,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredB' does not exist on type 'GPUPhysics'."},{"start":37019,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":37065,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37117,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37168,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37219,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37274,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37329,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37369,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":37374,"length":2,"messageText":"Parameter 'dt' implicitly has an 'any' type.","category":1,"code":7006},{"start":37378,"length":4,"messageText":"Parameter 'dims' implicitly has an 'any' type.","category":1,"code":7006},{"start":37529,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":37870,"length":9,"code":2339,"category":1,"messageText":"Property 'sliceSize' does not exist on type 'GPUPhysics'."},{"start":37895,"length":10,"code":2339,"category":1,"messageText":"Property 'gridOffset' does not exist on type 'GPUPhysics'."},{"start":37921,"length":6,"code":2339,"category":1,"messageText":"Property 'atlasW' does not exist on type 'GPUPhysics'."},{"start":37943,"length":6,"code":2339,"category":1,"messageText":"Property 'atlasH' does not exist on type 'GPUPhysics'."},{"start":37973,"length":8,"code":2339,"category":1,"messageText":"Property '_gridBuf' does not exist on type 'GPUPhysics'."},{"start":38008,"length":8,"code":2339,"category":1,"messageText":"Property '_poolBuf' does not exist on type 'GPUPhysics'."},{"start":38158,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":39898,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":42175,"length":3,"messageText":"Parameter 'tex' implicitly has an 'any' type.","category":1,"code":7006},{"start":42180,"length":1,"messageText":"Parameter 'w' implicitly has an 'any' type.","category":1,"code":7006},{"start":42183,"length":1,"messageText":"Parameter 'h' implicitly has an 'any' type.","category":1,"code":7006},{"start":42186,"length":4,"messageText":"Parameter 'data' implicitly has an 'any' type.","category":1,"code":7006},{"start":42343,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridPos' does not exist on type 'GPUPhysics'."},{"start":42402,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridVel' does not exist on type 'GPUPhysics'."},{"start":42461,"length":16,"code":2339,"category":1,"messageText":"Property '_tex_gridRewired' does not exist on type 'GPUPhysics'."},{"start":42528,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":42544,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexW' does not exist on type 'GPUPhysics'."},{"start":42559,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexH' does not exist on type 'GPUPhysics'."},{"start":42597,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freePos' does not exist on type 'GPUPhysics'."},{"start":42616,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":42631,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":42673,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freeVel' does not exist on type 'GPUPhysics'."},{"start":42692,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":42707,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":42749,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredA' does not exist on type 'GPUPhysics'."},{"start":42773,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":42788,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":42829,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredB' does not exist on type 'GPUPhysics'."},{"start":42853,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":42868,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":43038,"length":4,"code":2339,"category":1,"messageText":"Property '_fbo' does not exist on type 'GPUPhysics'."},{"start":43131,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridPos2' does not exist on type 'GPUPhysics'."},{"start":43236,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridVel2' does not exist on type 'GPUPhysics'."},{"start":43413,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":43564,"length":11,"code":2339,"category":1,"messageText":"Property 'gridProgram' does not exist on type 'GPUPhysics'."},{"start":43618,"length":4,"code":2339,"category":1,"messageText":"Property 'quad' does not exist on type 'GPUPhysics'."},{"start":43661,"length":8,"code":2339,"category":1,"messageText":"Property 'gridAPos' does not exist on type 'GPUPhysics'."},{"start":43704,"length":8,"code":2339,"category":1,"messageText":"Property 'gridAPos' does not exist on type 'GPUPhysics'."},{"start":43763,"length":4,"messageText":"Parameter 'unit' implicitly has an 'any' type.","category":1,"code":7006},{"start":43769,"length":3,"messageText":"Parameter 'tex' implicitly has an 'any' type.","category":1,"code":7006},{"start":43774,"length":7,"messageText":"Parameter 'uniform' implicitly has an 'any' type.","category":1,"code":7006},{"start":43898,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":43956,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridPos' does not exist on type 'GPUPhysics'."},{"start":44004,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridVel' does not exist on type 'GPUPhysics'."},{"start":44052,"length":16,"code":2339,"category":1,"messageText":"Property '_tex_gridRewired' does not exist on type 'GPUPhysics'."},{"start":44108,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":44154,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44215,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44260,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44335,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44384,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44437,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44496,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44553,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44585,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexW' does not exist on type 'GPUPhysics'."},{"start":44600,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexH' does not exist on type 'GPUPhysics'."},{"start":44790,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":44805,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":44904,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freePos2' does not exist on type 'GPUPhysics'."},{"start":45011,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freeVel2' does not exist on type 'GPUPhysics'."},{"start":45194,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":45351,"length":11,"code":2339,"category":1,"messageText":"Property 'freeProgram' does not exist on type 'GPUPhysics'."},{"start":45407,"length":4,"code":2339,"category":1,"messageText":"Property 'quad' does not exist on type 'GPUPhysics'."},{"start":45452,"length":8,"code":2339,"category":1,"messageText":"Property 'freeAPos' does not exist on type 'GPUPhysics'."},{"start":45497,"length":8,"code":2339,"category":1,"messageText":"Property 'freeAPos' does not exist on type 'GPUPhysics'."},{"start":45558,"length":4,"messageText":"Parameter 'unit' implicitly has an 'any' type.","category":1,"code":7006},{"start":45564,"length":3,"messageText":"Parameter 'tex' implicitly has an 'any' type.","category":1,"code":7006},{"start":45569,"length":7,"messageText":"Parameter 'uniform' implicitly has an 'any' type.","category":1,"code":7006},{"start":45699,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":45761,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freePos' does not exist on type 'GPUPhysics'."},{"start":45811,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freeVel' does not exist on type 'GPUPhysics'."},{"start":45861,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredA' does not exist on type 'GPUPhysics'."},{"start":45921,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredB' does not exist on type 'GPUPhysics'."},{"start":45981,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":46029,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":46076,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":46127,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":46159,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexW' does not exist on type 'GPUPhysics'."},{"start":46174,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexH' does not exist on type 'GPUPhysics'."},{"start":46318,"length":4,"code":2339,"category":1,"messageText":"Property '_fbo' does not exist on type 'GPUPhysics'."},{"start":46411,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridPos2' does not exist on type 'GPUPhysics'."},{"start":46516,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridVel2' does not exist on type 'GPUPhysics'."},{"start":46950,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freePos2' does not exist on type 'GPUPhysics'."},{"start":47057,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freeVel2' does not exist on type 'GPUPhysics'."},{"start":47218,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":47233,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":47267,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":47359,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":47374,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":47408,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":48201,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":48365,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":48471,"length":10,"code":2339,"category":1,"messageText":"Property 'frameCount' does not exist on type 'GPUPhysics'."},{"start":48494,"length":10,"code":2339,"category":1,"messageText":"Property 'lastTiming' does not exist on type 'GPUPhysics'."},{"start":48660,"length":4,"code":2339,"category":1,"messageText":"Property 'texW' does not exist on type 'GPUPhysics'."},{"start":48729,"length":4,"code":2339,"category":1,"messageText":"Property 'texH' does not exist on type 'GPUPhysics'."},{"start":48782,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":48787,"length":2,"messageText":"Parameter 'dt' implicitly has an 'any' type.","category":1,"code":7006},{"start":48791,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":56569,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":56626,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":56629,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":57058,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":57063,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":57068,"length":3,"messageText":"Parameter 'rot' implicitly has an 'any' type.","category":1,"code":7006},{"start":57073,"length":4,"messageText":"Parameter 'tilt' implicitly has an 'any' type.","category":1,"code":7006},{"start":57079,"length":7,"messageText":"Parameter 'camDist' implicitly has an 'any' type.","category":1,"code":7006},{"start":58066,"length":3,"messageText":"Parameter 'ctx' implicitly has an 'any' type.","category":1,"code":7006},{"start":58071,"length":6,"messageText":"Parameter 'canvas' implicitly has an 'any' type.","category":1,"code":7006},{"start":58079,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":58084,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":58089,"length":3,"messageText":"Parameter 'cam' implicitly has an 'any' type.","category":1,"code":7006},{"start":58094,"length":2,"messageText":"Parameter 'dt' implicitly has an 'any' type.","category":1,"code":7006},{"start":58098,"length":13,"messageText":"Parameter 'showGridLines' implicitly has an 'any' type.","category":1,"code":7006},{"start":61267,"length":1,"messageText":"Parameter 'p' implicitly has an 'any' type.","category":1,"code":7006},{"start":62713,"length":7,"messageText":"Variable 'sources' implicitly has type 'any[]' in some locations where its type cannot be determined.","category":1,"code":7034},{"start":64113,"length":1,"messageText":"Parameter 't' implicitly has an 'any' type.","category":1,"code":7006},{"start":64116,"length":5,"messageText":"Parameter 'alpha' implicitly has an 'any' type.","category":1,"code":7006},{"start":64619,"length":7,"messageText":"Variable 'samples' implicitly has type 'any[]' in some locations where its type cannot be determined.","category":1,"code":7034},{"start":64712,"length":4,"messageText":"Parameter 'axis' implicitly has an 'any' type.","category":1,"code":7006},{"start":65371,"length":7,"messageText":"Variable 'sources' implicitly has an 'any[]' type.","category":1,"code":7005},{"start":66139,"length":7,"messageText":"Variable 'samples' implicitly has an 'any[]' type.","category":1,"code":7005},{"start":68310,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":68313,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":69711,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":69770,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":69773,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":72522,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":73102,"length":3,"messageText":"Variable 'raf' implicitly has type 'any' in some locations where its type cannot be determined.","category":1,"code":7034},{"start":73865,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":74996,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":75174,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":75317,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":75626,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":75862,"length":3,"messageText":"Parameter 'now' implicitly has an 'any' type.","category":1,"code":7006},{"start":76557,"length":7,"code":2339,"category":1,"messageText":"Property 'stepRaw' does not exist on type '{ step: any; draw: any; }'."},{"start":78193,"length":7,"code":2339,"category":1,"messageText":"Property 'stepRaw' does not exist on type '{ step: any; draw: any; }'."},{"start":78895,"length":3,"messageText":"Variable 'raf' implicitly has an 'any' type.","category":1,"code":7005},{"start":79311,"length":6,"messageText":"Parameter 'active' implicitly has an 'any' type.","category":1,"code":7006}]],[1635,[{"start":307,"length":15,"messageText":"'ProfileRedirect', which lacks return-type annotation, implicitly has an 'any' return type.","category":1,"code":7010}]],[1644,[{"start":197,"length":14,"messageText":"'PapersRedirect', which lacks return-type annotation, implicitly has an 'any' return type.","category":1,"code":7010}]]],"affectedFilesPendingEmit":[1652,1650,1638,1642,1643,1631,1632,1633,1634,1639,1640,1641,1644,1645,1635,1636,1637,1646,1647,560,565,566,562,563,564,561,572,569,570,573,571,568,555,556,577,575,576,574,578,567,581,582,580,579,1578,1579,1584,1583,1580,1581,1582,584,585,583,586,1587,1588,1590,1593,1591,1589,1592,1586,588,1585,587,1595,1596,1597,1594,1598,1599,1600,589,591,1601,1603,1604,1602,1605,1606,596,1607,1611,1608,1613,1612,593,592,595,597,594,1610,1614,600,599,601,598,1618,1615,602,590,558,606,603,605,604,607,1616,621,1576,1575,635,622,627,624,629,630,633,626,631,632,628,625,623,634,638,1573,1619,1574,637,636,1577,557,1620,1627,1621,1617,1623,1557,1622,1624,1625,1626,1628,1629,1630,1609,641,642,645],"version":"5.9.3"}
\ No newline at end of file

From 97403bc187be0c15d76f7421958c08fc5037338b Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Tue, 4 Aug 2026 17:58:49 +0200
Subject: [PATCH 04/47] First working toy model of XOR space

---
 .../archive/2026.RayCalculiAndPhysics.tsx     | 1586 ++++++++++++++---
 1 file changed, 1300 insertions(+), 286 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index 71c80f2..86c0a4d 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -14,15 +14,26 @@ import Post, {
   Arc,
   Block
 } from "../../lib/post/Post";
-import { useEffect, useRef, useState } from "react";
+import { Fragment, useEffect, useMemo, useRef, useState } from "react";
 import { Button } from "@blueprintjs/core";
 
 // A boundary now carries a polarity instead of an annihilation/creation op.
+// Neutral is what space is when nothing has happened to it yet: it is what
+// gets instantiated as something moves — ahead of it at a boundary of the
+// structure, and behind it as it goes — rather than a charge drawn at random.
 enum Polarity {
   Positive,
-  Negative
+  Negative,
+  Neutral
 }
 
+// One end of a two-point universe: the polarity of its boundaries, and
+// whether its ray moves into the connection or away from it.
+type PairSide = {
+  polarity: Polarity;
+  moving: 'towards' | 'away';
+};
+
 class Universe {
   static _2D = () => Universe.nD_Expanding(2);
   static _3D = () => Universe.nD_Expanding(3);
@@ -36,8 +47,40 @@ class Universe {
   static randomPolarity() {
     return Math.random() < 0.5 ? Polarity.Positive : Polarity.Negative;
   }
+
+  // A fresh order, so that what interacts with what is a draw rather than an
+  // artefact of the order things happen to sit in.
+  static shuffle<T>(arr: T[]): T[] {
+    const out = arr.slice();
+
+    for (let i = out.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [out[i], out[j]] = [out[j], out[i]];
+    }
+
+    return out;
+  }
 }
 
+// Two rays meeting head-on, over the connection whose mutual boundaries are
+// `a` and `b`. Opposite charges cancel; like ones turn around. Movement isn't
+// here because it isn't an interaction: it is what a ray does when nothing is
+// coming the other way.
+type Interaction = {
+  kind: 'annihilate' | 'turn';
+  r: Ray; a: Boundary;
+  r2: Ray; b: Boundary;
+};
+
+// World units per lattice step. Shared by the layout and by the renderer,
+// which needs it to place boundaries that have a direction but no neighbour.
+const LATTICE_STEP = 50;
+
+// How far along its connection a boundary is drawn, as a fraction. Both ends
+// draw one, so they meet with a gap of 1 - 2×this in between. The viewport
+// fit uses it too, so that what it measures is what gets drawn.
+const BOUNDARY_STUB = 0.25;
+
 function stepAway(from: number[], to: number[]): number[] {
   return from.map((v, i) =>
     v + Math.sign(to[i] - v)
@@ -102,152 +145,617 @@ class Graph {
         boundary.target = target;
   }
 
-  // A ray "turns around" to one of its OTHER boundaries (superposed — one
-  // chosen at random for now). Returns the current one if there's nothing
-  // else to turn to.
-  private otherBoundary(ray: Ray, exclude: Boundary): Boundary {
-    const others = ray.boundaries.filter(b => b !== exclude);
-    if (!others.length) return exclude;
-    return others[Math.floor(Math.random() * others.length)];
+  // Which way a boundary points, as a unit vector in grid space. A bare
+  // direction says so itself; a connection is the step from the point it is
+  // on to the point on the other side.
+  private direction(bd: Boundary): number[] | undefined {
+    if (bd.outward) {
+      const length = Math.hypot(...bd.outward);
+      return length ? bd.outward.map(v => v / length) : undefined;
+    }
+
+    const from = this.gridPos.get(bd.at.node);
+    const to = bd.target && this.gridPos.get(bd.target.at.node);
+    if (!from || !to) return undefined;
+
+    const step = to.map((v, i) => v - from[i]);
+    const length = Math.hypot(...step);
+
+    return length ? step.map(v => v / length) : undefined;
+  }
+
+  // The boundary of `ray` pointing most nearly along `dir` (`sign` of -1 for
+  // most nearly opposite). Movement is conserved rather than reselected, so
+  // whenever a ray has to change which boundary it moves along, it does the
+  // thing closest to carrying straight on — or, turning around, closest to
+  // coming straight back.
+  private along(ray: Ray, dir: number[] | undefined, sign: 1 | -1, exclude?: Boundary): Boundary | undefined {
+    const options = ray.boundaries.filter(b => b !== exclude);
+    if (!options.length) return undefined;
+    if (!dir) return options[0];
+
+    let best: Boundary | undefined;
+    let bestDot = -Infinity;
+
+    for (const option of options) {
+      const d = this.direction(option);
+      if (!d) continue;
+
+      const dot = sign * d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
+      if (dot > bestDot) { bestDot = dot; best = option; }
+    }
+
+    return best ?? options[0];
+  }
+
+  /**
+   * Which way is behind us: the boundary pointing most nearly opposite to the
+   * one we are moving along. Only a genuinely backward direction counts — a
+   * perpendicular one is beside us, not behind us — so a ray with nothing
+   * behind it gets `undefined` and the space it sheds into has to be made.
+   */
+  private behind(ray: Ray, dir: number[] | undefined, exclude: Boundary): Boundary | undefined {
+    if (!dir) return undefined;
+
+    let best: Boundary | undefined;
+    let bestDot = 0.1; // has to actually point back, not sideways
+
+    for (const option of ray.boundaries) {
+      if (option === exclude) continue;
+
+      const d = this.direction(option);
+      if (!d) continue;
+
+      const dot = -d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
+      if (dot > bestDot) { bestDot = dot; best = option; }
+    }
+
+    return best;
+  }
+
+  // The point sitting at a grid position, if there is one. Positions are
+  // real-valued (space instantiated between two points lands at their
+  // midpoint), so this is a tolerance match rather than a key lookup.
+  private nodeAt(pos: number[]): node | undefined {
+    for (const [nd, p] of this.gridPos)
+      if (p.length === pos.length && p.every((v, i) => Math.abs(v - pos[i]) < 1e-6))
+        return nd;
+
+    return undefined;
+  }
+
+  /**
+   * The directions of a point that lie ACROSS the way we are going.
+   *
+   * The axis we are travelling on never changes hands: it is the thing being
+   * travelled, and taking it would tear the line we are moving along in two.
+   * Everything else is what a point IS as opposed to where it is, and it is
+   * exactly what gets handed over as something moves through.
+   */
+  private transverse(rays: Ray[], dir: number[] | undefined, exclude?: Boundary): Boundary[] {
+    if (!dir) return [];
+
+    const out: Boundary[] = [];
+
+    for (const ray of rays) {
+      for (const bd of ray.boundaries) {
+        if (bd === exclude) continue;
+
+        const d = this.direction(bd);
+        if (!d) continue;
+
+        const along = Math.abs(d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0));
+        if (along < 0.9) out.push(bd);
+      }
+    }
+
+    return out;
+  }
+
+  // The same directions, held by somewhere else now.
+  private hand(taken: Boundary[], onto: Ray) {
+    for (const bd of taken) {
+      bd.at.boundaries = bd.at.boundaries.filter(x => x !== bd);
+      bd.at = onto;
+      onto.boundaries.push(bd);
+    }
+  }
+
+  /**
+   * Two opposite charges meeting head-on: they cancel, and the space they
+   * were goes with them.
+   *
+   * Not by being destroyed — space is never destroyed here, it is handed
+   * backwards. Everything each of them held across the line they met on goes
+   * to the point behind it, the two of them are spliced out of that line, and
+   * what was behind them closes up directly onto what was behind the other.
+   * Nothing comes apart: there is simply less space than there was, and what
+   * that space was carrying is still carried.
+   *
+   * With nothing behind either of them there is nowhere backwards to hand
+   * anything to, so the two collapse onto each other instead — one neutral
+   * point left holding everything both of them held. A row of charges
+   * annihilating pair by pair therefore ends as exactly that one point.
+   */
+  private annihilate(r: Ray, a: Boundary, r2: Ray, b: Boundary, removed: Set<node>) {
+    const dirA = this.direction(a), dirB = this.direction(b);
+
+    const backA = this.behind(r, dirA, a), backB = this.behind(r2, dirB, b);
+    const homeA = backA?.target?.at, homeB = backB?.target?.at;
+
+    if (homeA || homeB) {
+      // Each side's space goes to whatever is behind it — or, for a side with
+      // nothing behind it, to the other's, that being the only way left.
+      this.hand(this.transverse([r], dirA, backA), homeA ?? homeB!);
+      this.hand(this.transverse([r2], dirB, backB), homeB ?? homeA!);
+
+      // The line closes up: what was behind one is now directly onto what was
+      // behind the other.
+      const pa = backA?.target, pb = backB?.target;
+
+      if (pa && pb) {
+        pa.target = pb;
+        pb.target = pa;
+      } else for (const p of [pa, pb]) {
+        if (!p) continue;
+
+        // Nothing on the far side to close onto, so the direction is all that
+        // is left of what used to be there.
+        const d = this.direction(p);
+        p.target = undefined;
+        p.outward = d;
+      }
+
+      this.discard(r, homeA ?? homeB!, removed);
+      this.discard(r2, homeB ?? homeA!, removed);
+
+      return;
+    }
+
+    // Nowhere behind either of them: everything the two were carrying ends up
+    // on one point, which is all that is left of both.
+    this.hand(this.transverse([r2], dirB, backB), r);
+
+    r.boundaries = r.boundaries.filter(x => x !== a);
+    this.discard(r2, r, removed);
+
+    r.moving = undefined;
+    for (const bd of r.boundaries) bd.polarity = Polarity.Neutral;
+  }
+
+  /**
+   * A point that is no longer anywhere.
+   *
+   * Whatever it was carrying has already gone wherever it was going; this is
+   * only the removal. Anything still pointing at it is left holding the bare
+   * direction — the way is still that way, there is just nothing there — and
+   * anything still sitting on it goes wherever its structure went.
+   */
+  private discard(ray: Ray, onto: Ray, removed: Set<node>) {
+    const nd = ray.node;
+
+    for (const bd of ray.boundaries) {
+      const partner = bd.target;
+
+      // Only if it is still pointing back at us: a connection that has
+      // already been closed up onto something else is not ours to break.
+      if (!partner || partner.target !== bd) continue;
+
+      const d = this.direction(partner);
+      partner.target = undefined;
+      partner.outward = d;
+    }
+
+    ray.boundaries = [];
+
+    for (const other of [...nd]) {
+      if (other === ray) continue;
+
+      other.node = onto.node;
+      onto.node.push(other);
+    }
+
+    nd.length = 0;
+
+    this.gridPos.delete(nd);
+    this.nodes = this.nodes.filter(n => n !== nd);
+    removed.add(nd);
+  }
+
+  /**
+   * Two like charges meeting head-on: neither cancels the other and neither
+   * can move through the other, so each simply turns itself around.
+   *
+   * Movement is conserved rather than reselected — it comes back the way it
+   * came instead of setting off somewhere new — and if there is no way back
+   * yet then the way back is something it has to have, so it gets one.
+   */
+  private turnAround(ray: Ray, a: Boundary) {
+    const dir = this.direction(a);
+
+    let back = this.behind(ray, dir, a);
+
+    if (!back) {
+      back = new Boundary(ray, this);
+      back.polarity = a.polarity;
+      if (dir) back.outward = dir.map(v => -v);
+      ray.boundaries.push(back);
+    }
+
+    ray.moving = back;
+  }
+
+  /**
+   * Whether there is anywhere to go.
+   *
+   * Space can be moved through. So can a point that is itself moving out of
+   * our way, because by the time we get there it will have put down the space
+   * it left behind, and that space is what we move through. Anything else is
+   * in the way — including something on its way somewhere that is itself
+   * blocked, which is why this is asked of a whole queue at once rather than
+   * of one point in isolation.
+   */
+  private canMove(ray: Ray, a: Boundary, blocked: Set<Ray>): boolean {
+    if (!a.target) return true; // an actual boundary of the structure: we make our own way
+
+    const dir = this.direction(a);
+
+    for (const other of a.target.at.node) {
+      if (!other.moving) continue; // space: ours to move through
+
+      const d = this.direction(other.moving);
+      if (!d || !dir) return false;
+
+      // Not leaving the way we are going, so it is in the way.
+      if (d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0) < 0.9) return false;
+
+      // Leaving, but blocked itself, so it isn't leaving after all.
+      if (blocked.has(other)) return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * The space something leaves behind it.
+   *
+   * We never move ourselves — a point is what "where" is made of, and has
+   * nowhere to go. What moves is space: a fresh point is put behind us,
+   * spliced in between us and whatever was already back there, and everything
+   * we were carrying across our direction of travel is handed to it. It is
+   * neutral and has no direction of its own; nothing has happened to it yet,
+   * and giving it a charge at random would be an event this model didn't
+   * have.
+   */
+  private emitBehind(ray: Ray, a: Boundary, vacated: Map<node, number[]>) {
+    const dir = this.direction(a);
+    const here = this.gridPos.get(ray.node);
+
+    let back = this.behind(ray, dir, a);
+    const was = back?.target;
+    const there = was && this.gridPos.get(was.at.node);
+
+    const nd: node = [];
+    const fresh = new Ray(nd, this);
+    fresh.boundaries = []; // drop the constructor's default
+
+    const facing = new Boundary(fresh, this);
+    facing.polarity = Polarity.Neutral;
+    fresh.boundaries.push(facing);
+
+    // Nothing behind us at all, not even a bare direction, so the way back is
+    // itself something we have to have.
+    if (!back) {
+      back = new Boundary(ray, this);
+      back.polarity = Polarity.Neutral;
+      ray.boundaries.push(back);
+    }
+
+    back.outward = undefined;
+    back.target = facing;
+    facing.target = back;
+
+    // Whatever was behind us is behind the point we just put there.
+    const onward = new Boundary(fresh, this);
+    onward.polarity = Polarity.Neutral;
+
+    if (was) { onward.target = was; was.target = onward; }
+    else if (dir) onward.outward = dir.map(v => -v);
+
+    fresh.boundaries.push(onward);
+
+    this.nodes.push(nd);
+
+    // Where it ends up is where we are: we are about to be one step further
+    // on, and this is what we will have left at the place we were. It can't
+    // be put there yet, though — until we have actually gone, that place is
+    // still occupied by us, and two points sharing one position have no
+    // direction between them for anything else to read. So it waits between
+    // us and what is behind us, and is put down properly once the moving is
+    // over.
+    this.gridPos.set(nd, !here ? []
+      : there ? here.map((v, i) => (v + there[i]) / 2)
+        : dir ? here.map((v, i) => v - dir[i])
+          : here.slice());
+
+    if (here) vacated.set(nd, here.slice());
+
+    this.hand(this.transverse([ray], dir, back), fresh);
   }
 
-  // Annihilate a single connection (the mutual boundaries a↔b) and MERGE the
-  // two nodes into one, keeping every other connection (spatial direction) of
-  // both. Only this one link is destroyed. The `removed` set records nodes
-  // that were merged away so the tick loop skips them.
-  private mergeConnection(rA: Ray, a: Boundary, rB: Ray, b: Boundary, removed: Set<node>) {
-    const A = rA.node, B = rB.node;
-
-    // Destroy just this connection.
-    rA.boundaries = rA.boundaries.filter(x => x !== a);
-    rB.boundaries = rB.boundaries.filter(x => x !== b);
-    if (rA.moving === a) rA.moving = rA.boundaries.length ? rA.boundaries[Math.floor(Math.random() * rA.boundaries.length)] : undefined;
-    if (rB.moving === b) rB.moving = rB.boundaries.length ? rB.boundaries[Math.floor(Math.random() * rB.boundaries.length)] : undefined;
-
-    if (A === B) return; // already the same node — the connection was internal
-
-    // Merge B's rays into A (every remaining boundary comes along; their
-    // targets still point at the same Boundary objects, now reachable via A).
-    for (const ray of B) {
-      ray.node = A;
-      A.push(ray);
+  /**
+   * Moving through the space in front of us: it comes onto us, and stops
+   * being anywhere.
+   *
+   * This is the half of movement that makes it movement rather than drift.
+   * Its structure becomes ours, its place becomes our place, and the
+   * connection we came in on is rewired straight through to whatever lay
+   * beyond it, so nothing comes apart. One point is consumed here for the one
+   * emitted behind, so space is conserved: a thing moving is a thing swapping
+   * places with the space in front of it while everything else stays where it
+   * was.
+   *
+   * Only space is ever consumed. Anything with a direction of its own is
+   * somebody rather than somewhere.
+   */
+  private consumeAhead(ray: Ray, a: Boundary, removed: Set<node>, vacated: Map<node, number[]>) {
+    // Nothing in front of us at all: we assume we can go that way anyway, and
+    // make what we are moving into.
+    if (!a.target) this.grow(ray, a);
+
+    const ahead = a.target;
+    if (!ahead) return;
+
+    const nd = ahead.at.node;
+    if (nd === ray.node || removed.has(nd)) return;
+
+    for (const other of nd)
+      if (other.moving) return;
+
+    const dir = this.direction(a);
+
+    // Where it is going to be, which is not yet where it is if it is space
+    // something else has just put down on its way out.
+    const there = vacated.get(nd) ?? this.gridPos.get(nd);
+
+    // What lies beyond it the way we are going — carrying on, rather than
+    // across. Our own direction of travel is rewired onto that, so the line
+    // we are moving along stays a line.
+    let onward: Boundary | undefined;
+    let onwardDir: number[] | undefined;
+
+    for (const other of nd) {
+      for (const bd of other.boundaries) {
+        if (bd === ahead) continue;
+
+        const d = this.direction(bd);
+        if (!d || !dir) continue;
+
+        if (d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0) > 0.9) {
+          onward = bd;
+          onwardDir = d;
+        }
+      }
+    }
+
+    // Everything it held across our path is ours now.
+    this.hand(this.transverse(nd, dir, ahead), ray);
+
+    const beyond = onward?.target;
+
+    if (beyond) {
+      a.target = beyond;
+      beyond.target = a;
+    } else {
+      // Nothing beyond it: what we are moving along is a bare direction
+      // again, and growing into it is the next thing we do.
+      a.target = undefined;
+      a.outward = onwardDir ?? dir;
+    }
+
+    // Anything still pointing at it is pointing at nowhere; the direction
+    // survives the point, so it is left as a bare one.
+    for (const other of nd) {
+      for (const bd of other.boundaries) {
+        const partner = bd.target;
+        if (!partner || partner === a || partner === beyond) continue;
+
+        const d = this.direction(partner);
+        partner.target = undefined;
+        partner.outward = d;
+      }
+
+      other.boundaries = [];
     }
 
-    this.gridPos.delete(B);
-    this.nodes = this.nodes.filter(n => n !== B);
-    removed.add(B);
+    // Its place is our place: we have moved.
+    if (there) this.gridPos.set(ray.node, there.slice());
+
+    this.gridPos.delete(nd);
+    this.nodes = this.nodes.filter(n => n !== nd);
+    removed.add(nd);
+    vacated.delete(nd);
+  }
+
+  /**
+   * An actual boundary of the structure: there is nothing in front of us at
+   * all. We assume we can go that way anyway, and make what we are going
+   * into — a new point, connected to what we are connected to, so that what
+   * grows is more of the same lattice rather than a spur hanging off it.
+   *
+   * Neutral, like anything else instantiated: it is somewhere to be, not
+   * something to be. It is space, so the move that made it consumes it in the
+   * same tick, which is what moving into nothing amounts to.
+   */
+  private grow(ray: Ray, a: Boundary) {
+    const dir = this.direction(a);
+    const here = this.gridPos.get(ray.node);
+    if (!dir || !here) return;
+
+    const pos = here.map((v, i) => v + dir[i]);
+
+    const nd: node = [];
+    const fresh = new Ray(nd, this);
+    fresh.boundaries = []; // drop the constructor's default
+
+    const facing = new Boundary(fresh, this);
+    facing.polarity = Polarity.Neutral;
+    facing.target = a;
+    fresh.boundaries.push(facing);
+
+    a.outward = undefined; // a connection now, not a bare direction
+    a.target = facing;
+
+    this.nodes.push(nd);
+    this.gridPos.set(nd, pos);
+
+    // Connected to what we are connected to: one direction for each of ours,
+    // a real connection where a point is already there and a bare direction
+    // where there isn't one yet, so the frontier can keep going.
+    for (const boundary of ray.boundaries) {
+      if (boundary === a) continue;
+
+      const d = this.direction(boundary);
+      if (!d) continue;
+
+      const neighbour = this.nodeAt(pos.map((v, i) => v + d[i]));
+      if (neighbour === ray.node || neighbour === nd) continue; // back at us
+
+      const side = new Boundary(fresh, this);
+      side.polarity = Polarity.Neutral;
+
+      if (neighbour) {
+        const facingBack = new Boundary(neighbour[0], this);
+        facingBack.polarity = Polarity.Neutral;
+        facingBack.target = side;
+        side.target = facingBack;
+        neighbour[0].boundaries.push(facingBack);
+      } else {
+        side.outward = d;
+      }
+
+      fresh.boundaries.push(side);
+    }
   }
 
+  /**
+   * One tick. Every ray acts, and each acts on one thing only: the boundary
+   * it is moving towards. There is nothing else it consults.
+   *
+   * Two of them meeting head-on is the one thing that isn't movement, and
+   * what it is depends only on the two charges that met:
+   *
+   *  - opposite → they cancel, leaving the space they were still connected
+   *    and still there, just neutral and still;
+   *  - alike → neither can cancel and neither can pass, so each turns itself
+   *    around.
+   *
+   * Everything else moves, and moving is a trade with space: put a point down
+   * behind, take the point in front. Space is conserved by it, which is what
+   * makes a column of things moving in step actually travel — the space each
+   * one leaves is the space the one behind it moves into.
+   */
   tick() {
     this._tickId++;
 
-    // Every node is evaluated, but each acts on only its single `moving`
-    // direction. Snapshot the rays first so structural changes (merges,
-    // new points) don't disturb iteration.
+    // Snapshot the rays first, so structural changes don't disturb iteration.
     const rays: Ray[] = [];
     for (const node of this.nodes)
       for (const ray of node)
         rays.push(ray);
 
-    const removed = new Set<node>();
+    // Which way each ray was headed when the tick began. Read once, so that
+    // acting in some order doesn't let the earlier actions decide what the
+    // later ones are — head-on is head-on as of the start of the tick.
+    const headed = new Map<Ray, Boundary | undefined>();
+    for (const r of rays) headed.set(r, r.moving);
+
+    // 1. Who is meeting whom head-on. Both ends of such a pair have had their
+    // tick: turning around, or cancelling, is the whole of what they do in
+    // it.
+    const collisions: Interaction[] = [];
+    const met = new Set<Ray>();
 
     for (const r of rays) {
-      if (removed.has(r.node)) continue;
+      if (met.has(r)) continue;
 
-      const a = r.moving;              // the single direction this ray executes
+      const a = headed.get(r);
       if (!a) continue;
 
-      const b = a.target;              // the boundary it is moving towards
-      if (!b) continue;
-
-      const r2 = b.at;                 // the ray on the far side
-      if (removed.has(r2.node)) continue;
-      if (r.node === r2.node) continue; // already merged into one node
-
-      // Is the far side moving back towards us along this same connection?
-      const mutual = r2.moving === b && b.target === a;
-
-      if (mutual) {
-        if (a.polarity !== b.polarity) {
-          // Opposite polarities head-on → annihilate this connection and
-          // merge the two nodes (keeping their other spatial directions).
-          this.mergeConnection(r, a, r2, b, removed);
-        } else {
-          // Same polarity head-on → both turn around to (superposed) their
-          // other boundaries.
-          r.moving = this.otherBoundary(r, a);
-          r2.moving = this.otherBoundary(r2, b);
-        }
-      } else {
-        // One-sided: r is moving into b's node, but b isn't pointing back.
-        // Take the spatial structure of the node we're moving towards and
-        // place it on ourselves.
-        const from = this.gridPos.get(r2.node);
-        if (from) {
-          // TODO: decide what to do with my OWN previous spatial structure —
-          // for now it is simply overwritten by the one we moved into.
-          this.gridPos.set(r.node, from.slice());
-        }
-      }
-    }
+      const b = a.target;
+      const r2 = b?.at;
 
-    // Space creation: a same-polarity connection whose two nodes are BOTH
-    // moving away from it (neither's single direction is this connection)
-    // sprouts a new spatial point in between.
-    const seen = new Set<Boundary>();
-    const toCreate: [Boundary, Boundary][] = [];
-    for (const node of this.nodes) {
-      if (removed.has(node)) continue;
-      for (const ray of node) {
-        for (const a of ray.boundaries) {
-          const b = a.target;
-          if (!b || seen.has(a) || seen.has(b)) continue;
-          seen.add(a); seen.add(b);
-          if (a.polarity !== b.polarity) continue;          // must be same polarity
-          const rA = a.at, rB = b.at;
-          if (!rA.moving || !rB.moving) continue;           // both must be moving
-          if (rA.moving === a || rB.moving === b) continue; // and moving AWAY, not into
-          toCreate.push([a, b]);
-        }
-      }
+      // Is the far side coming back at us along this same connection?
+      if (!b || !r2 || r2.node === r.node || headed.get(r2) !== b || b.target !== a) continue;
+
+      met.add(r); met.add(r2);
+
+      // Only two actual charges, one of each, cancel. Neutral space has no
+      // charge to cancel with, so anything else that meets head-on turns
+      // around instead.
+      const opposed =
+        (a.polarity === Polarity.Positive && b.polarity === Polarity.Negative) ||
+        (a.polarity === Polarity.Negative && b.polarity === Polarity.Positive);
+
+      collisions.push({ kind: opposed ? 'annihilate' : 'turn', r, a, r2, b });
     }
-    for (const [a, b] of toCreate) this.createSpaceBetween(a, b);
 
-    this.invalidateLayout();
-  }
+    const removed = new Set<node>();
 
-  // Insert a fresh spatial point X between the nodes connected by a↔b, so
-  // A—X—B. X sits at their midpoint, with two boundaries (facing A and B) of
-  // random polarity, and a random movement direction.
-  private createSpaceBetween(a: Boundary, b: Boundary) {
-    const A = a.at.node, B = b.at.node;
-    const pA = this.gridPos.get(A), pB = this.gridPos.get(B);
-    if (!pA || !pB) return;
-    const mid = pA.map((v, i) => (v + pB[i]) / 2);
+    for (const it of collisions) {
+      if (it.kind === 'annihilate') {
+        this.annihilate(it.r, it.a, it.r2, it.b, removed);
+      } else {
+        this.turnAround(it.r, it.a);
+        this.turnAround(it.r2, it.b);
+      }
+    }
 
-    const x: node = [];
-    const rx = new Ray(x, this);
-    rx.boundaries = []; // drop the constructor's default
+    // 2. Everything else moves — read off the world as the collisions have
+    // left it, so that space that has just closed up behind an annihilation
+    // is gone before anything tries to move through it.
+    const movers = rays.filter(r =>
+      !met.has(r)
+      && r.moving
+      && !removed.has(r.node)
+      && r.boundaries.includes(r.moving));
+
+    // Who is actually going anywhere. Being behind something that is leaving
+    // is fine; being behind something that turns out not to be leaving after
+    // all is not, so this settles rather than being decided in one pass.
+    const blocked = new Set<Ray>();
+    for (let pass = 0; pass < movers.length; pass++) {
+      let changed = false;
+
+      for (const r of movers) {
+        if (blocked.has(r)) continue;
+        if (this.canMove(r, r.moving!, blocked)) continue;
+
+        blocked.add(r);
+        changed = true;
+      }
 
-    const xa = new Boundary(rx, this); // faces A
-    xa.polarity = Universe.randomPolarity();
-    xa.target = a;
+      if (!changed) break;
+    }
 
-    const xb = new Boundary(rx, this); // faces B
-    xb.polarity = Universe.randomPolarity();
-    xb.target = b;
+    const going = Universe.shuffle(movers.filter(r => !blocked.has(r)));
 
-    rx.boundaries.push(xa, xb);
+    // Two passes over the same rays. Everything puts down the space it is
+    // leaving before anything goes anywhere, because the space one of them
+    // leaves is what the one behind it moves through — done one ray at a time
+    // instead, the one behind would find its way blocked by a neighbour that
+    // hasn't left yet.
+    const vacated = new Map<node, number[]>();
 
-    // Splice X into the connection: A—X—B.
-    a.target = xa;
-    b.target = xb;
+    for (const r of going) this.emitBehind(r, r.moving!, vacated);
+    for (const r of going) this.consumeAhead(r, r.moving!, removed, vacated);
 
-    // Random initial movement direction.
-    rx.moving = Universe.random(rx.boundaries);
+    // Everything has gone where it was going, so the space left behind can
+    // take the places that were left.
+    for (const [nd, pos] of vacated)
+      if (!removed.has(nd)) this.gridPos.set(nd, pos);
 
-    this.nodes.push(x);
-    this.gridPos.set(x, mid);
+    this.invalidateLayout();
   }
 
   /**
@@ -255,11 +763,16 @@ class Graph {
    * each a single ray with one boundary per orthogonal neighbour. Every
    * boundary gets a random polarity, and every ray a random `moving`
    * direction (one of its boundaries). From there the tick rules —
-   * annihilation (opposite polarities meeting head-on), turn-around (like
-   * polarities meeting head-on), and structure-absorption (one-sided
-   * approach) — drive the evolution.
+   * annihilation (opposite polarities meeting head-on), merging (like
+   * polarities meeting head-on), and movement (everything else) — drive the
+   * evolution.
+   *
+   * The patch is small because everything in it moves, and everything that
+   * moves instantiates the space it leaves behind: the population grows by
+   * roughly one point per moving ray per tick, so what you seed is what you
+   * pay for on every tick thereafter.
    */
-  static expandingGrid(dims: number, size = 10): Graph {
+  static expandingGrid(dims: number, size = 5): Graph {
     const graph = new Graph();
     graph.dims = dims;
     const center = Math.floor(size / 2);
@@ -274,34 +787,63 @@ class Graph {
         build([...prefix, i]);
     })([]);
 
+    const { nodes } = Graph.wire(graph, coords.map(c => c.map(v => v - center)), () => Universe.randomPolarity());
+
+    // Give every ray an initial movement direction — a random one of its
+    // boundaries. This is an initial condition, not a choice the dynamics
+    // ever make again: from here on movement is conserved.
+    for (const node of nodes) {
+      const ray = node[0];
+      if (ray.boundaries.length)
+        ray.moving = ray.boundaries[Math.floor(Math.random() * ray.boundaries.length)];
+    }
+
+    graph.ringRadius = center;
+
+    return graph;
+  }
+
+  /**
+   * Lay a patch of points out on a lattice: one point per coordinate, each a
+   * single ray carrying one boundary per orthogonal neighbour present in the
+   * patch, wired to that neighbour's boundary facing back.
+   *
+   * Returns everything a caller needs to say which way things move: the
+   * points in coordinate order, a lookup by coordinate, and, per point, which
+   * of its boundaries faces which neighbour.
+   */
+  private static wire(
+    graph: Graph,
+    coords: number[][],
+    polarity: (coord: number[]) => Polarity,
+  ) {
+    const key = (c: number[]) => c.join(",");
+
+    const nodes: node[] = [];
     const byCoord = new Map<string, node>();
     const coordOf = new Map<node, number[]>();
-    const key = (c: number[]) => c.join(",");
 
-    // One node per cell — each is a single ray with no boundaries yet.
-    for (const idx of coords) {
-      const coord = idx.map(v => v - center);
-      const node: node = [];
-      const ray = new Ray(node, graph);
+    for (const coord of coords) {
+      const nd: node = [];
+      const ray = new Ray(nd, graph);
       ray.boundaries = []; // drop the constructor's default boundary
 
-      graph.nodes.push(node);
-      graph.gridPos.set(node, coord);
-      byCoord.set(key(coord), node);
-      coordOf.set(node, coord);
+      graph.nodes.push(nd);
+      graph.gridPos.set(nd, coord);
+
+      nodes.push(nd);
+      byCoord.set(key(coord), nd);
+      coordOf.set(nd, coord);
     }
 
-    // One boundary per orthogonal neighbour, each a random polarity. Remember
-    // which boundary of a node faces which neighbour, so the pair can be
-    // wired as mutual targets afterwards.
     const facing = new Map<node, Map<node, Boundary>>();
-    for (const node of graph.nodes) {
-      const coord = coordOf.get(node)!;
-      const ray = node[0];
+    for (const nd of nodes) {
+      const coord = coordOf.get(nd)!;
+      const ray = nd[0];
       const m = new Map<node, Boundary>();
-      facing.set(node, m);
+      facing.set(nd, m);
 
-      for (let axis = 0; axis < dims; axis++) {
+      for (let axis = 0; axis < coord.length; axis++) {
         for (const dir of [-1, 1]) {
           const nc = coord.slice();
           nc[axis] += dir;
@@ -309,32 +851,177 @@ class Graph {
           if (!neighbour) continue;
 
           const b = new Boundary(ray, graph);
-          b.polarity = Universe.randomPolarity();
+          b.polarity = polarity(coord);
           ray.boundaries.push(b);
           m.set(neighbour, b);
         }
       }
     }
 
-    // Wire mutual targets: this node's boundary facing a neighbour points at
-    // that neighbour's boundary facing back.
-    for (const node of graph.nodes) {
-      const m = facing.get(node)!;
-      for (const [neighbour, b] of m) {
-        const back = facing.get(neighbour)!.get(node);
+    // Mutual targets: this point's boundary facing a neighbour points at that
+    // neighbour's boundary facing back.
+    for (const nd of nodes) {
+      for (const [neighbour, b] of facing.get(nd)!) {
+        const back = facing.get(neighbour)!.get(nd);
         if (back) b.target = back;
       }
     }
 
-    // Give every ray an initial movement direction — a random one of its
-    // boundaries.
-    for (const node of graph.nodes) {
-      const ray = node[0];
-      if (ray.boundaries.length)
-        ray.moving = ray.boundaries[Math.floor(Math.random() * ray.boundaries.length)];
+    return { nodes, byCoord, facing, key };
+  }
+
+  /**
+   * Two solid blocks of points, side by side along x, every point in each one
+   * moving into the other. Each block's boundaries all carry that block's
+   * polarity, so the whole of the interface between them meets head-on at
+   * once — and the three ways two polarities can be arranged (opposite, both
+   * positive, both negative) are three different things happening to a whole
+   * surface rather than to a single pair.
+   *
+   * Opposite: the interface annihilates a column at a time, each annihilation
+   * throwing what it was carrying out behind it, so the two blocks come apart
+   * backwards. Like polarities can't annihilate, so the interface merges
+   * instead and the two blocks become one.
+   *
+   * Interior points are moving into their own block, which isn't head-on (the
+   * point ahead is moving the same way, not back), so behind the interface
+   * every column is simply moving.
+   */
+  static blocks(left: Polarity, right: Polarity, size = 3): Graph {
+    const graph = new Graph();
+    graph.dims = 2;
+    graph.ringRadius = size;
+
+    const half = Math.floor(size / 2);
+
+    const coords: number[][] = [];
+    for (let x = -size; x < size; x++)
+      for (let y = -half; y <= half; y++)
+        coords.push([x, y]);
+
+    const { nodes, byCoord, facing, key } = Graph.wire(
+      graph, coords, coord => coord[0] < 0 ? left : right,
+    );
+
+    // Every point heads for the interface: the left block moves +x, the right
+    // block -x. So the two innermost columns meet head-on, and every column
+    // behind them is moving into the back of the one in front.
+    for (const nd of nodes) {
+      const coord = graph.gridPos.get(nd)!;
+      const towards = byCoord.get(key([coord[0] + (coord[0] < 0 ? 1 : -1), coord[1]]));
+      if (towards) nd[0].moving = facing.get(nd)!.get(towards);
     }
 
-    graph.ringRadius = center;
+    return graph;
+  }
+
+  /**
+   * The smallest possible universe: two spatial points A—B, one ray each,
+   * joined by a mutual boundary pair. Every permutation of (polarity,
+   * movement direction) over the two sides is one isolated experiment in the
+   * tick rules — head-on like polarities merge into one point, head-on
+   * opposite polarities annihilate, and anything else moves: away from each
+   * other they grow the structure ahead of them and instantiate the space
+   * they vacate between themselves.
+   *
+   * Each side also carries an OUTWARD boundary (no target, pointing away from
+   * the partner). Without it "moving away from the connection" would be
+   * inexpressible — a ray whose only boundary is the connection can never
+   * point elsewhere, so a side could never be at an actual boundary of the
+   * structure and moving into it.
+   */
+  static pair(a: PairSide, b: PairSide): Graph {
+    const graph = new Graph();
+    graph.dims = 3;
+    graph.ringRadius = 1;
+
+    const side = (s: PairSide, coord: number[], outward: number[]): Boundary => {
+      const nd: node = [];
+      const ray = new Ray(nd, graph);
+      ray.boundaries = []; // drop the constructor's default
+
+      const facing = new Boundary(ray, graph);
+      facing.polarity = s.polarity;
+
+      const away = new Boundary(ray, graph);
+      away.polarity = s.polarity;
+      away.outward = outward;
+
+      ray.boundaries.push(facing, away);
+      ray.moving = s.moving === 'towards' ? facing : away;
+
+      graph.nodes.push(nd);
+      graph.gridPos.set(nd, coord);
+
+      return facing;
+    };
+
+    const fa = side(a, [-1, 0, 0], [-1, 0, 0]);
+    const fb = side(b, [1, 0, 0], [1, 0, 0]);
+
+    fa.target = fb;
+    fb.target = fa;
+
+    return graph;
+  }
+
+  /**
+   * A deep copy: new nodes, rays and boundaries, with every `target` and
+   * `moving` reference remapped onto the copies. Ticking the original leaves
+   * the clone untouched, which is what lets a run be frozen state by state.
+   *
+   * Rays and boundaries are built with `Object.create` rather than `new`,
+   * because their constructors have side effects — a Ray registers itself on
+   * its node and grows a default boundary — that would corrupt the copy.
+   */
+  clone(): Graph {
+    const graph = new Graph();
+    graph.dims = this.dims;
+    graph.ringRadius = this.ringRadius;
+    graph._tickId = this._tickId;
+
+    const rays = new Map<Ray, Ray>();
+    const boundaries = new Map<Boundary, Boundary>();
+
+    for (const nd of this.nodes) {
+      const copy: node = [];
+
+      for (const ray of nd) {
+        const r: Ray = Object.create(Ray.prototype);
+        r.id = ray.id;
+        r.node = copy;
+        r.boundaries = [];
+        rays.set(ray, r);
+        copy.push(r);
+
+        for (const bd of ray.boundaries) {
+          const b: Boundary = Object.create(Boundary.prototype);
+          b.polarity = bd.polarity;
+          b.at = r;
+          if (bd.outward) b.outward = bd.outward.slice();
+          boundaries.set(bd, b);
+          r.boundaries.push(b);
+        }
+      }
+
+      graph.nodes.push(copy);
+
+      const pos = this.gridPos.get(nd);
+      if (pos) graph.gridPos.set(copy, pos.slice());
+    }
+
+    // Second pass — every boundary now exists, so the references between
+    // them can be resolved.
+    for (const nd of this.nodes) {
+      for (const ray of nd) {
+        const r = rays.get(ray)!;
+        if (ray.moving) r.moving = boundaries.get(ray.moving);
+
+        ray.boundaries.forEach((bd, i) => {
+          if (bd.target) r.boundaries[i].target = boundaries.get(bd.target);
+        });
+      }
+    }
 
     return graph;
   }
@@ -344,7 +1031,7 @@ class Graph {
 
   get layout(): Map<node, Vec> {
     if (!this.layoutCache || this.dirty) {
-      this.layoutCache = this.sphereLayout({ scale: 50 });
+      this.layoutCache = this.sphereLayout({ scale: LATTICE_STEP });
       this.dirty = false;
     }
 
@@ -611,6 +1298,12 @@ class Boundary {
   // The boundary on the neighbouring node this one connects to / points at.
   target?: Boundary;
 
+  // A boundary with no target has no neighbour to be drawn towards. `outward`
+  // gives it a bare direction (in grid units) so it can still be rendered —
+  // and so a ray has somewhere to move that ISN'T one of its connections,
+  // which is what "moving away from this connection" means.
+  outward?: number[];
+
   constructor(public at: Ray, private readonly graph: Graph) { }
 
   positive() { this.polarity = Polarity.Positive; }
@@ -666,14 +1359,68 @@ function initialPosition(
   return gridPos.map(v => v * scale);
 }
 
-const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) => {
+// How many ticks one cycle of a repeating pattern runs for, when `repeated`
+// is passed as a bare boolean rather than a count.
+const DEFAULT_STEPS = 8;
+
+export interface CalculusVisualizationProps {
+  // The universe to run. A factory, not an instance: it is called again on
+  // every reset, so each cycle starts from a freshly seeded graph.
+  graph?: () => Graph;
+
+  // A repeating pattern: run this many ticks, reset to the seed, run again.
+  // `true` uses DEFAULT_STEPS; `false` runs indefinitely without resetting.
+  repeated?: boolean | number;
+
+  // Don't animate: lay every step of the pattern out at once, left to right
+  // (wrapping to further lines when there isn't the width), with an arrow
+  // between consecutive states. There is nothing to play, so no controls.
+  filmstrip?: boolean;
+
+  autoplay?: boolean;
+  height?: number;
+
+  // The gravity-flow glow. Worth it for a large universe; for a two-point one
+  // it just washes out the handful of boundaries the picture is about (and
+  // costs a few hundred gradient fills a frame, times however many of these
+  // are on the page).
+  density?: boolean;
+}
+
+/**
+ * One canvas showing one universe.
+ *
+ * `animate` is what separates a player from a still: with it the view runs a
+ * requestAnimationFrame loop, easing the camera and handing each frame's dt
+ * back to the caller (which is where ticking lives — this component only ever
+ * renders, it never advances the dynamics). Without it the universe is drawn
+ * exactly once, with the camera snapped straight to its target orientation
+ * rather than eased into it, since there are no later frames to ease over.
+ */
+const GraphView = ({
+  graph: current,
+  animate = false,
+  density = true,
+  onFrame,
+}: {
+  // Read afresh every frame, so a reset that swaps the whole graph out is
+  // picked up without tearing the render loop down.
+  graph: () => Graph;
+  animate?: boolean;
+  density?: boolean;
+  onFrame?: (dt: number) => void;
+}) => {
   const canvasRef = useRef(null);
   const camRef = useRef({ scale: 44, rot: Math.PI / 4, tilt: 0.6155, anchor: null, dist: null, distMult: 1.5, scaleMult: 1 });
 
-  const [running, setRunning] = useState(false);
-  // Seed the initial polarity universe; Graph.tick (annihilation /
-  // turn-around / structure-absorption) evolves it while running.
-  const [graph, setGraph] = useState(() => Graph.expandingGrid(3));
+  // The frame loop is set up once and outlives every re-render, so it must
+  // not capture these — a callback closed over at mount time would still be
+  // looking at the state of the world as it was then (which is what made
+  // pausing do nothing: the loop kept calling the first render's onFrame,
+  // where `running` was frozen at its initial value). Kept in refs and read
+  // per frame, so the loop always calls the current ones.
+  const latest = useRef({ current, onFrame });
+  latest.current = { current, onFrame };
 
   // TODO Right click/left click cursor=grab
   useEffect(() => {
@@ -693,7 +1440,11 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
       ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
     }
     resize();
-    window.addEventListener("resize", resize);
+    const onResize = () => {
+      resize();
+      if (!animate) draw(); // no frame loop to pick the new size up
+    };
+    window.addEventListener("resize", onResize);
 
     // Scroll to zoom. 2D: cursor-anchored zoom (screen-space, no depth to
     // navigate) — modifies cam.scaleMult. 3D: real dolly — scrolling
@@ -778,6 +1529,7 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
 
     function draw() {
       const cam = camRef.current;
+      const graph = latest.current.current();
 
       const w = canvas.clientWidth, h = canvas.clientHeight;
 
@@ -827,7 +1579,8 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
 
       const targetRot = effDims >= 3 ? Math.PI / 4 : 0;
       const targetTilt = effDims >= 3 ? 0.6155 : 0;
-      const orientEase = 0.12;
+      // A still has no later frames to ease over, so it snaps.
+      const orientEase = animate ? 0.12 : 1;
       cam.rot += (targetRot - cam.rot) * orientEase;
       cam.tilt += (targetTilt - cam.tilt) * orientEase;
 
@@ -854,100 +1607,97 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
       // const panY = dim === 2 && cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
       const cx = w / 2 /*+ panX*/, cy = h / 2 /*+ panY*/;
 
-      const gridKey = (c: number[]) => c.join(",");
       const projected = new Map();
-      const projByKey = new Map<string, any>();
-      for (const [n, pos] of layout) {
-        const pr = project(pos, cam.rot, cam.tilt, cam.dist || 1);
-        projected.set(n, pr);
-        const g = graph.gridPos.get(n);
-        if (g) projByKey.set(gridKey(g), pr);
-      }
+      for (const [n, pos] of layout)
+        projected.set(n, project(pos, cam.rot, cam.tilt, cam.dist || 1));
+
+      // Where a boundary's stub points, in projected (pre-scale) space: at
+      // its neighbour, or one lattice step along its bare outward direction.
+      // The same two cases the renderer draws, so the box below is measured
+      // against exactly what ends up on the canvas.
+      const aims = (n: node, bd: Boundary) => {
+        if (bd.target) return projected.get(bd.target.at.node);
+
+        const wp = layout.get(n);
+        if (!bd.outward || !wp) return undefined;
+
+        return project(
+          wp.map((v, i) => v + (bd.outward![i] || 0) * LATTICE_STEP),
+          cam.rot, cam.tilt, cam.dist || 1,
+        );
+      };
 
       // Fit-to-viewport zoom: size the structure from its actual PROJECTED
       // extent against the available width and height. A horizontal line
       // fills the width, a flat plane fills the frame, and a sphere sits
       // inside the smaller dimension — each zoomed appropriately for its
-      // shape rather than assumed spherical. The bounding box includes the
-      // outward repell tick tips (which reach past the outermost nodes and,
-      // at low ring counts, are proportionally long) so nothing overhangs.
-      let maxAbsX = 1e-6, maxAbsY = 1e-6;
+      // shape rather than assumed spherical. Boundary stubs are measured
+      // along with the nodes: the outward ones reach past the outermost node
+      // by a quarter of a lattice step, which on a two-point universe is a
+      // large fraction of the whole picture, and would otherwise hang off
+      // the edge of the canvas.
+      let loX = Infinity, hiX = -Infinity, loY = Infinity, hiY = -Infinity;
       const consider = (x: number, y: number) => {
-        const ax = Math.abs(x), ay = Math.abs(y);
-        if (ax > maxAbsX) maxAbsX = ax;
-        if (ay > maxAbsY) maxAbsY = ay;
+        if (x < loX) loX = x;
+        if (x > hiX) hiX = x;
+        if (y < loY) loY = y;
+        if (y > hiY) hiY = y;
       };
       for (const [n, p] of projected) {
         if (p.clipped) continue;
         consider(p.x, p.y);
-        const g = graph.gridPos.get(n);
-        if (!g) continue;
-        let axis = -1, maxA = 0;
-        for (let i = 0; i < g.length; i++) {
-          const a = Math.abs(g[i]);
-          if (a > maxA) { maxA = a; axis = i; }
+
+        for (const ray of n) {
+          for (const bd of ray.boundaries) {
+            const t = aims(n, bd);
+            if (!t || t.clipped) continue;
+            consider(p.x + (t.x - p.x) * BOUNDARY_STUB, p.y + (t.y - p.y) * BOUNDARY_STUB);
+          }
         }
-        if (axis < 0) continue;
-        const nc = g.slice();
-        nc[axis] -= Math.sign(g[axis]);
-        const np = projByKey.get(gridKey(nc));
-        if (!np || np.clipped) continue;
-        // Outward repell tick reaches half the edge length past the node:
-        // tip = p + (p - neighbour) * 0.5.
-        consider(p.x + (p.x - np.x) * 0.5, p.y + (p.y - np.y) * 0.5);
       }
+      if (loX > hiX) { loX = hiX = loY = hiY = 0; } // nothing survived clipping
+
+      // The camera frames what is actually there, rather than the world
+      // origin: the middle of that bounding box is what lands in the middle
+      // of the canvas. A universe that has drifted off the origin — every
+      // node merged onto one side, say — is still centred on screen instead
+      // of clinging to an edge.
+      const midX = (loX + hiX) / 2, midY = (loY + hiY) / 2;
+      const halfX = Math.max((hiX - loX) / 2, 1e-6);
+      const halfY = Math.max((hiY - loY) / 2, 1e-6);
+
       const FIT_MARGIN = 0.9; // small gap at the edges
       cam.scale = Math.min(
-        (w * 0.5 * FIT_MARGIN) / maxAbsX,
-        (h * 0.5 * FIT_MARGIN) / maxAbsY,
+        (w * 0.5 * FIT_MARGIN) / halfX,
+        (h * 0.5 * FIT_MARGIN) / halfY,
+        // A single point has no extent to fit, and would otherwise ask for
+        // an infinite zoom.
+        Math.min(w, h) / LATTICE_STEP,
       ) * (cam.scaleMult || 1);
 
+      // Projected space to canvas pixels. Everything drawn goes through this,
+      // so the framing above holds for nodes, boundaries and the density
+      // cloud alike.
+      const place = (pr: { x: number, y: number, depth: number, clipped: boolean }) => ({
+        x: cx + (pr.x - midX) * cam.scale,
+        y: cy + (pr.y - midY) * cam.scale,
+        depth: pr.depth,
+        clipped: pr.clipped,
+      });
+
       const pts = new Map();
-      for (const [n, p] of projected) {
-        pts.set(n, { x: cx + p.x * cam.scale, y: cy + p.y * cam.scale, depth: p.depth, clipped: p.clipped });
-      }
+      for (const [n, p] of projected) pts.set(n, place(p));
 
-      const keyOf = (c: number[]) => c.join(",");
+      // Screen position of an arbitrary world point, through the same camera
+      // as the nodes — used for boundaries that point somewhere no node is.
+      const screenOf = (world: Vec) =>
+        place(project(world, cam.rot, cam.tilt, cam.dist || 1));
 
-      // Lattice-coordinate lookup so each node's colored op vectors can be
-      // drawn along the ACTUAL edge to its laid-out neighbour, rather than
-      // along an abstract stored axis direction that no longer matches
-      // where the neighbour ended up after layout. This is the fix — the
-      // vectors now sit exactly on the lattice.
-      const byCoord = new Map<string, node>();
-      for (const nd of graph.nodes) {
-        const g = graph.gridPos.get(nd);
-        if (g) byCoord.set(keyOf(g), nd);
-      }
+      // The seed of an expanding universe — the one cell at the origin.
       const isCenterNode = (nd: node) => {
         const g = graph.gridPos.get(nd);
         return !!g && g.every(v => v === 0);
       };
-      const ringOf = (nd: node) => {
-        const g = graph.gridPos.get(nd);
-        return g ? Math.max(...g.map(v => Math.abs(v))) : 0;
-      };
-      // The lattice neighbour one step inward along whichever axis is
-      // largest in magnitude — i.e. the one that actually set this cell's
-      // ring distance. Pointing the vector at THIS neighbour makes it run
-      // radially along the real lattice, which is the fix (the old
-      // renderer pointed vectors along an abstract world axis regardless
-      // of where the cell sat on the sphere).
-      const primaryInwardNeighbour = (nd: node): node | undefined => {
-        const g = graph.gridPos.get(nd);
-        if (!g) return undefined;
-        let axis = -1, maxAbs = 0;
-        for (let i = 0; i < g.length; i++) {
-          const a = Math.abs(g[i]);
-          if (a > maxAbs) { maxAbs = a; axis = i; }
-        }
-        if (axis < 0) return undefined;
-        const nc = g.slice();
-        nc[axis] -= Math.sign(g[axis]);
-        return byCoord.get(keyOf(nc));
-      };
-      let maxRing = 0;
-      for (const nd of graph.nodes) maxRing = Math.max(maxRing, ringOf(nd));
 
       // Viewport culling: skip the detailed rendering work (ray projection,
       // shadowBlur, stroke/fill calls) for anything clearly off-screen. Once
@@ -996,12 +1746,14 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
       // every sample is a real coordinate run through the same camera as
       // the nodes, so it navigates identically.
       const sources: { pos: Vec; sign: number; w: number }[] = [];
-      for (const nd of graph.nodes) {
+      for (const nd of density ? graph.nodes : []) {
         const mv = nd[0] && nd[0].moving;
         if (!mv) continue;
         const wpos = layout.get(nd);
         if (!wpos) continue;
-        // Positive polarity glows one way, Negative the other.
+        // Positive polarity glows one way, Negative the other; neutral space
+        // contributes nothing to pull against.
+        if (mv.polarity === Polarity.Neutral) continue;
         sources.push({ pos: wpos, sign: mv.polarity === Polarity.Positive ? 1 : -1, w: 1 });
       }
       const MAX_SOURCES = 220;
@@ -1054,7 +1806,7 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
         const prevComposite = ctx.globalCompositeOperation;
         ctx.globalCompositeOperation = "lighter";
         for (const { s, proj } of withDepth) {
-          const x = cx + proj.x * cam.scale, y = cy + proj.y * cam.scale;
+          const { x, y } = place(proj);
           if (!onScreen({ x, y })) continue;
           const depthFactor = Math.min(Math.max(proj.depth, 0.3), 1.8);
           const norm = maxMag > 0 ? Math.min(s.mag / maxMag, 1) : 0;
@@ -1078,7 +1830,7 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
         if (!p || p.clipped || !onScreen(p)) continue;
         const depth = Math.min(Math.max(p.depth, 0.4), 1.6);
 
-        // Center seed: bright core with a soft glow.
+        // Center seed: a soft glow marking where the universe started.
         if (isCenterNode(n)) {
           const r = Math.min(Math.max(cam.scale * 0.16 * depth, 0.8), 26);
           const g = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3);
@@ -1088,85 +1840,204 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
           ctx.beginPath();
           ctx.arc(p.x, p.y, r * 3, 0, Math.PI * 2);
           ctx.fill();
-          ctx.fillStyle = "#FFE9CE";
-          ctx.beginPath();
-          ctx.arc(p.x, p.y, r, 0, Math.PI * 2);
-          ctx.fill();
-          continue;
         }
 
-        // Movement: draw each ray's selected `moving` direction as a thick
-        // segment towards the node it is heading into, coloured by that
-        // boundary's polarity (Positive amber, Negative cyan).
+        // Boundaries: EVERY boundary of every ray is drawn as a segment
+        // towards the node on the far side of its connection, coloured by
+        // its own polarity (Positive amber, Negative cyan), reaching 25% of
+        // the way along it. So each lattice connection shows two of them —
+        // one from each end, with a gap in between. The single boundary the
+        // ray is currently `moving` along is drawn at full opacity (and
+        // thicker) on top; the rest are faded down.
         ctx.lineCap = "round";
-        for (const ray of n) {
-          const mv = ray.moving;
-          if (!mv || !mv.target) continue;
-          const tp = pts.get(mv.target.at.node);
-          if (!tp || tp.clipped) continue;
+        const stub = (bd: Boundary, moving: boolean) => {
+          // Connected boundaries aim at their neighbour; unconnected ones at
+          // a point one lattice step along their bare `outward` direction, so
+          // "moving away from every connection" is visible rather than blank.
+          const wp = layout.get(n);
+          const wt = bd.target
+            ? layout.get(bd.target.at.node)
+            : (wp && bd.outward ? wp.map((v, i) => v + (bd.outward![i] || 0) * LATTICE_STEP) : undefined);
+          if (!wp || !wt) return;
+
+          const tp = bd.target ? pts.get(bd.target.at.node) : screenOf(wt);
+          if (!tp || tp.clipped) return;
 
           const dx = tp.x - p.x, dy = tp.y - p.y;
           const len = Math.hypot(dx, dy);
-          if (len < 1) continue;
+          if (len < 1) return;
           const ux = dx / len, uy = dy / len;
-          const L = len * 0.4;
-
-          ctx.strokeStyle = mv.polarity === Polarity.Positive ? "#FF7A45" : "#3DDCFF";
-          ctx.lineWidth = 4 * depth;
+          const L = len * BOUNDARY_STUB;
+
+          // Positive amber, Negative cyan, and space that hasn't been charged
+          // by anything a plain grey.
+          ctx.strokeStyle = moving
+            ? (bd.polarity === Polarity.Positive ? "#FF7A45"
+              : bd.polarity === Polarity.Negative ? "#3DDCFF"
+                : "#8C93A8")
+            : (bd.polarity === Polarity.Positive ? "rgba(255,122,69,0.3)"
+              : bd.polarity === Polarity.Negative ? "rgba(61,220,255,0.3)"
+                : "rgba(140,147,168,0.25)");
+          ctx.lineWidth = 2 * depth;
           ctx.beginPath();
           ctx.moveTo(p.x, p.y);
           ctx.lineTo(p.x + ux * L, p.y + uy * L);
           ctx.stroke();
+
+          if (!moving) return;
+
+          // An arrow head sitting ON the node, naming which of its lattice
+          // directions the ray is actually moving in. Its base is centred on
+          // the node's own position and it points off along the connection,
+          // so the direction is read at the point it belongs to rather than
+          // out at the far end of the stub.
+          //
+          // It is the silhouette of a cone, so it foreshortens like one: the
+          // width of the base is fixed, but the length shrinks as the
+          // direction turns towards or away from the camera. That ratio is
+          // measured, not guessed — the drawn length of the connection over
+          // the length it would have had square to the camera. Without it
+          // every head is drawn at full length whatever it points at, which
+          // is what makes them read wrong in 3D.
+          const worldLen = Math.hypot(...wt.map((v, i) => v - wp[i]));
+          const square = worldLen * cam.scale * depth;
+          const foreshortening = square > 0 ? Math.min(len / square, 1) : 1;
+
+          const size = Math.min(Math.max(10, ctx.lineWidth * 5), L * 0.7);
+          const head = size * Math.max(foreshortening, 0.3);
+          const nx = -uy * size * 0.46, ny = ux * size * 0.46;
+
+          ctx.fillStyle = ctx.strokeStyle;
+          ctx.beginPath();
+          ctx.moveTo(p.x + ux * head, p.y + uy * head);
+          ctx.lineTo(p.x + nx, p.y + ny);
+          ctx.lineTo(p.x - nx, p.y - ny);
+          ctx.closePath();
+          ctx.fill();
+        };
+
+        // One stub per direction — per neighbouring node, or per outward
+        // direction. After a merge a node holds many rays whose boundaries
+        // all face the same neighbour; stroking that one segment once per
+        // boundary stacks the 0.3-alpha passes into an opaque line, and mixed
+        // polarities towards the same neighbour blend amber over cyan into a
+        // washed-out white. A `moving` boundary always wins the slot, so the
+        // highlight is never lost to a resting one sharing its direction.
+        const slots = new Map<string, { bd: Boundary; moving: boolean }>();
+        for (const ray of n) {
+          for (const bd of ray.boundaries) {
+            const other = bd.target?.at.node;
+
+            let key: string;
+            if (other && other !== n) key = "n" + idxOf.get(other);
+            else if (!other && bd.outward) key = "o" + bd.outward.join(",");
+            else continue;
+
+            const moving = ray.moving === bd;
+            const cur = slots.get(key);
+            if (!cur || (moving && !cur.moving)) slots.set(key, { bd, moving });
+          }
         }
-        ctx.lineCap = "butt";
 
-        // Node dot.
-        ctx.fillStyle = "#EDEFF5";
-        ctx.beginPath();
-        ctx.arc(p.x, p.y, Math.max(1.5, 2.4 * depth), 0, Math.PI * 2);
-        ctx.fill();
+        // Dim pass first, so the highlighted one is never overdrawn by it.
+        for (const { bd, moving } of slots.values())
+          if (!moving) stub(bd, false);
+
+        for (const { bd, moving } of slots.values())
+          if (moving) stub(bd, true);
+
+        ctx.lineCap = "butt";
       }
     }
 
-    // Step the polarity dynamics once every TICK_INTERVAL seconds while
-    // running — annihilation / turn-around / structure-absorption.
-    const TICK_INTERVAL = 0.45;
-    let tickAccum = 0;
-
     function frame(now) {
       const dt = Math.min((now - last) / 1000, 0.05);
       last = now;
 
-      if (running && graph.nodes.length > 0) {
-        tickAccum += dt;
-        while (tickAccum >= TICK_INTERVAL) {
-          tickAccum -= TICK_INTERVAL;
-          graph.tick();
-        }
-      }
-
+      latest.current.onFrame?.(dt);
       draw();
 
       raf = requestAnimationFrame(frame);
     }
-    raf = requestAnimationFrame(frame);
+
+    // A still is drawn once here (and again whenever it is resized); only an
+    // animated view keeps a frame loop alive.
+    if (animate) raf = requestAnimationFrame(frame);
+    else draw();
 
     return () => {
       cancelAnimationFrame(raf);
-      window.removeEventListener("resize", resize);
+      window.removeEventListener("resize", onResize);
       // canvas.removeEventListener("wheel", onWheel);
       // canvas.removeEventListener("contextmenu", onContextMenu);
       // canvas.removeEventListener("mousedown", onMouseDown);
       // window.removeEventListener("mousemove", onMouseMove);
       // window.removeEventListener("mouseup", onMouseUp);
     };
-  }, [running]);
+  }, [animate, density]);
 
 
-  return <Block>
-    <Row center="xs">
-      <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%" }} />
-    </Row>
+  return <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%" }} />;
+}
+
+/**
+ * The animated form: one universe, ticking, with transport controls.
+ */
+const CalculusPlayer = ({
+  graph: seed = () => Graph.expandingGrid(3),
+  repeated = false,
+  autoplay = repeated !== false,
+  height = 150,
+  density = true,
+}: CalculusVisualizationProps) => {
+  const [running, setRunning] = useState(autoplay);
+
+  // The live universe. Held in a ref rather than state because resetting
+  // swaps the whole graph out mid-animation-frame — the render loop reads it
+  // afresh every frame, so it picks the new one up without tearing down.
+  const graphRef = useRef<Graph | null>(null);
+  if (!graphRef.current) graphRef.current = seed();
+
+  // Ticks taken since the last reset, against which `repeated` is measured.
+  const stepsRef = useRef(0);
+
+  const cycle = typeof repeated === 'number' ? repeated : DEFAULT_STEPS;
+  const loops = repeated !== false;
+
+  const reset = () => {
+    graphRef.current = seed();
+    stepsRef.current = 0;
+  };
+
+  const step = () => {
+    graphRef.current?.tick();
+    stepsRef.current++;
+  };
+
+  // Step the polarity dynamics once every TICK_INTERVAL seconds while
+  // running — annihilation / turn-around / structure-absorption.
+  const TICK_INTERVAL = 0.45;
+  const accum = useRef(0);
+
+  const onFrame = (dt: number) => {
+    if (!running || !graphRef.current!.nodes.length) return;
+
+    accum.current += dt;
+    while (accum.current >= TICK_INTERVAL) {
+      accum.current -= TICK_INTERVAL;
+
+      // A repeating pattern spends one interval showing the seed again
+      // before stepping on, so the loop point is legible rather than an
+      // instant jump back.
+      if (loops && stepsRef.current >= cycle) reset();
+      else step();
+    }
+  };
+
+  return <div>
+    <div style={{ height }}>
+      <GraphView graph={() => graphRef.current!} animate density={density} onFrame={onFrame} />
+    </div>
     <Row end="xs" className="child-px-2">
       {running
         ? <>
@@ -1175,15 +2046,126 @@ const CalculusVisualization = ({ repeated = false }: { repeated?: boolean }) =>
           <div style={{ width: '1em' }}></div>
         </>
         : <>
-          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M491 100.8C478.1 93.8 462.3 94.5 450 102.6L192 272.1L192 128C192 110.3 177.7 96 160 96C142.3 96 128 110.3 128 128L128 512C128 529.7 142.3 544 160 544C177.7 544 192 529.7 192 512L192 367.9L450 537.5C462.3 545.6 478 546.3 491 539.3C504 532.3 512 518.8 512 504.1L512 136.1C512 121.4 503.9 107.9 491 100.9z" /></svg></Button>
+          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }} onClick={reset}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M491 100.8C478.1 93.8 462.3 94.5 450 102.6L192 272.1L192 128C192 110.3 177.7 96 160 96C142.3 96 128 110.3 128 128L128 512C128 529.7 142.3 544 160 544C177.7 544 192 529.7 192 512L192 367.9L450 537.5C462.3 545.6 478 546.3 491 539.3C504 532.3 512 518.8 512 504.1L512 136.1C512 121.4 503.9 107.9 491 100.9z" /></svg></Button>
           <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }} onClick={() => setRunning(true)}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M187.2 100.9C174.8 94.1 159.8 94.4 147.6 101.6C135.4 108.8 128 121.9 128 136L128 504C128 518.1 135.5 531.2 147.6 538.4C159.7 545.6 174.8 545.9 187.2 539.1L523.2 355.1C536 348.1 544 334.6 544 320C544 305.4 536 291.9 523.2 284.9L187.2 100.9z" /></svg></Button>
-          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M149 100.8C161.9 93.8 177.7 94.5 190 102.6L448 272.1L448 128C448 110.3 462.3 96 480 96C497.7 96 512 110.3 512 128L512 512C512 529.7 497.7 544 480 544C462.3 544 448 529.7 448 512L448 367.9L190 537.5C177.7 545.6 162 546.3 149 539.3C136 532.3 128 518.7 128 504L128 136C128 121.3 136.1 107.8 149 100.8z" /></svg></Button>
+          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }} onClick={step}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M149 100.8C161.9 93.8 177.7 94.5 190 102.6L448 272.1L448 128C448 110.3 462.3 96 480 96C497.7 96 512 110.3 512 128L512 512C512 529.7 497.7 544 480 544C462.3 544 448 529.7 448 512L448 367.9L190 537.5C177.7 545.6 162 546.3 149 539.3C136 532.3 128 518.7 128 504L128 136C128 121.3 136.1 107.8 149 100.8z" /></svg></Button>
         </>
       }
     </Row>
-  </Block>
+  </div>
 }
 
+/**
+ * The static form: the same pattern, but every step of it laid out at once.
+ *
+ * The dynamics are stochastic (which boundary a ray turns around to, what
+ * polarity a newly created point gets), so the states can't be re-derived by
+ * re-running the seed — running it again gives a different history. One run
+ * is stepped through, and each state along the way is cloned out of it, so
+ * the strip really is consecutive states of a single universe.
+ */
+const CalculusFilmstrip = ({
+  graph: seed = () => Graph.expandingGrid(3),
+  repeated = false,
+  height = 150,
+  density = true,
+}: CalculusVisualizationProps) => {
+  const cycle = typeof repeated === 'number' ? repeated : DEFAULT_STEPS;
+
+  const frames = useMemo(() => {
+    const graph = seed();
+    const states = [graph.clone()];
+
+    for (let i = 0; i < cycle; i++) {
+      graph.tick();
+      states.push(graph.clone());
+    }
+
+    return states;
+  }, []);
+
+  return <div style={{ display: 'flex', flexWrap: 'wrap', alignItems: 'center' }}>
+    {frames.map((graph, i) => (
+      <Fragment key={i}>
+        {i > 0
+          ? <div style={{ flex: '0 0 auto', padding: '0 0.5em', color: '#515254' }}>→</div>
+          : null}
+        <div style={{ flex: '1 1 120px', height }}>
+          <GraphView graph={() => graph} density={density} />
+        </div>
+      </Fragment>
+    ))}
+  </div>
+}
+
+const CalculusVisualization = ({ filmstrip, ...props }: CalculusVisualizationProps) =>
+  filmstrip
+    ? <CalculusFilmstrip {...props} />
+    : <CalculusPlayer {...props} />;
+
+// The four states one end of a two-point universe can be in: its polarity,
+// and whether its ray moves into the connection or away from it.
+const SIDE_STATES: PairSide[] = [
+  { polarity: Polarity.Positive, moving: 'towards' },
+  { polarity: Polarity.Positive, moving: 'away' },
+  { polarity: Polarity.Negative, moving: 'towards' },
+  { polarity: Polarity.Negative, moving: 'away' },
+];
+
+// Every combination of those two ends. `j >= i` drops mirror images — a
+// universe and its left-right reflection run identically, so listing both
+// would only duplicate the same experiment. Drop the slice for all 16.
+const PAIRS: { a: PairSide, b: PairSide }[] = SIDE_STATES.flatMap((a, i) =>
+  SIDE_STATES.slice(i).map(b => ({ a, b }))
+);
+
+type Pair = { a: PairSide, b: PairSide };
+
+// Identity of a pair up to mirroring: whichever ordering of its two ends
+// sorts first, since a universe and its reflection are the same experiment.
+const pairKey = ({ a, b }: Pair) => {
+  const end = (s: PairSide) => `${s.polarity}${s.moving}`;
+  const [x, y] = [`${end(a)}|${end(b)}`, `${end(b)}|${end(a)}`];
+  return x < y ? x : y;
+};
+
+// The anti-universe: every polarity flipped, every movement direction kept.
+const anti = ({ a, b }: Pair): Pair => {
+  const flip = (s: PairSide): PairSide => ({
+    polarity: s.polarity === Polarity.Positive ? Polarity.Negative : Polarity.Positive,
+    moving: s.moving,
+  });
+
+  return { a: flip(a), b: flip(b) };
+};
+
+// Pairs grouped with their own anti-pair, so the two sit one above the other.
+// Head-on opposite polarities (and away-from-each-other opposite polarities)
+// are their own anti up to mirroring, so those groups hold a single pair.
+const ANTI_GROUPS: Pair[][] = (() => {
+  const byKey = new Map(PAIRS.map(p => [pairKey(p), p]));
+  const taken = new Set<string>();
+  const groups: Pair[][] = [];
+
+  for (const pair of PAIRS) {
+    const key = pairKey(pair);
+    if (taken.has(key)) continue;
+    taken.add(key);
+
+    const group = [pair];
+
+    const opposite = pairKey(anti(pair));
+    if (!taken.has(opposite) && byKey.has(opposite)) {
+      taken.add(opposite);
+      group.push(byKey.get(opposite)!);
+    }
+
+    groups.push(group);
+  }
+
+  return groups;
+})();
+
 const RayCalculiAndPhysics = () => {
   const navigate = useNavigate();
 
@@ -1201,9 +2183,41 @@ const RayCalculiAndPhysics = () => {
   return <Post {...paper}>
     <Arc head="">
       <Section head="">
-        <CalculusVisualization repeated>
-
-        </CalculusVisualization>
+        <CalculusVisualization
+          graph={() => Graph.expandingGrid(3)}
+          // repeated
+        />
+
+        {/* Two blocks meeting head-on: opposite polarities, then both
+            positive, then both negative. */}
+        {([
+          [Polarity.Positive, Polarity.Negative],
+          [Polarity.Positive, Polarity.Positive],
+          [Polarity.Negative, Polarity.Negative],
+        ] as [Polarity, Polarity][]).map(([left, right], i) => (
+          <CalculusVisualization
+            key={`blocks-${i}`}
+            graph={() => Graph.blocks(left, right)}
+            repeated={15}
+            height={140}
+            density={false}
+          />
+        ))}
+
+        {ANTI_GROUPS.map((group, i) => (
+          <div key={i} style={{ marginBottom: '1.5rem' }}>
+            {group.map((pair, j) => (
+              <CalculusVisualization
+                key={j}
+                graph={() => Graph.pair(pair.a, pair.b)}
+                repeated={1}
+                filmstrip
+                height={60}
+                density={false}
+              />
+            ))}
+          </div>
+        ))}
 
       </Section>
     </Arc>

From 13c16cf3cd4acf2ff5a861052c90d125721710e5 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Wed, 5 Aug 2026 15:58:35 +0200
Subject: [PATCH 05/47] Experimenting with XOR space

---
 .../archive/2026.RayCalculiAndPhysics.tsx     | 166 ++++++++++++++++--
 1 file changed, 149 insertions(+), 17 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index 86c0a4d..0cc494d 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -34,6 +34,14 @@ type PairSide = {
   moving: 'towards' | 'away';
 };
 
+// One charge in a line of them: its polarity, and which way along the line it
+// goes. With more than two there is no "towards each other" to name a
+// direction by, so the line itself is what they are named against.
+type LineSide = {
+  polarity: Polarity;
+  moving: 'left' | 'right';
+};
+
 class Universe {
   static _2D = () => Universe.nD_Expanding(2);
   static _3D = () => Universe.nD_Expanding(3);
@@ -931,36 +939,65 @@ class Graph {
    * structure and moving into it.
    */
   static pair(a: PairSide, b: PairSide): Graph {
+    // "Towards" and "away" are the two ends of a line seen from each other:
+    // the left one heads right to close the gap, the right one heads left.
+    return Graph.line([
+      { polarity: a.polarity, moving: a.moving === 'towards' ? 'right' : 'left' },
+      { polarity: b.polarity, moving: b.moving === 'towards' ? 'left' : 'right' },
+    ]);
+  }
+
+  /**
+   * The same universe with room in it: n charges in a row, each with a
+   * polarity and a direction along the line, every point connected to the
+   * next.
+   *
+   * A pair can only do the one thing its two ends do to each other. A line
+   * of three or four has an inside — charges with something on both sides of
+   * them — so what one interaction leaves behind is what the next one has to
+   * work with. Annihilations close the line up behind them, movement trades
+   * places with the space between, and the ends grow more line to move into.
+   *
+   * Both ends carry an OUTWARD boundary (no target, pointing off the end).
+   * Without it an end moving outwards would have nowhere to be moving — it is
+   * at an actual boundary of the structure, and moves by making more of it.
+   */
+  static line(sides: LineSide[]): Graph {
     const graph = new Graph();
     graph.dims = 3;
     graph.ringRadius = 1;
 
-    const side = (s: PairSide, coord: number[], outward: number[]): Boundary => {
+    const n = sides.length;
+    const lefts: Boundary[] = [];
+    const rights: Boundary[] = [];
+
+    sides.forEach((side, i) => {
       const nd: node = [];
       const ray = new Ray(nd, graph);
       ray.boundaries = []; // drop the constructor's default
 
-      const facing = new Boundary(ray, graph);
-      facing.polarity = s.polarity;
+      const left = new Boundary(ray, graph);
+      left.polarity = side.polarity;
+      if (i === 0) left.outward = [-1, 0, 0];
 
-      const away = new Boundary(ray, graph);
-      away.polarity = s.polarity;
-      away.outward = outward;
+      const right = new Boundary(ray, graph);
+      right.polarity = side.polarity;
+      if (i === n - 1) right.outward = [1, 0, 0];
 
-      ray.boundaries.push(facing, away);
-      ray.moving = s.moving === 'towards' ? facing : away;
+      ray.boundaries.push(left, right);
+      ray.moving = side.moving === 'left' ? left : right;
 
-      graph.nodes.push(nd);
-      graph.gridPos.set(nd, coord);
+      lefts.push(left);
+      rights.push(right);
 
-      return facing;
-    };
-
-    const fa = side(a, [-1, 0, 0], [-1, 0, 0]);
-    const fb = side(b, [1, 0, 0], [1, 0, 0]);
+      graph.nodes.push(nd);
+      graph.gridPos.set(nd, [i - (n - 1) / 2, 0, 0]);
+    });
 
-    fa.target = fb;
-    fb.target = fa;
+    for (let i = 0; i + 1 < n; i++) {
+      rights[i].target = lefts[i + 1];
+      lefts[i + 1].target = rights[i];
+    }
 
     return graph;
   }
@@ -2166,6 +2203,78 @@ const ANTI_GROUPS: Pair[][] = (() => {
   return groups;
 })();
 
+// The same four states a side of a pair can be in, named against the line
+// rather than against a partner.
+const LINE_STATES: LineSide[] = [
+  { polarity: Polarity.Positive, moving: 'right' },
+  { polarity: Polarity.Positive, moving: 'left' },
+  { polarity: Polarity.Negative, moving: 'right' },
+  { polarity: Polarity.Negative, moving: 'left' },
+];
+
+// Every arrangement of n charges in a row: each of them either polarity, each
+// of them going either way. 4ⁿ of them before the symmetries are taken out.
+const linesOf = (n: number): LineSide[][] =>
+  n === 0
+    ? [[]]
+    : linesOf(n - 1).flatMap(rest => LINE_STATES.map(side => [side, ...rest]));
+
+// Read back to front with every direction reversed, a line is the same
+// experiment watched from the other end.
+const mirrored = (line: LineSide[]): LineSide[] =>
+  [...line].reverse().map(s => ({
+    polarity: s.polarity,
+    moving: s.moving === 'left' ? 'right' : 'left',
+  }));
+
+// Every polarity flipped, every direction kept: the anti-line.
+const antiLine = (line: LineSide[]): LineSide[] =>
+  line.map(s => ({
+    polarity: s.polarity === Polarity.Positive ? Polarity.Negative : Polarity.Positive,
+    moving: s.moving,
+  }));
+
+// Identity up to mirroring: whichever way round the line reads first.
+const lineKey = (line: LineSide[]): string => {
+  const read = (l: LineSide[]) => l.map(s => `${s.polarity}${s.moving}`).join(",");
+  const [x, y] = [read(line), read(mirrored(line))];
+
+  return x < y ? x : y;
+};
+
+/**
+ * The distinct lines of n charges, each grouped with its anti-line so the two
+ * sit one above the other — the same experiment run on matter and on
+ * antimatter. A line that is its own anti up to mirroring is a group of one.
+ */
+const lineGroups = (n: number): LineSide[][][] => {
+  const byKey = new Map<string, LineSide[]>();
+  for (const line of linesOf(n)) {
+    const key = lineKey(line);
+    if (!byKey.has(key)) byKey.set(key, line);
+  }
+
+  const taken = new Set<string>();
+  const groups: LineSide[][][] = [];
+
+  for (const [key, line] of byKey) {
+    if (taken.has(key)) continue;
+    taken.add(key);
+
+    const group = [line];
+
+    const opposite = lineKey(antiLine(line));
+    if (!taken.has(opposite) && byKey.has(opposite)) {
+      taken.add(opposite);
+      group.push(byKey.get(opposite)!);
+    }
+
+    groups.push(group);
+  }
+
+  return groups;
+};
+
 const RayCalculiAndPhysics = () => {
   const navigate = useNavigate();
 
@@ -2219,6 +2328,29 @@ const RayCalculiAndPhysics = () => {
           </div>
         ))}
 
+        {/* The same thing with an inside to it: every arrangement of three,
+            then of four, charges in a line. Each runs for as many steps as
+            there are charges, since that is roughly how long it takes for
+            what happens at one end to be felt at the other. */}
+        {[3, 4].map(n => (
+          <Fragment key={`line-${n}`}>
+            {lineGroups(n).map((group, i) => (
+              <div key={i} style={{ marginBottom: '1.5rem' }}>
+                {group.map((line, j) => (
+                  <CalculusVisualization
+                    key={j}
+                    graph={() => Graph.line(line)}
+                    repeated={n}
+                    filmstrip
+                    height={60}
+                    density={false}
+                  />
+                ))}
+              </div>
+            ))}
+          </Fragment>
+        ))}
+
       </Section>
     </Arc>
   </Post>;

From 5cb5bc946739eb59e3dc3d0c3207f2f84a914f4f Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Wed, 5 Aug 2026 17:07:34 +0200
Subject: [PATCH 06/47] Gravitational waves in XOR space

---
 .../archive/2026.RayCalculiAndPhysics.tsx     | 319 +++++++++++++++++-
 1 file changed, 311 insertions(+), 8 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index 0cc494d..8b85835 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -112,6 +112,13 @@ class Graph {
   // Monotonic tick counter.
   _tickId = 0;
 
+  // Something the seed has arranged for the world to go on doing, run at the
+  // start of every tick before the rules get their say. Nothing in the rules
+  // needs one — it is how a source that is never itself an event gets to be
+  // one, which is the only way to ask what a thing that keeps emitting does
+  // to the space around it.
+  onTick?: (graph: Graph) => void;
+
   get edges(): [node, node][] {
     const seen = new Set<string>();
     const edges: [node, node][] = [];
@@ -666,6 +673,8 @@ class Graph {
   tick() {
     this._tickId++;
 
+    this.onTick?.(this);
+
     // Snapshot the rays first, so structural changes don't disturb iteration.
     const rays: Ray[] = [];
     for (const node of this.nodes)
@@ -923,6 +932,139 @@ class Graph {
     return graph;
   }
 
+  /**
+   * The same two blocks, but not touching: a wide field of neutral space
+   * between them, and neither of them moving. Nothing here is told to fall
+   * towards anything.
+   *
+   * What they do instead is emit. Every tick each block writes a charge onto
+   * the space at its face and points it across the gap — alternating, so a
+   * charged pulse goes out every other tick and a neutral one in between. A
+   * pulse is not a new thing added to the world: it is a point of the space
+   * that was already there, told what it is and which way it is going. It
+   * crosses by trading places with the space in front of it, so the field
+   * stays the same size while something travels through it.
+   *
+   * The two streams meet in the middle, and what they do there is the whole
+   * experiment:
+   *
+   *  - opposite charges annihilate, and annihilation is the one rule that
+   *    takes space out of the world. The two points that cancelled are gone
+   *    and what was behind each closes directly onto what was behind the
+   *    other, so every meeting leaves the two blocks fewer points apart than
+   *    they were. Nothing moved them. The distance between them is just
+   *    smaller — which is what it would mean, here, for them to be falling
+   *    towards each other. Once the first pair meets there is a meeting every
+   *    tick, each eating the two columns that met, and it runs until the field
+   *    is gone and the two blocks are directly connected.
+   *  - like charges can't cancel, so they turn around and go home instead.
+   *    The field is exactly as wide as it was — and what comes back is a
+   *    charge arriving at a block that isn't moving, which the block has no
+   *    way to refuse, so the blocks end up being driven apart by their own
+   *    emissions rather than drawn together.
+   *
+   * So `left` and `right` are what each block emits, and that alone is the
+   * difference between attraction and repulsion.
+   *
+   * What is drawn is still where each point was put down, and annihilation
+   * doesn't move what it leaves behind: the field empties from the middle
+   * outwards and the blocks stay where they were drawn, joined across the
+   * emptied part by the connection that closed up over it. The gap in the
+   * picture is the space that no longer exists.
+   *
+   * `every` is how many ticks apart the emissions are, and `spin` flips what
+   * each block is emitting between one emission and the next — a magnet being
+   * turned over and over rather than held still. `left` and `right` are then
+   * only what each side starts as, and what matters is whether the two are
+   * turning together or against each other.
+   */
+  static emitters(
+    left: Polarity,
+    right: Polarity,
+    {
+      size = 2,
+      gap = 16,
+      height = 3,
+      every = 2,
+      spin = false,
+    }: {
+      size?: number, gap?: number, height?: number,
+      every?: number, spin?: boolean,
+    } = {},
+  ): Graph {
+    const graph = new Graph();
+    graph.dims = 2;
+    graph.ringRadius = 1; // a flat lattice: nothing here wants rounding off
+
+    const half = Math.floor(height / 2);
+
+    // The field is an even number of columns wide, so that the two streams
+    // end up adjacent and meet each other rather than both arriving at the
+    // same empty cell — which is two things trying to be in one place, and
+    // not a meeting at all.
+    const width = gap + (gap % 2);
+    const l0 = -width / 2, r0 = width / 2 - 1; // the two columns at the faces
+
+    const coords: number[][] = [];
+    for (let x = l0 - size; x <= r0 + size; x++)
+      for (let y = -half; y <= half; y++)
+        coords.push([x, y]);
+
+    // Only the blocks are charged. The field between them is what space is
+    // when nothing has happened to it yet.
+    const { byCoord, key } = Graph.wire(graph, coords, coord =>
+      coord[0] < l0 ? left
+        : coord[0] > r0 ? right
+          : Polarity.Neutral);
+
+    // The two faces: the innermost column of each block, and the way out of
+    // it. Blocks never move, so these stay the points they are.
+    const faces: { at: node, dir: number[], polarity: Polarity }[] = [];
+
+    for (let y = -half; y <= half; y++) {
+      const l = byCoord.get(key([l0 - 1, y]));
+      const r = byCoord.get(key([r0 + 1, y]));
+
+      if (l) faces.push({ at: l, dir: [1, 0], polarity: left });
+      if (r) faces.push({ at: r, dir: [-1, 0], polarity: right });
+    }
+
+    graph.onTick = g => {
+      // Ticks are counted from the first one, so `every = 2` puts a step of
+      // untouched space between one pulse and the next — the tick in between
+      // emits neutral, and emitting neutral is emitting what the space at the
+      // face already is, which is to say nothing leaves. `every = 1` is a
+      // block that never stops: one pulse directly behind the last, with no
+      // space in between for either of them to move through.
+      if ((g._tickId - 1) % every !== 0) return;
+
+      // Which way round the magnet is by now.
+      const turned = spin && Math.floor((g._tickId - 1) / every) % 2 === 1;
+
+      for (const face of faces) {
+        const here = g.gridPos.get(face.at);
+        if (!here) continue;
+
+        const ahead = g.nodeAt(here.map((v, i) => v + face.dir[i]));
+        const ray = ahead?.[0];
+
+        // Only space can be told what to be. Anything already going somewhere
+        // is somebody, and the face waits rather than overwriting it.
+        if (!ray || ray.moving) continue;
+
+        const polarity = !turned ? face.polarity
+          : face.polarity === Polarity.Positive ? Polarity.Negative : Polarity.Positive;
+
+        for (const bd of ray.boundaries)
+          bd.polarity = polarity;
+
+        ray.moving = g.along(ray, face.dir, 1);
+      }
+    };
+
+    return graph;
+  }
+
   /**
    * The smallest possible universe: two spatial points A—B, one ray each,
    * joined by a mutual boundary pair. Every permutation of (polarity,
@@ -1016,6 +1158,7 @@ class Graph {
     graph.dims = this.dims;
     graph.ringRadius = this.ringRadius;
     graph._tickId = this._tickId;
+    graph.onTick = this.onTick;
 
     const rays = new Map<Ray, Ray>();
     const boundaries = new Map<Boundary, Boundary>();
@@ -2227,12 +2370,12 @@ const mirrored = (line: LineSide[]): LineSide[] =>
     moving: s.moving === 'left' ? 'right' : 'left',
   }));
 
+const opposite = (p: Polarity): Polarity =>
+  p === Polarity.Positive ? Polarity.Negative : Polarity.Positive;
+
 // Every polarity flipped, every direction kept: the anti-line.
 const antiLine = (line: LineSide[]): LineSide[] =>
-  line.map(s => ({
-    polarity: s.polarity === Polarity.Positive ? Polarity.Negative : Polarity.Positive,
-    moving: s.moving,
-  }));
+  line.map(s => ({ polarity: opposite(s.polarity), moving: s.moving }));
 
 // Identity up to mirroring: whichever way round the line reads first.
 const lineKey = (line: LineSide[]): string => {
@@ -2243,13 +2386,13 @@ const lineKey = (line: LineSide[]): string => {
 };
 
 /**
- * The distinct lines of n charges, each grouped with its anti-line so the two
- * sit one above the other — the same experiment run on matter and on
+ * The distinct lines among the given ones, each grouped with its anti-line so
+ * the two sit one above the other — the same experiment run on matter and on
  * antimatter. A line that is its own anti up to mirroring is a group of one.
  */
-const lineGroups = (n: number): LineSide[][][] => {
+const antiGroups = (lines: LineSide[][]): LineSide[][][] => {
   const byKey = new Map<string, LineSide[]>();
-  for (const line of linesOf(n)) {
+  for (const line of lines) {
     const key = lineKey(line);
     if (!byKey.has(key)) byKey.set(key, line);
   }
@@ -2275,6 +2418,86 @@ const lineGroups = (n: number): LineSide[][][] => {
   return groups;
 };
 
+// Every arrangement of n charges, grouped with its anti.
+const lineGroups = (n: number): LineSide[][][] => antiGroups(linesOf(n));
+
+/**
+ * One side of a head-on collision: `size` charges all going the same way,
+ * their polarity flipping from one to the next. `inner` is the polarity of
+ * the one at the interface, and the block alternates outward from there —
+ * so what a block is doing at the meeting point is what names it, and the
+ * rest of it follows.
+ */
+const alternatingBlock = (size: number, inner: Polarity, moving: 'left' | 'right'): LineSide[] => {
+  const outward = Array.from({ length: size }, (_, i) => ({
+    polarity: i % 2 === 0 ? inner : opposite(inner),
+    moving,
+  }));
+
+  // Written from the interface outward. A block moving right sits to the left
+  // of the interface, so it reads the other way round along the line.
+  return moving === 'right' ? outward.reverse() : outward;
+};
+
+/**
+ * Two alternating blocks run at each other. Once the alternation is fixed the
+ * only freedom left is the phase of each block — which polarity it presents
+ * at the interface — so these four are all of them:
+ *
+ *   ..0101 → ← 1010..  the alternation carries straight through the meeting
+ *                      point; the line is one alternating line, cut in two and
+ *                      told to move at itself.
+ *   ..1010 → ← 1010..  both blocks in the same phase; the alternation breaks
+ *                      exactly where they meet, and the two innermost charges
+ *                      are alike rather than opposite.
+ *
+ * and the anti of each. Head-on opposites annihilate and head-on likes turn
+ * around, so the phase decides whether the interface eats the line or reflects
+ * it — and after the first tick the block behind is one step further in, with
+ * its own phase to present.
+ */
+const COLLISION_PHASES: [Polarity, Polarity][] = [
+  [Polarity.Positive, Polarity.Negative],
+  [Polarity.Negative, Polarity.Positive],
+  [Polarity.Positive, Polarity.Positive],
+  [Polarity.Negative, Polarity.Negative],
+];
+
+const collision = (size: number, [left, right]: [Polarity, Polarity]): LineSide[] => [
+  ...alternatingBlock(size, left, 'right'),
+  ...alternatingBlock(size, right, 'left'),
+];
+
+// The distinct collisions of two alternating blocks of `size`, grouped with
+// their antis. Mirroring identifies the two through-alternating phases, so
+// what is left is: alternation-through, and alternation-broken with its anti.
+const collisionGroups = (size: number): LineSide[][][] =>
+  antiGroups(COLLISION_PHASES.map(phases => collision(size, phases)));
+
+/**
+ * A block with no phase to it: `size` charges all going the same way, each
+ * polarity drawn on its own. There is nothing to name such a block by — every
+ * draw is a different block — so what it says about an interface is only what
+ * survives being watched a few times over.
+ */
+const randomBlock = (size: number, moving: 'left' | 'right'): LineSide[] =>
+  Array.from({ length: size }, () => ({ polarity: Universe.randomPolarity(), moving }));
+
+/**
+ * An alternating block driven into an unstructured one. The left side arrives
+ * at the interface with a polarity that was decided the moment the block was
+ * written; the right side arrives with one that wasn't decided by anything.
+ *
+ * So the two phases above stop being two experiments: which of them is
+ * happening is redrawn at every step, as whatever the other side happens to
+ * have put in front. What is left to watch is whether the alternation
+ * survives being met by something that isn't one.
+ */
+const alternatingIntoRandom = (size: number, inner: Polarity): LineSide[] => [
+  ...alternatingBlock(size, inner, 'right'),
+  ...randomBlock(size, 'left'),
+];
+
 const RayCalculiAndPhysics = () => {
   const navigate = useNavigate();
 
@@ -2313,6 +2536,43 @@ const RayCalculiAndPhysics = () => {
           />
         ))}
 
+        {/* The same two blocks held apart by a wide field of neutral space,
+            neither of them moving, each writing a charge onto the space at
+            its face every other tick. Opposite charges annihilate in the
+            middle and the field between them is eaten two columns at a time
+            until there is none of it left; like charges only bounce off each
+            other and come home. */}
+        {([
+          [Polarity.Positive, Polarity.Negative],
+          [Polarity.Positive, Polarity.Positive],
+        ] as [Polarity, Polarity][]).map(([left, right], i) => (
+          <CalculusVisualization
+            key={`emitters-${i}`}
+            graph={() => Graph.emitters(left, right)}
+            repeated={18}
+            height={140}
+          />
+        ))}
+
+        {/* The same two blocks with the magnets turned on: each side flips
+            what it is emitting every tick, and emits on every one of them, so
+            the field fills with alternating charge rather than with one thing
+            over and over. Spinning is what makes it unconditional — held
+            still, two blocks emitting alike only push each other away; turned
+            over fast enough, both ways round end up eating the field between
+            them, the second one in bursts rather than steadily. */}
+        {([
+          [Polarity.Positive, Polarity.Negative],
+          [Polarity.Positive, Polarity.Positive],
+        ] as [Polarity, Polarity][]).map(([left, right], i) => (
+          <CalculusVisualization
+            key={`spinning-${i}`}
+            graph={() => Graph.emitters(left, right, { gap: 20, every: 1, spin: true })}
+            repeated={22}
+            height={140}
+          />
+        ))}
+
         {ANTI_GROUPS.map((group, i) => (
           <div key={i} style={{ marginBottom: '1.5rem' }}>
             {group.map((pair, j) => (
@@ -2351,6 +2611,49 @@ const RayCalculiAndPhysics = () => {
           </Fragment>
         ))}
 
+        {/* Not every arrangement now, but the one arrangement with a pattern
+            to it: alternating polarities driven head-on into alternating
+            polarities. Blocks of two, three and four a side, each run for as
+            many steps as the whole line is long. */}
+        {[2, 3, 4].map(size => (
+          <Fragment key={`collision-${size}`}>
+            {collisionGroups(size).map((group, i) => (
+              <div key={i} style={{ marginBottom: '1.5rem' }}>
+                {group.map((line, j) => (
+                  <CalculusVisualization
+                    key={j}
+                    graph={() => Graph.line(line)}
+                    repeated={size * 2}
+                    height={60}
+                    density={false}
+                  />
+                ))}
+              </div>
+            ))}
+          </Fragment>
+        ))}
+
+        {/* And the same collision with the structure taken out of one side:
+            alternating into randomly assigned. There is no permutation to
+            enumerate here — a draw is not a case — so it is a handful of runs,
+            the alternating side starting from either polarity in turn. */}
+        {[3, 4].map(size => (
+          <Fragment key={`mixed-${size}`}>
+            {Array.from({ length: 4 }, (_, i) => (
+              <div key={i} style={{ marginBottom: '1.5rem' }}>
+                <CalculusVisualization
+                  graph={() => Graph.line(
+                    alternatingIntoRandom(size, i % 2 === 0 ? Polarity.Positive : Polarity.Negative)
+                  )}
+                  repeated={size * 2}
+                  height={60}
+                  density={false}
+                />
+              </div>
+            ))}
+          </Fragment>
+        ))}
+
       </Section>
     </Arc>
   </Post>;

From 69ea5226f47709ddd44c832cc07c2f24ae5881bb Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Thu, 6 Aug 2026 11:01:40 +0200
Subject: [PATCH 07/47] More examples of XOR space

---
 .gitignore                                    |  1 +
 .../archive/2026.RayCalculiAndPhysics.tsx     | 57 +++++++++++++++++--
 orbitmines.com/tsconfig.tsbuildinfo           |  1 -
 3 files changed, 52 insertions(+), 7 deletions(-)
 delete mode 100644 orbitmines.com/tsconfig.tsbuildinfo

diff --git a/.gitignore b/.gitignore
index 1c61332..945c442 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,7 @@
 orbitmines.com/.next
 orbitmines.com/node_modules
 orbitmines.com/build
+orbitmines.com/tsconfig.tsbuildinfo
 
 # Environment
 **/.idea
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index 8b85835..6d94acd 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -905,6 +905,40 @@ class Graph {
    * every column is simply moving.
    */
   static blocks(left: Polarity, right: Polarity, size = 3): Graph {
+    return Graph.facingBlocks(size, coord => coord[0] < 0 ? left : right);
+  }
+
+  /**
+   * The same two blocks with nothing uniform about either of them: every
+   * point's charge is drawn on its own, so the interface is not one thing
+   * happening to a surface but a different thing happening at every row of
+   * it. Opposite pairs cancel and take their space with them, like pairs turn
+   * around and start heading back out through their own block — at the same
+   * moment, along the same surface.
+   *
+   * What a block is, then, isn't decided by the block. It is decided pair by
+   * pair, and the two of them come apart along a line neither of them had.
+   */
+  static mixedBlocks(size = 3): Graph {
+    // `wire` asks per boundary, but a point is one thing: the draw is
+    // remembered by coordinate so every boundary of a point carries the same
+    // charge, and it is the point that is positive or negative.
+    const drawn = new Map<string, Polarity>();
+
+    return Graph.facingBlocks(size, coord => {
+      const key = coord.join(",");
+
+      if (!drawn.has(key)) drawn.set(key, Universe.randomPolarity());
+
+      return drawn.get(key)!;
+    });
+  }
+
+  // Two solid blocks side by side along x, each point charged by `polarity`
+  // and every one of them moving into the other block. So the two innermost
+  // columns meet head-on, and every column behind them is moving into the
+  // back of the one in front.
+  private static facingBlocks(size: number, polarity: (coord: number[]) => Polarity): Graph {
     const graph = new Graph();
     graph.dims = 2;
     graph.ringRadius = size;
@@ -916,13 +950,8 @@ class Graph {
       for (let y = -half; y <= half; y++)
         coords.push([x, y]);
 
-    const { nodes, byCoord, facing, key } = Graph.wire(
-      graph, coords, coord => coord[0] < 0 ? left : right,
-    );
+    const { nodes, byCoord, facing, key } = Graph.wire(graph, coords, polarity);
 
-    // Every point heads for the interface: the left block moves +x, the right
-    // block -x. So the two innermost columns meet head-on, and every column
-    // behind them is moving into the back of the one in front.
     for (const nd of nodes) {
       const coord = graph.gridPos.get(nd)!;
       const towards = byCoord.get(key([coord[0] + (coord[0] < 0 ? 1 : -1), coord[1]]));
@@ -2536,6 +2565,22 @@ const RayCalculiAndPhysics = () => {
           />
         ))}
 
+        {/* The same two blocks heading into each other with nothing uniform
+            about either of them: every point drawn positive or negative on
+            its own. The interface is then a different thing at every row of
+            it, so the two come apart along a line neither of them had — three
+            draws, since a draw is not a case. */}
+        {[0, 1, 2].map(i => (
+          <CalculusVisualization
+            key={`mixed-blocks-${i}`}
+            graph={() => Graph.mixedBlocks()}
+            repeated={5}
+            filmstrip
+            height={90}
+            density={false}
+          />
+        ))}
+
         {/* The same two blocks held apart by a wide field of neutral space,
             neither of them moving, each writing a charge onto the space at
             its face every other tick. Opposite charges annihilate in the
diff --git a/orbitmines.com/tsconfig.tsbuildinfo b/orbitmines.com/tsconfig.tsbuildinfo
deleted file mode 100644
index acd6952..0000000
--- a/orbitmines.com/tsconfig.tsbuildinfo
+++ /dev/null
@@ -1 +0,0 @@
-{"fileNames":["./node_modules/typescript/lib/lib.es5.d.ts","./node_modules/typescript/lib/lib.es2015.d.ts","./node_modules/typescript/lib/lib.es2016.d.ts","./node_modules/typescript/lib/lib.es2017.d.ts","./node_modules/typescript/lib/lib.es2018.d.ts","./node_modules/typescript/lib/lib.es2019.d.ts","./node_modules/typescript/lib/lib.es2020.d.ts","./node_modules/typescript/lib/lib.es2021.d.ts","./node_modules/typescript/lib/lib.es2022.d.ts","./node_modules/typescript/lib/lib.es2023.d.ts","./node_modules/typescript/lib/lib.es2024.d.ts","./node_modules/typescript/lib/lib.esnext.d.ts","./node_modules/typescript/lib/lib.dom.d.ts","./node_modules/typescript/lib/lib.dom.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.core.d.ts","./node_modules/typescript/lib/lib.es2015.collection.d.ts","./node_modules/typescript/lib/lib.es2015.generator.d.ts","./node_modules/typescript/lib/lib.es2015.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.promise.d.ts","./node_modules/typescript/lib/lib.es2015.proxy.d.ts","./node_modules/typescript/lib/lib.es2015.reflect.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2016.array.include.d.ts","./node_modules/typescript/lib/lib.es2016.intl.d.ts","./node_modules/typescript/lib/lib.es2017.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2017.date.d.ts","./node_modules/typescript/lib/lib.es2017.object.d.ts","./node_modules/typescript/lib/lib.es2017.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2017.string.d.ts","./node_modules/typescript/lib/lib.es2017.intl.d.ts","./node_modules/typescript/lib/lib.es2017.typedarrays.d.ts","./node_modules/typescript/lib/lib.es2018.asyncgenerator.d.ts","./node_modules/typescript/lib/lib.es2018.asynciterable.d.ts","./node_modules/typescript/lib/lib.es2018.intl.d.ts","./node_modules/typescript/lib/lib.es2018.promise.d.ts","./node_modules/typescript/lib/lib.es2018.regexp.d.ts","./node_modules/typescript/lib/lib.es2019.array.d.ts","./node_modules/typescript/lib/lib.es2019.object.d.ts","./node_modules/typescript/lib/lib.es2019.string.d.ts","./node_modules/typescript/lib/lib.es2019.symbol.d.ts","./node_modules/typescript/lib/lib.es2019.intl.d.ts","./node_modules/typescript/lib/lib.es2020.bigint.d.ts","./node_modules/typescript/lib/lib.es2020.date.d.ts","./node_modules/typescript/lib/lib.es2020.promise.d.ts","./node_modules/typescript/lib/lib.es2020.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2020.string.d.ts","./node_modules/typescript/lib/lib.es2020.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2020.intl.d.ts","./node_modules/typescript/lib/lib.es2020.number.d.ts","./node_modules/typescript/lib/lib.es2021.promise.d.ts","./node_modules/typescript/lib/lib.es2021.string.d.ts","./node_modules/typescript/lib/lib.es2021.weakref.d.ts","./node_modules/typescript/lib/lib.es2021.intl.d.ts","./node_modules/typescript/lib/lib.es2022.array.d.ts","./node_modules/typescript/lib/lib.es2022.error.d.ts","./node_modules/typescript/lib/lib.es2022.intl.d.ts","./node_modules/typescript/lib/lib.es2022.object.d.ts","./node_modules/typescript/lib/lib.es2022.string.d.ts","./node_modules/typescript/lib/lib.es2022.regexp.d.ts","./node_modules/typescript/lib/lib.es2023.array.d.ts","./node_modules/typescript/lib/lib.es2023.collection.d.ts","./node_modules/typescript/lib/lib.es2023.intl.d.ts","./node_modules/typescript/lib/lib.es2024.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2024.collection.d.ts","./node_modules/typescript/lib/lib.es2024.object.d.ts","./node_modules/typescript/lib/lib.es2024.promise.d.ts","./node_modules/typescript/lib/lib.es2024.regexp.d.ts","./node_modules/typescript/lib/lib.es2024.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2024.string.d.ts","./node_modules/typescript/lib/lib.esnext.array.d.ts","./node_modules/typescript/lib/lib.esnext.collection.d.ts","./node_modules/typescript/lib/lib.esnext.intl.d.ts","./node_modules/typescript/lib/lib.esnext.disposable.d.ts","./node_modules/typescript/lib/lib.esnext.promise.d.ts","./node_modules/typescript/lib/lib.esnext.decorators.d.ts","./node_modules/typescript/lib/lib.esnext.iterator.d.ts","./node_modules/typescript/lib/lib.esnext.float16.d.ts","./node_modules/typescript/lib/lib.esnext.error.d.ts","./node_modules/typescript/lib/lib.esnext.sharedmemory.d.ts","./node_modules/typescript/lib/lib.decorators.d.ts","./node_modules/typescript/lib/lib.decorators.legacy.d.ts","./node_modules/@types/react/global.d.ts","./node_modules/csstype/index.d.ts","./node_modules/@types/react/index.d.ts","./node_modules/next/dist/styled-jsx/types/css.d.ts","./node_modules/next/dist/styled-jsx/types/macro.d.ts","./node_modules/next/dist/styled-jsx/types/style.d.ts","./node_modules/next/dist/styled-jsx/types/global.d.ts","./node_modules/next/dist/styled-jsx/types/index.d.ts","./node_modules/next/dist/server/get-page-files.d.ts","./node_modules/@types/node/compatibility/iterators.d.ts","./node_modules/@types/node/globals.typedarray.d.ts","./node_modules/@types/node/buffer.buffer.d.ts","./node_modules/@types/node/globals.d.ts","./node_modules/@types/node/web-globals/abortcontroller.d.ts","./node_modules/@types/node/web-globals/blob.d.ts","./node_modules/@types/node/web-globals/console.d.ts","./node_modules/@types/node/web-globals/crypto.d.ts","./node_modules/@types/node/web-globals/domexception.d.ts","./node_modules/@types/node/web-globals/encoding.d.ts","./node_modules/@types/node/web-globals/events.d.ts","./node_modules/undici-types/utility.d.ts","./node_modules/undici-types/header.d.ts","./node_modules/undici-types/readable.d.ts","./node_modules/undici-types/fetch.d.ts","./node_modules/undici-types/formdata.d.ts","./node_modules/undici-types/connector.d.ts","./node_modules/undici-types/client-stats.d.ts","./node_modules/undici-types/client.d.ts","./node_modules/undici-types/errors.d.ts","./node_modules/undici-types/dispatcher.d.ts","./node_modules/undici-types/global-dispatcher.d.ts","./node_modules/undici-types/global-origin.d.ts","./node_modules/undici-types/pool-stats.d.ts","./node_modules/undici-types/pool.d.ts","./node_modules/undici-types/handlers.d.ts","./node_modules/undici-types/balanced-pool.d.ts","./node_modules/undici-types/round-robin-pool.d.ts","./node_modules/undici-types/h2c-client.d.ts","./node_modules/undici-types/agent.d.ts","./node_modules/undici-types/mock-interceptor.d.ts","./node_modules/undici-types/mock-call-history.d.ts","./node_modules/undici-types/mock-agent.d.ts","./node_modules/undici-types/mock-client.d.ts","./node_modules/undici-types/mock-pool.d.ts","./node_modules/undici-types/snapshot-agent.d.ts","./node_modules/undici-types/mock-errors.d.ts","./node_modules/undici-types/proxy-agent.d.ts","./node_modules/undici-types/env-http-proxy-agent.d.ts","./node_modules/undici-types/retry-handler.d.ts","./node_modules/undici-types/retry-agent.d.ts","./node_modules/undici-types/api.d.ts","./node_modules/undici-types/cache-interceptor.d.ts","./node_modules/undici-types/interceptors.d.ts","./node_modules/undici-types/util.d.ts","./node_modules/undici-types/cookies.d.ts","./node_modules/undici-types/patch.d.ts","./node_modules/undici-types/websocket.d.ts","./node_modules/undici-types/eventsource.d.ts","./node_modules/undici-types/diagnostics-channel.d.ts","./node_modules/undici-types/content-type.d.ts","./node_modules/undici-types/cache.d.ts","./node_modules/undici-types/index.d.ts","./node_modules/@types/node/web-globals/fetch.d.ts","./node_modules/@types/node/web-globals/importmeta.d.ts","./node_modules/@types/node/web-globals/messaging.d.ts","./node_modules/@types/node/web-globals/navigator.d.ts","./node_modules/@types/node/web-globals/performance.d.ts","./node_modules/@types/node/web-globals/storage.d.ts","./node_modules/@types/node/web-globals/streams.d.ts","./node_modules/@types/node/web-globals/timers.d.ts","./node_modules/@types/node/web-globals/url.d.ts","./node_modules/@types/node/assert.d.ts","./node_modules/@types/node/assert/strict.d.ts","./node_modules/@types/node/async_hooks.d.ts","./node_modules/@types/node/buffer.d.ts","./node_modules/@types/node/child_process.d.ts","./node_modules/@types/node/cluster.d.ts","./node_modules/@types/node/console.d.ts","./node_modules/@types/node/constants.d.ts","./node_modules/@types/node/crypto.d.ts","./node_modules/@types/node/dgram.d.ts","./node_modules/@types/node/diagnostics_channel.d.ts","./node_modules/@types/node/dns.d.ts","./node_modules/@types/node/dns/promises.d.ts","./node_modules/@types/node/domain.d.ts","./node_modules/@types/node/events.d.ts","./node_modules/@types/node/fs.d.ts","./node_modules/@types/node/fs/promises.d.ts","./node_modules/@types/node/http.d.ts","./node_modules/@types/node/http2.d.ts","./node_modules/@types/node/https.d.ts","./node_modules/@types/node/inspector.d.ts","./node_modules/@types/node/inspector.generated.d.ts","./node_modules/@types/node/inspector/promises.d.ts","./node_modules/@types/node/module.d.ts","./node_modules/@types/node/net.d.ts","./node_modules/buffer/index.d.ts","./node_modules/@types/node/os.d.ts","./node_modules/@types/node/path.d.ts","./node_modules/@types/node/path/posix.d.ts","./node_modules/@types/node/path/win32.d.ts","./node_modules/@types/node/perf_hooks.d.ts","./node_modules/@types/node/process.d.ts","./node_modules/@types/node/punycode.d.ts","./node_modules/@types/node/querystring.d.ts","./node_modules/@types/node/quic.d.ts","./node_modules/@types/node/readline.d.ts","./node_modules/@types/node/readline/promises.d.ts","./node_modules/@types/node/repl.d.ts","./node_modules/@types/node/sea.d.ts","./node_modules/@types/node/sqlite.d.ts","./node_modules/@types/node/stream.d.ts","./node_modules/@types/node/stream/consumers.d.ts","./node_modules/@types/node/stream/promises.d.ts","./node_modules/@types/node/stream/web.d.ts","./node_modules/@types/node/string_decoder.d.ts","./node_modules/@types/node/test.d.ts","./node_modules/@types/node/test/reporters.d.ts","./node_modules/@types/node/timers.d.ts","./node_modules/@types/node/timers/promises.d.ts","./node_modules/@types/node/tls.d.ts","./node_modules/@types/node/trace_events.d.ts","./node_modules/@types/node/tty.d.ts","./node_modules/@types/node/url.d.ts","./node_modules/@types/node/util.d.ts","./node_modules/@types/node/util/types.d.ts","./node_modules/@types/node/v8.d.ts","./node_modules/@types/node/vm.d.ts","./node_modules/@types/node/wasi.d.ts","./node_modules/@types/node/worker_threads.d.ts","./node_modules/@types/node/zlib.d.ts","./node_modules/@types/node/index.d.ts","./node_modules/@types/react/canary.d.ts","./node_modules/@types/react/experimental.d.ts","./node_modules/@types/react-dom/index.d.ts","./node_modules/@types/react-dom/canary.d.ts","./node_modules/@types/react-dom/experimental.d.ts","./node_modules/next/dist/lib/fallback.d.ts","./node_modules/next/dist/compiled/webpack/webpack.d.ts","./node_modules/next/dist/shared/lib/modern-browserslist-target.d.ts","./node_modules/next/dist/shared/lib/entry-constants.d.ts","./node_modules/next/dist/shared/lib/constants.d.ts","./node_modules/next/dist/lib/bundler.d.ts","./node_modules/next/dist/server/config.d.ts","./node_modules/next/dist/lib/load-custom-routes.d.ts","./node_modules/next/dist/shared/lib/image-config.d.ts","./node_modules/next/dist/build/webpack/plugins/subresource-integrity-plugin.d.ts","./node_modules/next/dist/server/body-streams.d.ts","./node_modules/next/dist/server/request/search-params.d.ts","./node_modules/next/dist/shared/lib/segment-cache/vary-params-decoding.d.ts","./node_modules/next/dist/server/app-render/vary-params.d.ts","./node_modules/next/dist/server/request/params.d.ts","./node_modules/next/dist/server/route-kind.d.ts","./node_modules/next/dist/server/route-definitions/route-definition.d.ts","./node_modules/next/dist/server/route-matches/route-match.d.ts","./node_modules/next/dist/client/components/app-router-headers.d.ts","./node_modules/next/dist/server/lib/cache-control.d.ts","./node_modules/next/dist/shared/lib/app-router-types.d.ts","./node_modules/next/dist/server/lib/cache-handlers/types.d.ts","./node_modules/next/dist/server/use-cache/use-cache-wrapper.d.ts","./node_modules/next/dist/server/resume-data-cache/cache-store.d.ts","./node_modules/next/dist/server/resume-data-cache/resume-data-cache.d.ts","./node_modules/next/dist/lib/constants.d.ts","./node_modules/next/dist/server/render-result.d.ts","./node_modules/next/dist/server/response-cache/types.d.ts","./node_modules/next/dist/server/response-cache/index.d.ts","./node_modules/@types/react/jsx-runtime.d.ts","./node_modules/next/dist/next-devtools/userspace/pages/pages-dev-overlay-setup.d.ts","./node_modules/next/dist/build/static-paths/types.d.ts","./node_modules/next/dist/server/route-definitions/app-page-route-definition.d.ts","./node_modules/next/dist/build/adapter/setup-node-env.external.d.ts","./node_modules/next/dist/server/instrumentation/types.d.ts","./node_modules/next/dist/lib/setup-exception-listeners.d.ts","./node_modules/next/dist/lib/worker.d.ts","./node_modules/next/dist/server/lib/experimental/ppr.d.ts","./node_modules/next/dist/lib/page-types.d.ts","./node_modules/next/dist/build/segment-config/app/app-segment-config.d.ts","./node_modules/next/dist/build/segment-config/pages/pages-segment-config.d.ts","./node_modules/next/dist/build/analysis/get-page-static-info.d.ts","./node_modules/next/dist/build/webpack/loaders/get-module-build-info.d.ts","./node_modules/next/dist/build/webpack/plugins/middleware-plugin.d.ts","./node_modules/next/dist/server/require-hook.d.ts","./node_modules/next/dist/server/node-polyfill-crypto.d.ts","./node_modules/next/dist/server/node-environment-baseline.d.ts","./node_modules/next/dist/server/node-environment-extensions/error-inspect.d.ts","./node_modules/next/dist/server/node-environment-extensions/console-file.d.ts","./node_modules/next/dist/server/node-environment-extensions/console-exit.d.ts","./node_modules/next/dist/server/node-environment-extensions/console-dim.external.d.ts","./node_modules/next/dist/server/node-environment-extensions/unhandled-rejection.external.d.ts","./node_modules/next/dist/server/node-environment-extensions/random.d.ts","./node_modules/next/dist/server/node-environment-extensions/date.d.ts","./node_modules/next/dist/server/node-environment-extensions/web-crypto.d.ts","./node_modules/next/dist/server/node-environment-extensions/node-crypto.d.ts","./node_modules/next/dist/server/node-environment-extensions/fast-set-immediate.external.d.ts","./node_modules/next/dist/server/node-environment.d.ts","./node_modules/next/dist/build/page-extensions-type.d.ts","./node_modules/next/dist/server/route-modules/app-page/module.compiled.d.ts","./node_modules/next/dist/server/route-definitions/app-route-route-definition.d.ts","./node_modules/next/dist/server/lib/i18n-provider.d.ts","./node_modules/next/dist/server/web/next-url.d.ts","./node_modules/next/dist/compiled/@edge-runtime/cookies/index.d.ts","./node_modules/next/dist/server/web/spec-extension/cookies.d.ts","./node_modules/next/dist/server/web/spec-extension/request.d.ts","./node_modules/next/dist/shared/lib/deep-readonly.d.ts","./node_modules/next/dist/server/lib/incremental-cache/index.d.ts","./node_modules/next/dist/shared/lib/router/utils/middleware-route-matcher.d.ts","./node_modules/next/dist/build/webpack/plugins/flight-manifest-plugin.d.ts","./node_modules/next/dist/build/webpack/plugins/next-font-manifest-plugin.d.ts","./node_modules/next/dist/server/route-definitions/locale-route-definition.d.ts","./node_modules/next/dist/server/route-definitions/pages-route-definition.d.ts","./node_modules/next/dist/shared/lib/mitt.d.ts","./node_modules/next/dist/client/with-router.d.ts","./node_modules/next/dist/client/router.d.ts","./node_modules/next/dist/client/route-loader.d.ts","./node_modules/next/dist/client/page-loader.d.ts","./node_modules/next/dist/shared/lib/bloom-filter.d.ts","./node_modules/next/dist/shared/lib/router/router.d.ts","./node_modules/next/dist/shared/lib/router-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/loadable-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/loadable.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/image-config-context.shared-runtime.d.ts","./node_modules/next/dist/client/components/readonly-url-search-params.d.ts","./node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.d.ts","./node_modules/next/dist/client/flight-data-helpers.d.ts","./node_modules/next/dist/client/components/segment-cache/cache-key.d.ts","./node_modules/next/dist/client/components/router-reducer/fetch-server-response.d.ts","./node_modules/next/dist/client/components/segment-cache/types.d.ts","./node_modules/next/dist/shared/lib/segment-cache/segment-value-encoding.d.ts","./node_modules/next/dist/client/components/segment-cache/scheduler.d.ts","./node_modules/next/dist/client/components/segment-cache/cache-map.d.ts","./node_modules/next/dist/client/components/segment-cache/vary-path.d.ts","./node_modules/next/dist/client/components/segment-cache/cache.d.ts","./node_modules/next/dist/client/components/router-reducer/ppr-navigations.d.ts","./node_modules/next/dist/client/components/segment-cache/navigation.d.ts","./node_modules/next/dist/client/components/router-reducer/router-reducer-types.d.ts","./node_modules/next/dist/shared/lib/app-router-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/server-inserted-html.shared-runtime.d.ts","./node_modules/next/dist/server/route-modules/pages/vendored/contexts/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/pages/module.compiled.d.ts","./node_modules/next/dist/build/templates/pages.d.ts","./node_modules/next/dist/server/route-modules/pages/module.d.ts","./node_modules/next/dist/server/render.d.ts","./node_modules/next/dist/build/webpack/plugins/pages-manifest-plugin.d.ts","./node_modules/next/dist/server/route-definitions/pages-api-route-definition.d.ts","./node_modules/next/dist/server/route-matches/pages-api-route-match.d.ts","./node_modules/next/dist/server/route-matchers/route-matcher.d.ts","./node_modules/next/dist/server/route-matcher-providers/route-matcher-provider.d.ts","./node_modules/next/dist/server/route-matcher-managers/route-matcher-manager.d.ts","./node_modules/next/dist/server/normalizers/normalizer.d.ts","./node_modules/next/dist/server/normalizers/locale-route-normalizer.d.ts","./node_modules/next/dist/server/normalizers/request/pathname-normalizer.d.ts","./node_modules/next/dist/server/normalizers/request/suffix.d.ts","./node_modules/next/dist/server/normalizers/request/rsc.d.ts","./node_modules/next/dist/server/normalizers/request/next-data.d.ts","./node_modules/next/dist/server/after/builtin-request-context.d.ts","./node_modules/next/dist/server/normalizers/request/segment-prefix-rsc.d.ts","./node_modules/next/dist/server/route-modules/pages/builtin/_error.d.ts","./node_modules/next/dist/server/load-default-error-components.d.ts","./node_modules/next/dist/server/base-server.d.ts","./node_modules/next/dist/server/after/after.d.ts","./node_modules/next/dist/server/after/after-context.d.ts","./node_modules/next/dist/server/use-cache/cache-life.d.ts","./node_modules/next/dist/server/app-render/work-async-storage-instance.d.ts","./node_modules/next/dist/server/lib/lazy-result.d.ts","./node_modules/next/dist/server/app-render/create-error-handler.d.ts","./node_modules/next/dist/shared/lib/action-revalidation-kind.d.ts","./node_modules/next/dist/server/app-render/work-async-storage.external.d.ts","./node_modules/next/dist/server/async-storage/work-store.d.ts","./node_modules/next/dist/server/web/http.d.ts","./node_modules/next/dist/client/components/hooks-server-context.d.ts","./node_modules/next/dist/server/route-modules/app-route/shared-modules.d.ts","./node_modules/next/dist/client/components/redirect-status-code.d.ts","./node_modules/next/dist/client/components/redirect-error.d.ts","./node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.d.ts","./node_modules/next/dist/server/async-storage/draft-mode-provider.d.ts","./node_modules/next/dist/server/web/spec-extension/adapters/headers.d.ts","./node_modules/next/dist/server/app-render/cache-signal.d.ts","./node_modules/next/dist/server/app-render/instant-validation/boundary-tracking.d.ts","./node_modules/next/dist/server/app-render/instant-validation/instant-validation-error.d.ts","./node_modules/next/dist/shared/lib/router/utils/parse-relative-url.d.ts","./node_modules/next/dist/server/app-render/instant-validation/instant-samples.d.ts","./node_modules/next/dist/server/app-render/dynamic-rendering.d.ts","./node_modules/next/dist/server/app-render/work-unit-async-storage-instance.d.ts","./node_modules/next/dist/server/lib/implicit-tags.d.ts","./node_modules/next/dist/server/app-render/staged-rendering.d.ts","./node_modules/next/dist/server/app-render/work-unit-async-storage.external.d.ts","./node_modules/next/dist/build/templates/app-route.d.ts","./node_modules/next/dist/server/app-render/action-async-storage-instance.d.ts","./node_modules/next/dist/server/app-render/action-async-storage.external.d.ts","./node_modules/next/dist/server/route-modules/app-route/module.d.ts","./node_modules/next/dist/server/route-modules/app-route/module.compiled.d.ts","./node_modules/next/dist/build/segment-config/app/app-segments.d.ts","./node_modules/next/dist/build/get-supported-browsers.d.ts","./node_modules/next/dist/build/utils.d.ts","./node_modules/next/dist/build/rendering-mode.d.ts","./node_modules/next/dist/server/lib/router-utils/build-prefetch-segment-data-route.d.ts","./node_modules/next/dist/server/lib/cpu-profile.d.ts","./node_modules/next/dist/build/turborepo-access-trace/types.d.ts","./node_modules/next/dist/build/turborepo-access-trace/result.d.ts","./node_modules/next/dist/build/turborepo-access-trace/helpers.d.ts","./node_modules/next/dist/build/turborepo-access-trace/index.d.ts","./node_modules/next/dist/export/routes/types.d.ts","./node_modules/next/dist/export/types.d.ts","./node_modules/next/dist/export/worker.d.ts","./node_modules/next/dist/build/worker.d.ts","./node_modules/next/dist/build/index.d.ts","./node_modules/next/dist/lib/coalesced-function.d.ts","./node_modules/next/dist/server/lib/router-utils/types.d.ts","./node_modules/next/dist/trace/types.d.ts","./node_modules/next/dist/trace/trace.d.ts","./node_modules/next/dist/trace/shared.d.ts","./node_modules/next/dist/trace/index.d.ts","./node_modules/next/dist/build/load-jsconfig.d.ts","./node_modules/@next/env/dist/index.d.ts","./node_modules/next/dist/build/webpack/plugins/telemetry-plugin/use-cache-tracker-utils.d.ts","./node_modules/next/dist/build/webpack/plugins/telemetry-plugin/telemetry-plugin.d.ts","./node_modules/next/dist/telemetry/storage.d.ts","./node_modules/next/dist/build/build-context.d.ts","./node_modules/next/dist/build/webpack-config.d.ts","./node_modules/next/dist/build/swc/generated-native.d.ts","./node_modules/next/dist/build/define-env.d.ts","./node_modules/next/dist/build/swc/index.d.ts","./node_modules/next/dist/build/swc/types.d.ts","./node_modules/next/dist/server/dev/parse-version-info.d.ts","./node_modules/next/dist/next-devtools/shared/types.d.ts","./node_modules/next/dist/server/dev/dev-indicator-server-state.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/cache-indicator.d.ts","./node_modules/next/dist/server/lib/parse-stack.d.ts","./node_modules/next/dist/next-devtools/server/shared.d.ts","./node_modules/next/dist/next-devtools/shared/stack-frame.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/utils/get-error-by-type.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/container/runtime-error/render-error.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/shared.d.ts","./node_modules/next/dist/server/dev/debug-channel.d.ts","./node_modules/next/dist/server/dev/hot-reloader-types.d.ts","./node_modules/next/dist/server/web/spec-extension/fetch-event.d.ts","./node_modules/next/dist/server/web/spec-extension/response.d.ts","./node_modules/next/dist/build/segment-config/middleware/middleware-config.d.ts","./node_modules/next/dist/server/web/types.d.ts","./node_modules/next/dist/shared/lib/router/utils/parse-url.d.ts","./node_modules/next/dist/server/base-http/node.d.ts","./node_modules/next/dist/server/lib/async-callback-set.d.ts","./node_modules/next/dist/shared/lib/router/utils/route-regex.d.ts","./node_modules/next/dist/shared/lib/router/utils/route-matcher.d.ts","./node_modules/sharp/lib/index.d.ts","./node_modules/next/dist/server/image-optimizer.d.ts","./node_modules/next/dist/server/next-server.d.ts","./node_modules/next/dist/server/lib/types.d.ts","./node_modules/next/dist/server/lib/lru-cache.d.ts","./node_modules/next/dist/server/lib/dev-bundler-service.d.ts","./node_modules/next/dist/server/dev/static-paths-worker.d.ts","./node_modules/next/dist/server/dev/next-dev-server.d.ts","./node_modules/next/dist/server/next.d.ts","./node_modules/next/dist/server/lib/render-server.d.ts","./node_modules/next/dist/server/lib/router-server.d.ts","./node_modules/next/dist/shared/lib/router/utils/path-match.d.ts","./node_modules/next/dist/server/lib/router-utils/filesystem.d.ts","./node_modules/next/dist/server/lib/router-utils/setup-dev-bundler.d.ts","./node_modules/next/dist/server/lib/router-utils/router-server-context.d.ts","./node_modules/next/dist/server/route-modules/route-module.d.ts","./node_modules/next/dist/server/load-components.d.ts","./node_modules/next/dist/server/web/adapter.d.ts","./node_modules/next/dist/server/app-render/types.d.ts","./node_modules/next/dist/build/webpack/loaders/metadata/types.d.ts","./node_modules/next/dist/build/webpack/loaders/next-app-loader/index.d.ts","./node_modules/next/dist/server/lib/app-dir-module.d.ts","./node_modules/next/dist/server/app-render/app-render.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/contexts/entrypoints.d.ts","./node_modules/next/dist/client/components/error-boundary.d.ts","./node_modules/next/dist/client/components/layout-router.d.ts","./node_modules/next/dist/client/components/render-from-template-context.d.ts","./node_modules/next/dist/client/components/client-page.d.ts","./node_modules/next/dist/client/components/client-segment.d.ts","./node_modules/next/dist/client/components/http-access-fallback/error-boundary.d.ts","./node_modules/next/dist/lib/metadata/types/alternative-urls-types.d.ts","./node_modules/next/dist/lib/metadata/types/extra-types.d.ts","./node_modules/next/dist/lib/metadata/types/metadata-types.d.ts","./node_modules/next/dist/lib/metadata/types/manifest-types.d.ts","./node_modules/next/dist/lib/metadata/types/opengraph-types.d.ts","./node_modules/next/dist/lib/metadata/types/twitter-types.d.ts","./node_modules/next/dist/lib/metadata/types/metadata-interface.d.ts","./node_modules/next/dist/lib/metadata/types/resolvers.d.ts","./node_modules/next/dist/lib/metadata/types/icons.d.ts","./node_modules/next/dist/lib/metadata/resolve-metadata.d.ts","./node_modules/next/dist/lib/metadata/metadata.d.ts","./node_modules/next/dist/lib/framework/boundary-components.d.ts","./node_modules/next/dist/server/app-render/rsc/preloads.d.ts","./node_modules/next/dist/server/app-render/rsc/postpone.d.ts","./node_modules/next/dist/server/app-render/rsc/taint.d.ts","./node_modules/next/dist/server/app-render/collect-segment-data.d.ts","./node_modules/next/dist/server/app-render/instant-validation/instant-validation.d.ts","./node_modules/next/dist/next-devtools/userspace/app/segment-explorer-node.d.ts","./node_modules/next/dist/server/app-render/entry-base.d.ts","./node_modules/next/dist/build/templates/app-page.d.ts","./node_modules/next/dist/server/route-modules/app-page/helpers/prerender-manifest-matcher.d.ts","./node_modules/@types/react/jsx-dev-runtime.d.ts","./node_modules/@types/react/compiler-runtime.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/rsc/entrypoints.d.ts","./node_modules/@types/react-dom/client.d.ts","./node_modules/@types/react-dom/static.d.ts","./node_modules/@types/react-dom/server.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/ssr/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/app-page/module.d.ts","./node_modules/next/dist/server/request/fallback-params.d.ts","./node_modules/next/dist/server/web/spec-extension/image-response.d.ts","./node_modules/next/dist/server/web/spec-extension/user-agent.d.ts","./node_modules/next/dist/server/web/spec-extension/url-pattern.d.ts","./node_modules/next/dist/server/after/index.d.ts","./node_modules/next/dist/server/request/connection.d.ts","./node_modules/next/dist/server/web/exports/index.d.ts","./node_modules/next/dist/server/request-meta.d.ts","./node_modules/next/dist/cli/next-test.d.ts","./node_modules/next/dist/shared/lib/size-limit.d.ts","./node_modules/next/dist/server/config-shared.d.ts","./node_modules/next/dist/server/base-http/index.d.ts","./node_modules/next/dist/server/api-utils/index.d.ts","./node_modules/next/dist/build/adapter/build-complete.d.ts","./node_modules/next/dist/types.d.ts","./node_modules/next/dist/shared/lib/html-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/utils.d.ts","./node_modules/next/dist/pages/_app.d.ts","./node_modules/next/app.d.ts","./node_modules/next/dist/server/web/spec-extension/unstable-cache.d.ts","./node_modules/next/dist/server/web/spec-extension/revalidate.d.ts","./node_modules/next/dist/server/web/spec-extension/unstable-no-store.d.ts","./node_modules/next/dist/server/use-cache/cache-tag.d.ts","./node_modules/next/cache.d.ts","./node_modules/next/dist/pages/_document.d.ts","./node_modules/next/document.d.ts","./node_modules/next/dist/shared/lib/dynamic.d.ts","./node_modules/next/dynamic.d.ts","./node_modules/next/dist/pages/_error.d.ts","./node_modules/next/dist/client/components/catch-error.d.ts","./node_modules/next/dist/api/error.d.ts","./node_modules/next/error.d.ts","./node_modules/next/dist/shared/lib/head.d.ts","./node_modules/next/head.d.ts","./node_modules/next/dist/server/request/cookies.d.ts","./node_modules/next/dist/server/request/headers.d.ts","./node_modules/next/dist/server/request/draft-mode.d.ts","./node_modules/next/headers.d.ts","./node_modules/next/dist/shared/lib/get-img-props.d.ts","./node_modules/next/dist/client/image-component.d.ts","./node_modules/next/dist/shared/lib/image-external.d.ts","./node_modules/next/image.d.ts","./node_modules/next/dist/client/link.d.ts","./node_modules/next/link.d.ts","./node_modules/next/dist/client/components/unrecognized-action-error.d.ts","./node_modules/next/dist/client/components/redirect.d.ts","./node_modules/next/dist/client/components/not-found.d.ts","./node_modules/next/dist/client/components/forbidden.d.ts","./node_modules/next/dist/client/components/unauthorized.d.ts","./node_modules/next/dist/client/components/unstable-rethrow.server.d.ts","./node_modules/next/dist/client/components/unstable-rethrow.d.ts","./node_modules/next/dist/client/components/navigation.react-server.d.ts","./node_modules/next/dist/client/components/navigation.d.ts","./node_modules/next/navigation.d.ts","./node_modules/next/router.d.ts","./node_modules/next/dist/client/script.d.ts","./node_modules/next/script.d.ts","./node_modules/next/dist/compiled/@edge-runtime/primitives/url.d.ts","./node_modules/next/dist/compiled/@vercel/og/satori/index.d.ts","./node_modules/next/dist/compiled/@vercel/og/types.d.ts","./node_modules/next/server.d.ts","./node_modules/next/types/global.d.ts","./node_modules/next/types/compiled.d.ts","./node_modules/next/types.d.ts","./node_modules/next/index.d.ts","./.next/dev/types/routes.d.ts","./next-env.d.ts","./src/modules.d.ts","./src/@ether/UI/delay.ts","./src/@ether/UI/host.ts","./src/router/index.tsx","./src/@ether/UI/storage.ts","./node_modules/classnames/index.d.ts","./src/@ether/UI/CRTShell.tsx","./src/@ether/UI/Typewriter.tsx","./src/@ether/UI/Intro.tsx","./src/@ether/UI/MeButton.tsx","./src/@ether/UI/NameInput.tsx","./src/@ether/UI/CommandBar.tsx","./src/@ether/UI/EtherOverlay.tsx","./src/@ether/UI/index.ts","./src/@ether/UI/data/types.ts","./src/@ether/UI/data/EtherAPI.ts","./src/@ether/UI/data/articles.ts","./src/@ether/UI/data/profiles.ts","./src/@ether/UI/data/DummyBackend.ts","./src/@ether/UI/data/index.ts","./src/@ether/UI/icons/Svg.tsx","./src/@ether/UI/icons/FileIcons.tsx","./src/@ether/UI/icons/PRIcons.tsx","./src/@ether/UI/icons/ChatIcons.tsx","./src/@ether/UI/icons/index.ts","./src/@ether/UI/layout/types.ts","./src/@ether/UI/layout/tree.ts","./src/@ether/UI/layout/IDELayout.tsx","./src/@ether/UI/layout/index.ts","./src/@ether/UI/pages/language/types.ts","./src/@ether/UI/pages/language/modules.ts","./src/@ether/UI/pages/language/storage.ts","./src/@ether/UI/pages/language/validation.ts","./src/@ether/UI/pages/library/types.ts","./src/@ether/UI/pages/library/data.ts","./src/@ether/UI/pages/pullrequests/timeAgo.ts","./src/@ether/UI/router/types.ts","./src/@ether/UI/pages/pullrequests/urls.ts","./src/@ether/UI/pages/repository/paths.ts","./src/@ether/UI/pages/repository/icons.tsx","./src/@ether/UI/pages/repository/storage.ts","./src/@ether/UI/pages/repository/profileGroups.ts","./src/@ether/UI/pages/repository/Header.tsx","./src/@ether/UI/pages/repository/repoResolve.ts","./src/@ether/UI/pages/settings/types.ts","./src/@ether/UI/pages/settings/data.ts","./src/@ether/UI/pages/settings/calc.ts","./src/@ether/UI/pages/settings/storage.ts","./src/@ether/UI/router/matchRoute.ts","./src/@ether/UI/util/Markdown.ts","./src/@ether/UI/util/diff.ts","./src/@ether/UI/util/MarkdownView.tsx","./src/@ether/UI/util/DiffView.tsx","./src/@ether/UI/util/index.ts","./node_modules/@types/lodash/common/common.d.ts","./node_modules/@types/lodash/common/array.d.ts","./node_modules/@types/lodash/common/collection.d.ts","./node_modules/@types/lodash/common/date.d.ts","./node_modules/@types/lodash/common/function.d.ts","./node_modules/@types/lodash/common/lang.d.ts","./node_modules/@types/lodash/common/math.d.ts","./node_modules/@types/lodash/common/number.d.ts","./node_modules/@types/lodash/common/object.d.ts","./node_modules/@types/lodash/common/seq.d.ts","./node_modules/@types/lodash/common/string.d.ts","./node_modules/@types/lodash/common/util.d.ts","./node_modules/@types/lodash/index.d.ts","./src/@orbitmines/js/react/IEventListener.tsx","./src/@orbitmines/js/react/hooks/useHovering.ts","./src/lib/blueprintjs/hooks/hotkeys/hotkeyConfig.ts","./src/lib/blueprintjs/Classes.ts","./src/lib/blueprintjs/common.ts","./src/lib/blueprintjs/Icon.tsx","./src/lib/blueprintjs/Button.tsx","./src/lib/blueprintjs/Tag.tsx","./src/lib/blueprintjs/Divider.tsx","./src/lib/blueprintjs/Headings.tsx","./src/lib/blueprintjs/InputGroup.tsx","./src/lib/blueprintjs/Popover.tsx","./src/lib/blueprintjs/HotkeysProvider.tsx","./src/lib/blueprintjs/index.ts","./src/@orbitmines/js/react/hooks/useHotkeys.ts","./src/lib/post/sectionSlug.ts","./src/lib/post/section.ts","./src/lib/organizations/ORGANIZATIONS.ts","./node_modules/html-to-image/lib/types.d.ts","./node_modules/html-to-image/lib/index.d.ts","./src/routes/profiles/fadi-shawki/fadi_shawki.ts","./src/routes/profiles/profiles.ts","./node_modules/@types/prismjs/index.d.ts","./node_modules/prism-react-renderer/dist/index.d.ts","./src/routes/references.tsx","./node_modules/@types/three/src/constants.d.ts","./node_modules/@types/three/src/math/Vector2.d.ts","./node_modules/@types/three/src/math/Matrix3.d.ts","./node_modules/@types/three/src/core/BufferAttribute.d.ts","./node_modules/@types/three/src/core/InterleavedBuffer.d.ts","./node_modules/@types/three/src/core/InterleavedBufferAttribute.d.ts","./node_modules/@types/three/src/math/Quaternion.d.ts","./node_modules/@types/three/src/math/Euler.d.ts","./node_modules/@types/three/src/math/Matrix4.d.ts","./node_modules/@types/three/src/math/Vector4.d.ts","./node_modules/@types/three/src/cameras/Camera.d.ts","./node_modules/@types/three/src/math/ColorManagement.d.ts","./node_modules/@types/three/src/math/Color.d.ts","./node_modules/@types/three/src/math/Cylindrical.d.ts","./node_modules/@types/three/src/math/Spherical.d.ts","./node_modules/@types/three/src/math/Vector3.d.ts","./node_modules/@types/three/src/objects/Bone.d.ts","./node_modules/@types/three/src/math/Interpolant.d.ts","./node_modules/@types/three/src/math/interpolants/BezierInterpolant.d.ts","./node_modules/@types/three/src/math/interpolants/CubicInterpolant.d.ts","./node_modules/@types/three/src/math/interpolants/DiscreteInterpolant.d.ts","./node_modules/@types/three/src/math/interpolants/LinearInterpolant.d.ts","./node_modules/@types/three/src/animation/KeyframeTrack.d.ts","./node_modules/@types/three/src/animation/AnimationClip.d.ts","./node_modules/@types/three/src/extras/core/Curve.d.ts","./node_modules/@types/three/src/extras/core/CurvePath.d.ts","./node_modules/@types/three/src/extras/core/Path.d.ts","./node_modules/@types/three/src/extras/core/Shape.d.ts","./node_modules/@types/three/src/math/Line3.d.ts","./node_modules/@types/three/src/math/Sphere.d.ts","./node_modules/@types/three/src/math/Plane.d.ts","./node_modules/@types/three/src/math/Triangle.d.ts","./node_modules/@types/three/src/math/Box3.d.ts","./node_modules/@types/three/src/renderers/common/StorageBufferAttribute.d.ts","./node_modules/@types/three/src/renderers/common/IndirectStorageBufferAttribute.d.ts","./node_modules/@types/three/src/core/EventDispatcher.d.ts","./node_modules/@types/three/src/core/GLBufferAttribute.d.ts","./node_modules/@types/three/src/core/BufferGeometry.d.ts","./node_modules/@types/three/src/objects/Group.d.ts","./node_modules/@types/three/src/lights/Light.d.ts","./node_modules/@types/three/src/textures/DepthTexture.d.ts","./node_modules/@types/three/src/core/RenderTarget.d.ts","./node_modules/@types/three/src/textures/CompressedTexture.d.ts","./node_modules/@types/three/src/textures/CubeTexture.d.ts","./node_modules/@types/three/src/textures/Source.d.ts","./node_modules/@types/three/src/textures/Texture.d.ts","./node_modules/@types/three/src/scenes/Fog.d.ts","./node_modules/@types/three/src/scenes/FogExp2.d.ts","./node_modules/@types/three/src/scenes/Scene.d.ts","./node_modules/@types/three/src/renderers/shaders/UniformsLib.d.ts","./node_modules/@types/three/src/math/Box2.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLCapabilities.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLExtensions.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLUniforms.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLProgram.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLInfo.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLProperties.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLRenderLists.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLAttributes.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLBindingStates.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLGeometries.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLObjects.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLShadowMap.d.ts","./node_modules/@types/three/src/renderers/WebGLRenderTarget.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLState.d.ts","./node_modules/@types/webxr/index.d.ts","./node_modules/@types/three/src/cameras/PerspectiveCamera.d.ts","./node_modules/@types/three/src/cameras/ArrayCamera.d.ts","./node_modules/@types/three/src/objects/Mesh.d.ts","./node_modules/@webgpu/types/dist/index.d.ts","./node_modules/@types/three/src/textures/ExternalTexture.d.ts","./node_modules/@types/three/src/renderers/webxr/WebXRController.d.ts","./node_modules/@types/three/src/renderers/webxr/WebXRManager.d.ts","./node_modules/@types/three/src/renderers/WebGLRenderer.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLClipping.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLEnvironments.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLLights.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLPrograms.d.ts","./node_modules/@types/three/src/materials/Material.d.ts","./node_modules/@types/three/src/textures/DataTexture.d.ts","./node_modules/@types/three/src/objects/Skeleton.d.ts","./node_modules/@types/three/src/core/Layers.d.ts","./node_modules/@types/three/src/math/Ray.d.ts","./node_modules/@types/three/src/core/Raycaster.d.ts","./node_modules/@types/three/src/core/Object3D.d.ts","./node_modules/@types/three/src/animation/AnimationObjectGroup.d.ts","./node_modules/@types/three/src/animation/PropertyBinding.d.ts","./node_modules/@types/three/src/animation/PropertyMixer.d.ts","./node_modules/@types/three/src/animation/AnimationMixer.d.ts","./node_modules/@types/three/src/animation/AnimationAction.d.ts","./node_modules/@types/three/src/utils.d.ts","./node_modules/@types/three/src/animation/AnimationUtils.d.ts","./node_modules/@types/three/src/animation/tracks/BooleanKeyframeTrack.d.ts","./node_modules/@types/three/src/animation/tracks/ColorKeyframeTrack.d.ts","./node_modules/@types/three/src/animation/tracks/NumberKeyframeTrack.d.ts","./node_modules/@types/three/src/animation/tracks/QuaternionKeyframeTrack.d.ts","./node_modules/@types/three/src/animation/tracks/StringKeyframeTrack.d.ts","./node_modules/@types/three/src/animation/tracks/VectorKeyframeTrack.d.ts","./node_modules/@types/three/src/audio/AudioListener.d.ts","./node_modules/@types/three/src/audio/Audio.d.ts","./node_modules/@types/three/src/audio/AudioAnalyser.d.ts","./node_modules/@types/three/src/audio/AudioContext.d.ts","./node_modules/@types/three/src/audio/PositionalAudio.d.ts","./node_modules/@types/three/src/nodes/core/constants.d.ts","./node_modules/@types/three/src/nodes/core/TempNode.d.ts","./node_modules/@types/three/src/nodes/core/ArrayNode.d.ts","./node_modules/@types/three/src/nodes/core/AssignNode.d.ts","./node_modules/@types/three/src/nodes/core/AttributeNode.d.ts","./node_modules/@types/three/src/nodes/core/BypassNode.d.ts","./node_modules/@types/three/src/nodes/core/InputNode.d.ts","./node_modules/@types/three/src/nodes/core/ConstNode.d.ts","./node_modules/@types/three/src/nodes/core/IndexNode.d.ts","./node_modules/@types/three/src/nodes/core/InspectorNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeCache.d.ts","./node_modules/@types/three/src/nodes/core/IsolateNode.d.ts","./node_modules/@types/three/src/nodes/core/LightingModel.d.ts","./node_modules/@types/three/src/renderers/common/BlendMode.d.ts","./node_modules/@types/three/src/nodes/core/OutputStructNode.d.ts","./node_modules/@types/three/src/nodes/core/MRTNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeAttribute.d.ts","./node_modules/@types/three/src/nodes/core/NodeCode.d.ts","./node_modules/@types/three/src/nodes/core/StackTrace.d.ts","./node_modules/@types/three/src/nodes/core/NodeError.d.ts","./node_modules/@types/three/src/nodes/core/NodeFrame.d.ts","./node_modules/@types/three/src/nodes/core/NodeFunctionInput.d.ts","./node_modules/@types/three/src/nodes/core/UniformGroupNode.d.ts","./node_modules/@types/three/src/math/Matrix2.d.ts","./node_modules/@types/three/src/nodes/core/UniformNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeUniform.d.ts","./node_modules/@types/three/src/nodes/core/NodeVar.d.ts","./node_modules/@types/three/src/nodes/core/NodeVarying.d.ts","./node_modules/@types/three/src/nodes/core/PropertyNode.d.ts","./node_modules/@types/three/src/nodes/core/ParameterNode.d.ts","./node_modules/@types/three/src/nodes/core/StackNode.d.ts","./node_modules/@types/three/src/nodes/core/StructTypeNode.d.ts","./node_modules/@types/three/src/nodes/core/StructNode.d.ts","./node_modules/@types/three/src/nodes/core/SubBuildNode.d.ts","./node_modules/@types/three/src/nodes/core/VarNode.d.ts","./node_modules/@types/three/src/nodes/core/VaryingNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeUtils.d.ts","./node_modules/@types/three/src/objects/BatchedMesh.d.ts","./node_modules/@types/three/src/nodes/accessors/BatchNode.d.ts","./node_modules/@types/three/src/nodes/accessors/BufferAttributeNode.d.ts","./node_modules/@types/three/src/nodes/accessors/BufferNode.d.ts","./node_modules/@types/three/src/nodes/accessors/BuiltinNode.d.ts","./node_modules/@types/three/src/nodes/accessors/ClippingNode.d.ts","./node_modules/@types/three/src/nodes/accessors/TextureNode.d.ts","./node_modules/@types/three/src/nodes/accessors/CubeTextureNode.d.ts","./node_modules/@types/three/src/core/InstancedBufferAttribute.d.ts","./node_modules/@types/three/src/objects/InstancedMesh.d.ts","./node_modules/@types/three/src/core/InstancedInterleavedBuffer.d.ts","./node_modules/@types/three/src/renderers/common/StorageInstancedBufferAttribute.d.ts","./node_modules/@types/three/src/nodes/accessors/InstanceNode.d.ts","./node_modules/@types/three/src/nodes/accessors/InstancedMeshNode.d.ts","./node_modules/@types/three/src/nodes/accessors/MaterialNode.d.ts","./node_modules/@types/three/src/nodes/tsl/TSLCore.d.ts","./node_modules/@types/three/src/nodes/accessors/ReferenceNode.d.ts","./node_modules/@types/three/src/nodes/accessors/MaterialReferenceNode.d.ts","./node_modules/@types/three/src/nodes/accessors/Object3DNode.d.ts","./node_modules/@types/three/src/nodes/accessors/ModelNode.d.ts","./node_modules/@types/three/src/nodes/accessors/MorphNode.d.ts","./node_modules/@types/three/src/nodes/accessors/PointUVNode.d.ts","./node_modules/@types/three/src/nodes/accessors/ReferenceBaseNode.d.ts","./node_modules/@types/three/src/nodes/accessors/RendererReferenceNode.d.ts","./node_modules/@types/three/src/objects/SkinnedMesh.d.ts","./node_modules/@types/three/src/nodes/accessors/SkinningNode.d.ts","./node_modules/@types/three/src/nodes/utils/ArrayElementNode.d.ts","./node_modules/@types/three/src/nodes/utils/StorageArrayElementNode.d.ts","./node_modules/@types/three/src/nodes/accessors/StorageBufferNode.d.ts","./node_modules/@types/three/src/nodes/accessors/StorageTextureNode.d.ts","./node_modules/@types/three/src/nodes/accessors/Texture3DNode.d.ts","./node_modules/@types/three/src/nodes/accessors/TextureSizeNode.d.ts","./node_modules/@types/three/src/nodes/accessors/UniformArrayNode.d.ts","./node_modules/@types/three/src/nodes/accessors/UserDataNode.d.ts","./node_modules/@types/three/src/nodes/accessors/VelocityNode.d.ts","./node_modules/@types/three/src/nodes/accessors/VertexColorNode.d.ts","./node_modules/@types/three/src/nodes/code/CodeNode.d.ts","./node_modules/@types/three/src/nodes/code/ExpressionNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeFunction.d.ts","./node_modules/@types/three/src/nodes/code/FunctionNode.d.ts","./node_modules/@types/three/src/nodes/code/FunctionCallNode.d.ts","./node_modules/@types/three/src/nodes/display/BumpMapNode.d.ts","./node_modules/@types/three/src/nodes/display/ColorSpaceNode.d.ts","./node_modules/@types/three/src/nodes/display/FrontFacingNode.d.ts","./node_modules/@types/three/src/nodes/display/NormalMapNode.d.ts","./node_modules/@types/three/src/nodes/display/PassNode.d.ts","./node_modules/@types/three/src/nodes/display/RenderOutputNode.d.ts","./node_modules/@types/three/src/nodes/display/ScreenNode.d.ts","./node_modules/@types/three/src/nodes/display/ToneMappingNode.d.ts","./node_modules/@types/three/src/nodes/display/ToonOutlinePassNode.d.ts","./node_modules/@types/three/src/nodes/display/ViewportDepthNode.d.ts","./node_modules/@types/three/src/textures/FramebufferTexture.d.ts","./node_modules/@types/three/src/nodes/display/ViewportTextureNode.d.ts","./node_modules/@types/three/src/nodes/display/ViewportDepthTextureNode.d.ts","./node_modules/@types/three/src/nodes/display/ViewportSharedTextureNode.d.ts","./node_modules/@types/three/src/nodes/geometry/RangeNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/AtomicFunctionNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/BarrierNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/ComputeBuiltinNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/ComputeNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/SubgroupFunctionNode.d.ts","./node_modules/@types/three/src/nodes/gpgpu/WorkgroupInfoNode.d.ts","./node_modules/@types/three/src/lights/AmbientLight.d.ts","./node_modules/@types/three/src/nodes/lighting/LightingNode.d.ts","./node_modules/@types/three/src/materials/LineBasicMaterial.d.ts","./node_modules/@types/three/src/materials/LineDashedMaterial.d.ts","./node_modules/@types/three/src/materials/MeshBasicMaterial.d.ts","./node_modules/@types/three/src/materials/MeshDepthMaterial.d.ts","./node_modules/@types/three/src/materials/MeshDistanceMaterial.d.ts","./node_modules/@types/three/src/materials/MeshLambertMaterial.d.ts","./node_modules/@types/three/src/materials/MeshMatcapMaterial.d.ts","./node_modules/@types/three/src/materials/MeshNormalMaterial.d.ts","./node_modules/@types/three/src/materials/MeshPhongMaterial.d.ts","./node_modules/@types/three/src/materials/MeshStandardMaterial.d.ts","./node_modules/@types/three/src/materials/MeshPhysicalMaterial.d.ts","./node_modules/@types/three/src/materials/MeshToonMaterial.d.ts","./node_modules/@types/three/src/materials/PointsMaterial.d.ts","./node_modules/@types/three/src/core/Uniform.d.ts","./node_modules/@types/three/src/core/UniformsGroup.d.ts","./node_modules/@types/three/src/materials/ShaderMaterial.d.ts","./node_modules/@types/three/src/materials/RawShaderMaterial.d.ts","./node_modules/@types/three/src/materials/ShadowMaterial.d.ts","./node_modules/@types/three/src/materials/SpriteMaterial.d.ts","./node_modules/@types/three/src/materials/Materials.d.ts","./node_modules/@types/three/src/objects/Sprite.d.ts","./node_modules/@types/three/src/math/Frustum.d.ts","./node_modules/@types/three/src/lights/LightShadow.d.ts","./node_modules/@types/three/src/objects/ClippingGroup.d.ts","./node_modules/@types/three/src/renderers/common/ClippingContext.d.ts","./node_modules/@types/three/src/nodes/lighting/ShadowBaseNode.d.ts","./node_modules/@types/three/src/nodes/lighting/ShadowNode.d.ts","./node_modules/@types/three/src/nodes/lighting/AnalyticLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/AmbientLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/AONode.d.ts","./node_modules/@types/three/src/nodes/lighting/BasicEnvironmentNode.d.ts","./node_modules/@types/three/src/nodes/lighting/BasicLightMapNode.d.ts","./node_modules/@types/three/src/cameras/OrthographicCamera.d.ts","./node_modules/@types/three/src/lights/DirectionalLightShadow.d.ts","./node_modules/@types/three/src/lights/DirectionalLight.d.ts","./node_modules/@types/three/src/nodes/lighting/DirectionalLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/EnvironmentNode.d.ts","./node_modules/@types/three/src/lights/HemisphereLight.d.ts","./node_modules/@types/three/src/nodes/lighting/HemisphereLightNode.d.ts","./node_modules/@types/three/src/lights/SpotLightShadow.d.ts","./node_modules/@types/three/src/lights/SpotLight.d.ts","./node_modules/@types/three/src/nodes/lighting/SpotLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/IESSpotLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/IrradianceNode.d.ts","./node_modules/@types/three/src/nodes/lighting/LightingContextNode.d.ts","./node_modules/@types/three/src/math/SphericalHarmonics3.d.ts","./node_modules/@types/three/src/lights/LightProbe.d.ts","./node_modules/@types/three/src/nodes/lighting/LightProbeNode.d.ts","./node_modules/@types/three/src/lights/PointLightShadow.d.ts","./node_modules/@types/three/src/lights/PointLight.d.ts","./node_modules/@types/three/src/nodes/lighting/PointShadowNode.d.ts","./node_modules/@types/three/src/nodes/lighting/PointLightNode.d.ts","./node_modules/@types/three/src/nodes/lighting/ProjectorLightNode.d.ts","./node_modules/@types/three/src/lights/RectAreaLight.d.ts","./node_modules/@types/three/src/nodes/lighting/RectAreaLightNode.d.ts","./node_modules/@types/three/src/nodes/math/BitcastNode.d.ts","./node_modules/@types/three/src/nodes/math/MathNode.d.ts","./node_modules/@types/three/src/nodes/math/BitcountNode.d.ts","./node_modules/@types/three/src/nodes/math/ConditionalNode.d.ts","./node_modules/@types/three/src/nodes/math/OperatorNode.d.ts","./node_modules/@types/three/src/nodes/math/PackFloatNode.d.ts","./node_modules/@types/three/src/nodes/math/UnpackFloatNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeParser.d.ts","./node_modules/@types/three/src/nodes/parsers/GLSLNodeFunction.d.ts","./node_modules/@types/three/src/nodes/parsers/GLSLNodeParser.d.ts","./node_modules/@types/three/src/nodes/pmrem/PMREMNode.d.ts","./node_modules/@types/three/src/nodes/utils/ConvertNode.d.ts","./node_modules/@types/three/src/nodes/utils/CubeMapNode.d.ts","./node_modules/@types/three/src/nodes/utils/DebugNode.d.ts","./node_modules/@types/three/src/nodes/utils/EventNode.d.ts","./node_modules/@types/three/src/nodes/utils/FlipNode.d.ts","./node_modules/@types/three/src/nodes/utils/FunctionOverloadingNode.d.ts","./node_modules/@types/three/src/nodes/utils/JoinNode.d.ts","./node_modules/@types/three/src/nodes/utils/LoopNode.d.ts","./node_modules/@types/three/src/nodes/utils/MaxMipLevelNode.d.ts","./node_modules/@types/three/src/nodes/utils/MemberNode.d.ts","./node_modules/@types/three/src/nodes/utils/ReflectorNode.d.ts","./node_modules/@types/three/src/nodes/utils/RemapNode.d.ts","./node_modules/@types/three/src/nodes/utils/RotateNode.d.ts","./node_modules/@types/three/src/nodes/utils/RTTNode.d.ts","./node_modules/@types/three/src/nodes/utils/SampleNode.d.ts","./node_modules/@types/three/src/nodes/utils/SetNode.d.ts","./node_modules/@types/three/src/nodes/utils/SplitNode.d.ts","./node_modules/@types/three/src/nodes/functions/BasicLightingModel.d.ts","./node_modules/@types/three/src/nodes/functions/PhongLightingModel.d.ts","./node_modules/@types/three/src/nodes/functions/PhysicalLightingModel.d.ts","./node_modules/@types/three/src/nodes/Nodes.d.ts","./node_modules/@types/three/src/nodes/lighting/LightsNode.d.ts","./node_modules/@types/three/src/nodes/core/NodeBuilder.d.ts","./node_modules/@types/three/src/nodes/core/Node.d.ts","./node_modules/@types/three/src/nodes/core/ContextNode.d.ts","./node_modules/@types/three/src/renderers/common/Backend.d.ts","./node_modules/@types/three/src/renderers/common/CanvasTarget.d.ts","./node_modules/@types/three/src/renderers/common/Color4.d.ts","./node_modules/@types/three/src/renderers/common/Info.d.ts","./node_modules/@types/three/src/renderers/common/InspectorBase.d.ts","./node_modules/@types/three/src/renderers/common/Lighting.d.ts","./node_modules/@types/three/src/renderers/common/Binding.d.ts","./node_modules/@types/three/src/renderers/common/BindGroup.d.ts","./node_modules/@types/three/src/renderers/common/BundleGroup.d.ts","./node_modules/@types/three/src/renderers/common/DataMap.d.ts","./node_modules/@types/three/src/renderers/common/Attributes.d.ts","./node_modules/@types/three/src/renderers/common/Constants.d.ts","./node_modules/@types/three/src/renderers/common/Geometries.d.ts","./node_modules/@types/three/src/renderers/common/nodes/NodeBuilderState.d.ts","./node_modules/@types/three/src/renderers/common/ChainMap.d.ts","./node_modules/@types/three/src/renderers/common/Uniform.d.ts","./node_modules/@types/three/src/renderers/common/nodes/NodeUniform.d.ts","./node_modules/@types/three/src/renderers/common/Buffer.d.ts","./node_modules/@types/three/src/renderers/common/UniformBuffer.d.ts","./node_modules/@types/three/src/renderers/common/UniformsGroup.d.ts","./node_modules/@types/three/src/renderers/common/nodes/NodeUniformsGroup.d.ts","./node_modules/@types/three/src/renderers/common/nodes/NodeManager.d.ts","./node_modules/@types/three/src/renderers/common/RenderContext.d.ts","./node_modules/@types/three/src/renderers/common/RenderPipeline.d.ts","./node_modules/@types/three/src/renderers/common/RenderObject.d.ts","./node_modules/@types/three/src/materials/nodes/manager/NodeMaterialObserver.d.ts","./node_modules/@types/three/src/materials/nodes/NodeMaterial.d.ts","./node_modules/@types/three/src/renderers/common/nodes/NodeLibrary.d.ts","./node_modules/@types/three/src/renderers/common/RenderList.d.ts","./node_modules/@types/three/src/geometries/CylinderGeometry.d.ts","./node_modules/@types/three/src/geometries/PlaneGeometry.d.ts","./node_modules/@types/three/src/renderers/common/QuadMesh.d.ts","./node_modules/@types/three/src/renderers/common/XRRenderTarget.d.ts","./node_modules/@types/three/src/renderers/common/XRManager.d.ts","./node_modules/@types/three/src/renderers/common/Renderer.d.ts","./node_modules/@types/three/src/renderers/common/CubeRenderTarget.d.ts","./node_modules/@types/three/src/renderers/WebGLCubeRenderTarget.d.ts","./node_modules/@types/three/src/cameras/CubeCamera.d.ts","./node_modules/@types/three/src/cameras/StereoCamera.d.ts","./node_modules/@types/three/src/core/Clock.d.ts","./node_modules/@types/three/src/core/InstancedBufferGeometry.d.ts","./node_modules/@types/three/src/core/RenderTarget3D.d.ts","./node_modules/@types/three/src/core/Timer.d.ts","./node_modules/@types/three/src/extras/Controls.d.ts","./node_modules/@types/three/src/extras/core/ShapePath.d.ts","./node_modules/@types/three/src/extras/curves/EllipseCurve.d.ts","./node_modules/@types/three/src/extras/curves/ArcCurve.d.ts","./node_modules/@types/three/src/extras/curves/CatmullRomCurve3.d.ts","./node_modules/@types/three/src/extras/curves/CubicBezierCurve.d.ts","./node_modules/@types/three/src/extras/curves/CubicBezierCurve3.d.ts","./node_modules/@types/three/src/extras/curves/LineCurve.d.ts","./node_modules/@types/three/src/extras/curves/LineCurve3.d.ts","./node_modules/@types/three/src/extras/curves/QuadraticBezierCurve.d.ts","./node_modules/@types/three/src/extras/curves/QuadraticBezierCurve3.d.ts","./node_modules/@types/three/src/extras/curves/SplineCurve.d.ts","./node_modules/@types/three/src/extras/curves/Curves.d.ts","./node_modules/@types/three/src/extras/DataUtils.d.ts","./node_modules/@types/three/src/extras/ImageUtils.d.ts","./node_modules/@types/three/src/extras/ShapeUtils.d.ts","./node_modules/@types/three/src/extras/TextureUtils.d.ts","./node_modules/@types/three/src/geometries/BoxGeometry.d.ts","./node_modules/@types/three/src/geometries/CapsuleGeometry.d.ts","./node_modules/@types/three/src/geometries/CircleGeometry.d.ts","./node_modules/@types/three/src/geometries/ConeGeometry.d.ts","./node_modules/@types/three/src/geometries/PolyhedronGeometry.d.ts","./node_modules/@types/three/src/geometries/DodecahedronGeometry.d.ts","./node_modules/@types/three/src/geometries/EdgesGeometry.d.ts","./node_modules/@types/three/src/geometries/ExtrudeGeometry.d.ts","./node_modules/@types/three/src/geometries/IcosahedronGeometry.d.ts","./node_modules/@types/three/src/geometries/LatheGeometry.d.ts","./node_modules/@types/three/src/geometries/OctahedronGeometry.d.ts","./node_modules/@types/three/src/geometries/RingGeometry.d.ts","./node_modules/@types/three/src/geometries/ShapeGeometry.d.ts","./node_modules/@types/three/src/geometries/SphereGeometry.d.ts","./node_modules/@types/three/src/geometries/TetrahedronGeometry.d.ts","./node_modules/@types/three/src/geometries/TorusGeometry.d.ts","./node_modules/@types/three/src/geometries/TorusKnotGeometry.d.ts","./node_modules/@types/three/src/geometries/TubeGeometry.d.ts","./node_modules/@types/three/src/geometries/WireframeGeometry.d.ts","./node_modules/@types/three/src/geometries/Geometries.d.ts","./node_modules/@types/three/src/objects/Line.d.ts","./node_modules/@types/three/src/helpers/ArrowHelper.d.ts","./node_modules/@types/three/src/objects/LineSegments.d.ts","./node_modules/@types/three/src/helpers/AxesHelper.d.ts","./node_modules/@types/three/src/helpers/Box3Helper.d.ts","./node_modules/@types/three/src/helpers/BoxHelper.d.ts","./node_modules/@types/three/src/helpers/CameraHelper.d.ts","./node_modules/@types/three/src/helpers/DirectionalLightHelper.d.ts","./node_modules/@types/three/src/helpers/GridHelper.d.ts","./node_modules/@types/three/src/helpers/HemisphereLightHelper.d.ts","./node_modules/@types/three/src/helpers/PlaneHelper.d.ts","./node_modules/@types/three/src/helpers/PointLightHelper.d.ts","./node_modules/@types/three/src/helpers/PolarGridHelper.d.ts","./node_modules/@types/three/src/helpers/SkeletonHelper.d.ts","./node_modules/@types/three/src/helpers/SpotLightHelper.d.ts","./node_modules/@types/three/src/loaders/LoadingManager.d.ts","./node_modules/@types/three/src/loaders/Loader.d.ts","./node_modules/@types/three/src/loaders/AnimationLoader.d.ts","./node_modules/@types/three/src/loaders/AudioLoader.d.ts","./node_modules/@types/three/src/loaders/BufferGeometryLoader.d.ts","./node_modules/@types/three/src/loaders/Cache.d.ts","./node_modules/@types/three/src/loaders/CompressedTextureLoader.d.ts","./node_modules/@types/three/src/loaders/CubeTextureLoader.d.ts","./node_modules/@types/three/src/loaders/DataTextureLoader.d.ts","./node_modules/@types/three/src/loaders/FileLoader.d.ts","./node_modules/@types/three/src/loaders/ImageBitmapLoader.d.ts","./node_modules/@types/three/src/loaders/ImageLoader.d.ts","./node_modules/@types/three/src/loaders/LoaderUtils.d.ts","./node_modules/@types/three/src/loaders/MaterialLoader.d.ts","./node_modules/@types/three/src/loaders/ObjectLoader.d.ts","./node_modules/@types/three/src/loaders/TextureLoader.d.ts","./node_modules/@types/three/src/math/FrustumArray.d.ts","./node_modules/@types/three/src/math/interpolants/QuaternionLinearInterpolant.d.ts","./node_modules/@types/three/src/math/MathUtils.d.ts","./node_modules/@types/three/src/objects/LineLoop.d.ts","./node_modules/@types/three/src/objects/LOD.d.ts","./node_modules/@types/three/src/objects/Points.d.ts","./node_modules/@types/three/src/textures/Data3DTexture.d.ts","./node_modules/@types/three/src/renderers/WebGL3DRenderTarget.d.ts","./node_modules/@types/three/src/textures/DataArrayTexture.d.ts","./node_modules/@types/three/src/renderers/WebGLArrayRenderTarget.d.ts","./node_modules/@types/three/src/textures/CanvasTexture.d.ts","./node_modules/@types/three/src/textures/CompressedArrayTexture.d.ts","./node_modules/@types/three/src/textures/CompressedCubeTexture.d.ts","./node_modules/@types/three/src/textures/VideoTexture.d.ts","./node_modules/@types/three/src/textures/VideoFrameTexture.d.ts","./node_modules/@types/three/src/Three.Core.d.ts","./node_modules/@types/three/src/extras/PMREMGenerator.d.ts","./node_modules/@types/three/src/renderers/shaders/ShaderChunk.d.ts","./node_modules/@types/three/src/renderers/shaders/ShaderLib.d.ts","./node_modules/@types/three/src/renderers/shaders/UniformsUtils.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLBufferRenderer.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLIndexedBufferRenderer.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLShader.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLUtils.d.ts","./node_modules/@types/three/src/renderers/webgl/WebGLTextures.d.ts","./node_modules/@types/three/src/renderers/webxr/WebXRDepthSensing.d.ts","./node_modules/@types/three/src/Three.d.ts","./node_modules/@types/three/build/three.module.d.ts","./node_modules/utility-types/dist/aliases-and-guards.d.ts","./node_modules/utility-types/dist/mapped-types.d.ts","./node_modules/utility-types/dist/utility-types.d.ts","./node_modules/utility-types/dist/functional-helpers.d.ts","./node_modules/utility-types/dist/index.d.ts","./node_modules/@react-three/fiber/dist/declarations/react-reconciler/index.d.ts","./node_modules/zustand/esm/vanilla.d.mts","./node_modules/zustand/esm/react.d.mts","./node_modules/zustand/esm/index.d.mts","./node_modules/zustand/esm/traditional.d.mts","./node_modules/@react-three/fiber/dist/declarations/src/core/store.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/reconciler.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/utils.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/events.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/hooks.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/loop.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/renderer.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/core/index.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/three-types.d.ts","./node_modules/react-use-measure/dist/index.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/web/Canvas.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/web/events.d.ts","./node_modules/@react-three/fiber/dist/declarations/src/index.d.ts","./node_modules/@react-three/fiber/dist/react-three-fiber.cjs.d.ts","./node_modules/@react-three/drei/helpers/ts-utils.d.ts","./node_modules/@react-three/drei/web/Html.d.ts","./node_modules/@react-three/drei/web/CycleRaycast.d.ts","./node_modules/@react-three/drei/web/useCursor.d.ts","./node_modules/@react-three/drei/web/Loader.d.ts","./node_modules/@react-three/drei/web/ScrollControls.d.ts","./node_modules/@react-three/drei/web/PresentationControls.d.ts","./node_modules/@react-three/drei/web/KeyboardControls.d.ts","./node_modules/@react-three/drei/web/Select.d.ts","./node_modules/@react-three/drei/core/Billboard.d.ts","./node_modules/@react-three/drei/core/ScreenSpace.d.ts","./node_modules/@react-three/drei/core/ScreenSizer.d.ts","./node_modules/three-stdlib/misc/MD2CharacterComplex.d.ts","./node_modules/three-stdlib/misc/ConvexObjectBreaker.d.ts","./node_modules/three-stdlib/misc/MorphBlendMesh.d.ts","./node_modules/three-stdlib/misc/GPUComputationRenderer.d.ts","./node_modules/three-stdlib/misc/Gyroscope.d.ts","./node_modules/three-stdlib/misc/MorphAnimMesh.d.ts","./node_modules/three-stdlib/misc/RollerCoaster.d.ts","./node_modules/three-stdlib/misc/Timer.d.ts","./node_modules/three-stdlib/misc/WebGL.d.ts","./node_modules/three-stdlib/misc/MD2Character.d.ts","./node_modules/three-stdlib/misc/Volume.d.ts","./node_modules/three-stdlib/misc/VolumeSlice.d.ts","./node_modules/three-stdlib/misc/TubePainter.d.ts","./node_modules/three-stdlib/misc/ProgressiveLightmap.d.ts","./node_modules/three-stdlib/renderers/CSS2DRenderer.d.ts","./node_modules/three-stdlib/renderers/CSS3DRenderer.d.ts","./node_modules/three-stdlib/renderers/Projector.d.ts","./node_modules/three-stdlib/renderers/SVGRenderer.d.ts","./node_modules/three-stdlib/textures/FlakesTexture.d.ts","./node_modules/three-stdlib/modifiers/CurveModifier.d.ts","./node_modules/three-stdlib/modifiers/SimplifyModifier.d.ts","./node_modules/three-stdlib/modifiers/EdgeSplitModifier.d.ts","./node_modules/three-stdlib/modifiers/TessellateModifier.d.ts","./node_modules/three-stdlib/exporters/GLTFExporter.d.ts","./node_modules/three-stdlib/exporters/USDZExporter.d.ts","./node_modules/three-stdlib/exporters/PLYExporter.d.ts","./node_modules/three-stdlib/exporters/DRACOExporter.d.ts","./node_modules/three-stdlib/exporters/ColladaExporter.d.ts","./node_modules/three-stdlib/exporters/MMDExporter.d.ts","./node_modules/three-stdlib/exporters/STLExporter.d.ts","./node_modules/three-stdlib/exporters/OBJExporter.d.ts","./node_modules/three-stdlib/environments/RoomEnvironment.d.ts","./node_modules/three-stdlib/animation/AnimationClipCreator.d.ts","./node_modules/three-stdlib/animation/CCDIKSolver.d.ts","./node_modules/three-stdlib/animation/MMDPhysics.d.ts","./node_modules/three-stdlib/animation/MMDAnimationHelper.d.ts","./node_modules/three-stdlib/objects/BatchedMesh.d.ts","./node_modules/three-stdlib/types/shared.d.ts","./node_modules/three-stdlib/objects/Reflector.d.ts","./node_modules/three-stdlib/objects/Refractor.d.ts","./node_modules/three-stdlib/objects/ShadowMesh.d.ts","./node_modules/three-stdlib/objects/Lensflare.d.ts","./node_modules/three-stdlib/objects/Water.d.ts","./node_modules/three-stdlib/objects/MarchingCubes.d.ts","./node_modules/three-stdlib/geometries/LightningStrike.d.ts","./node_modules/three-stdlib/objects/LightningStorm.d.ts","./node_modules/three-stdlib/objects/ReflectorRTT.d.ts","./node_modules/three-stdlib/objects/ReflectorForSSRPass.d.ts","./node_modules/three-stdlib/objects/Sky.d.ts","./node_modules/three-stdlib/objects/Water2.d.ts","./node_modules/three-stdlib/objects/GroundProjectedEnv.d.ts","./node_modules/three-stdlib/utils/SceneUtils.d.ts","./node_modules/three-stdlib/utils/UVsDebug.d.ts","./node_modules/three-stdlib/utils/GeometryUtils.d.ts","./node_modules/three-stdlib/utils/RoughnessMipmapper.d.ts","./node_modules/three-stdlib/utils/SkeletonUtils.d.ts","./node_modules/three-stdlib/utils/ShadowMapViewer.d.ts","./node_modules/three-stdlib/utils/BufferGeometryUtils.d.ts","./node_modules/three-stdlib/utils/GeometryCompressionUtils.d.ts","./node_modules/three-stdlib/shaders/BokehShader2.d.ts","./node_modules/three-stdlib/cameras/CinematicCamera.d.ts","./node_modules/three-stdlib/math/ConvexHull.d.ts","./node_modules/three-stdlib/math/MeshSurfaceSampler.d.ts","./node_modules/three-stdlib/math/SimplexNoise.d.ts","./node_modules/three-stdlib/math/OBB.d.ts","./node_modules/three-stdlib/math/Capsule.d.ts","./node_modules/three-stdlib/math/ColorConverter.d.ts","./node_modules/three-stdlib/math/ImprovedNoise.d.ts","./node_modules/three-stdlib/math/Octree.d.ts","./node_modules/three-stdlib/math/Lut.d.ts","./node_modules/three-stdlib/controls/EventDispatcher.d.ts","./node_modules/three-stdlib/controls/experimental/CameraControls.d.ts","./node_modules/three-stdlib/controls/FirstPersonControls.d.ts","./node_modules/three-stdlib/controls/TransformControls.d.ts","./node_modules/three-stdlib/controls/DragControls.d.ts","./node_modules/three-stdlib/controls/PointerLockControls.d.ts","./node_modules/three-stdlib/controls/StandardControlsEventMap.d.ts","./node_modules/three-stdlib/controls/DeviceOrientationControls.d.ts","./node_modules/three-stdlib/controls/TrackballControls.d.ts","./node_modules/three-stdlib/controls/OrbitControls.d.ts","./node_modules/three-stdlib/controls/ArcballControls.d.ts","./node_modules/three-stdlib/controls/FlyControls.d.ts","./node_modules/three-stdlib/postprocessing/Pass.d.ts","./node_modules/three-stdlib/shaders/types.d.ts","./node_modules/three-stdlib/postprocessing/ShaderPass.d.ts","./node_modules/three-stdlib/postprocessing/LUTPass.d.ts","./node_modules/three-stdlib/postprocessing/ClearPass.d.ts","./node_modules/three-stdlib/shaders/DigitalGlitch.d.ts","./node_modules/three-stdlib/postprocessing/GlitchPass.d.ts","./node_modules/three-stdlib/postprocessing/HalftonePass.d.ts","./node_modules/three-stdlib/postprocessing/SMAAPass.d.ts","./node_modules/three-stdlib/shaders/FilmShader.d.ts","./node_modules/three-stdlib/postprocessing/FilmPass.d.ts","./node_modules/three-stdlib/postprocessing/OutlinePass.d.ts","./node_modules/three-stdlib/postprocessing/SSAOPass.d.ts","./node_modules/three-stdlib/postprocessing/SavePass.d.ts","./node_modules/three-stdlib/postprocessing/BokehPass.d.ts","./node_modules/three-stdlib/postprocessing/TexturePass.d.ts","./node_modules/three-stdlib/postprocessing/AdaptiveToneMappingPass.d.ts","./node_modules/three-stdlib/postprocessing/UnrealBloomPass.d.ts","./node_modules/three-stdlib/postprocessing/CubeTexturePass.d.ts","./node_modules/three-stdlib/postprocessing/SAOPass.d.ts","./node_modules/three-stdlib/shaders/AfterimageShader.d.ts","./node_modules/three-stdlib/postprocessing/AfterimagePass.d.ts","./node_modules/three-stdlib/postprocessing/MaskPass.d.ts","./node_modules/three-stdlib/postprocessing/EffectComposer.d.ts","./node_modules/three-stdlib/shaders/DotScreenShader.d.ts","./node_modules/three-stdlib/postprocessing/DotScreenPass.d.ts","./node_modules/three-stdlib/postprocessing/SSRPass.d.ts","./node_modules/three-stdlib/postprocessing/SSAARenderPass.d.ts","./node_modules/three-stdlib/postprocessing/TAARenderPass.d.ts","./node_modules/three-stdlib/postprocessing/RenderPass.d.ts","./node_modules/three-stdlib/postprocessing/RenderPixelatedPass.d.ts","./node_modules/three-stdlib/shaders/ConvolutionShader.d.ts","./node_modules/three-stdlib/postprocessing/BloomPass.d.ts","./node_modules/three-stdlib/postprocessing/WaterPass.d.ts","./node_modules/three-stdlib/webxr/ARButton.d.ts","./node_modules/three-stdlib/webxr/XRHandMeshModel.d.ts","./node_modules/three-stdlib/webxr/OculusHandModel.d.ts","./node_modules/three-stdlib/webxr/OculusHandPointerModel.d.ts","./node_modules/three-stdlib/webxr/Text2D.d.ts","./node_modules/three-stdlib/webxr/VRButton.d.ts","./node_modules/three-stdlib/loaders/DRACOLoader.d.ts","./node_modules/three-stdlib/loaders/KTX2Loader.d.ts","./node_modules/three-stdlib/loaders/GLTFLoader.d.ts","./node_modules/three-stdlib/libs/MotionControllers.d.ts","./node_modules/three-stdlib/webxr/XRControllerModelFactory.d.ts","./node_modules/three-stdlib/webxr/XREstimatedLight.d.ts","./node_modules/three-stdlib/webxr/XRHandPrimitiveModel.d.ts","./node_modules/three-stdlib/webxr/XRHandModelFactory.d.ts","./node_modules/three-stdlib/geometries/ParametricGeometry.d.ts","./node_modules/three-stdlib/geometries/ParametricGeometries.d.ts","./node_modules/three-stdlib/geometries/ConvexGeometry.d.ts","./node_modules/three-stdlib/geometries/RoundedBoxGeometry.d.ts","./node_modules/three-stdlib/geometries/BoxLineGeometry.d.ts","./node_modules/three-stdlib/geometries/DecalGeometry.d.ts","./node_modules/three-stdlib/geometries/TeapotGeometry.d.ts","./node_modules/three-stdlib/loaders/FontLoader.d.ts","./node_modules/three-stdlib/geometries/TextGeometry.d.ts","./node_modules/three-stdlib/csm/CSMFrustum.d.ts","./node_modules/three-stdlib/csm/CSM.d.ts","./node_modules/three-stdlib/csm/CSMHelper.d.ts","./node_modules/three-stdlib/csm/CSMShader.d.ts","./node_modules/three-stdlib/shaders/ACESFilmicToneMappingShader.d.ts","./node_modules/three-stdlib/shaders/BasicShader.d.ts","./node_modules/three-stdlib/shaders/BleachBypassShader.d.ts","./node_modules/three-stdlib/shaders/BlendShader.d.ts","./node_modules/three-stdlib/shaders/BokehShader.d.ts","./node_modules/three-stdlib/shaders/BrightnessContrastShader.d.ts","./node_modules/three-stdlib/shaders/ColorCorrectionShader.d.ts","./node_modules/three-stdlib/shaders/ColorifyShader.d.ts","./node_modules/three-stdlib/shaders/CopyShader.d.ts","./node_modules/three-stdlib/shaders/DOFMipMapShader.d.ts","./node_modules/three-stdlib/shaders/DepthLimitedBlurShader.d.ts","./node_modules/three-stdlib/shaders/FXAAShader.d.ts","./node_modules/three-stdlib/shaders/FocusShader.d.ts","./node_modules/three-stdlib/shaders/FreiChenShader.d.ts","./node_modules/three-stdlib/shaders/FresnelShader.d.ts","./node_modules/three-stdlib/shaders/GammaCorrectionShader.d.ts","./node_modules/three-stdlib/shaders/GodRaysShader.d.ts","./node_modules/three-stdlib/shaders/HalftoneShader.d.ts","./node_modules/three-stdlib/shaders/HorizontalBlurShader.d.ts","./node_modules/three-stdlib/shaders/HorizontalTiltShiftShader.d.ts","./node_modules/three-stdlib/shaders/HueSaturationShader.d.ts","./node_modules/three-stdlib/shaders/KaleidoShader.d.ts","./node_modules/three-stdlib/shaders/LuminosityHighPassShader.d.ts","./node_modules/three-stdlib/shaders/LuminosityShader.d.ts","./node_modules/three-stdlib/shaders/MirrorShader.d.ts","./node_modules/three-stdlib/shaders/NormalMapShader.d.ts","./node_modules/three-stdlib/shaders/ParallaxShader.d.ts","./node_modules/three-stdlib/shaders/PixelShader.d.ts","./node_modules/three-stdlib/shaders/RGBShiftShader.d.ts","./node_modules/three-stdlib/shaders/SAOShader.d.ts","./node_modules/three-stdlib/shaders/SMAAShader.d.ts","./node_modules/three-stdlib/shaders/SSAOShader.d.ts","./node_modules/three-stdlib/shaders/SSRShader.d.ts","./node_modules/three-stdlib/shaders/SepiaShader.d.ts","./node_modules/three-stdlib/shaders/SobelOperatorShader.d.ts","./node_modules/three-stdlib/shaders/SubsurfaceScatteringShader.d.ts","./node_modules/three-stdlib/shaders/TechnicolorShader.d.ts","./node_modules/three-stdlib/shaders/ToneMapShader.d.ts","./node_modules/three-stdlib/shaders/ToonShader.d.ts","./node_modules/three-stdlib/shaders/TriangleBlurShader.d.ts","./node_modules/three-stdlib/shaders/UnpackDepthRGBAShader.d.ts","./node_modules/three-stdlib/shaders/VerticalBlurShader.d.ts","./node_modules/three-stdlib/shaders/VerticalTiltShiftShader.d.ts","./node_modules/three-stdlib/shaders/VignetteShader.d.ts","./node_modules/three-stdlib/shaders/VolumeShader.d.ts","./node_modules/three-stdlib/shaders/WaterRefractionShader.d.ts","./node_modules/three-stdlib/interactive/HTMLMesh.d.ts","./node_modules/three-stdlib/interactive/InteractiveGroup.d.ts","./node_modules/three-stdlib/interactive/SelectionBox.d.ts","./node_modules/three-stdlib/interactive/SelectionHelper.d.ts","./node_modules/three-stdlib/physics/AmmoPhysics.d.ts","./node_modules/three-stdlib/effects/ParallaxBarrierEffect.d.ts","./node_modules/three-stdlib/effects/PeppersGhostEffect.d.ts","./node_modules/three-stdlib/effects/OutlineEffect.d.ts","./node_modules/three-stdlib/effects/AnaglyphEffect.d.ts","./node_modules/three-stdlib/effects/AsciiEffect.d.ts","./node_modules/three-stdlib/effects/StereoEffect.d.ts","./node_modules/three-stdlib/loaders/FBXLoader.d.ts","./node_modules/three-stdlib/loaders/TGALoader.d.ts","./node_modules/three-stdlib/loaders/LUTCubeLoader.d.ts","./node_modules/three-stdlib/loaders/NRRDLoader.d.ts","./node_modules/three-stdlib/loaders/STLLoader.d.ts","./node_modules/three-stdlib/loaders/MTLLoader.d.ts","./node_modules/three-stdlib/loaders/XLoader.d.ts","./node_modules/three-stdlib/loaders/BVHLoader.d.ts","./node_modules/three-stdlib/loaders/ColladaLoader.d.ts","./node_modules/three-stdlib/loaders/KMZLoader.d.ts","./node_modules/three-stdlib/loaders/VRMLoader.d.ts","./node_modules/three-stdlib/loaders/VRMLLoader.d.ts","./node_modules/three-stdlib/loaders/LottieLoader.d.ts","./node_modules/three-stdlib/loaders/TTFLoader.d.ts","./node_modules/three-stdlib/loaders/RGBELoader.d.ts","./node_modules/three-stdlib/loaders/AssimpLoader.d.ts","./node_modules/three-stdlib/loaders/MDDLoader.d.ts","./node_modules/three-stdlib/loaders/EXRLoader.d.ts","./node_modules/three-stdlib/loaders/3MFLoader.d.ts","./node_modules/three-stdlib/loaders/XYZLoader.d.ts","./node_modules/three-stdlib/loaders/VTKLoader.d.ts","./node_modules/three-stdlib/loaders/LUT3dlLoader.d.ts","./node_modules/three-stdlib/loaders/DDSLoader.d.ts","./node_modules/three-stdlib/loaders/PVRLoader.d.ts","./node_modules/three-stdlib/loaders/GCodeLoader.d.ts","./node_modules/three-stdlib/loaders/BasisTextureLoader.d.ts","./node_modules/three-stdlib/loaders/TDSLoader.d.ts","./node_modules/three-stdlib/loaders/LDrawLoader.d.ts","./node_modules/three-stdlib/loaders/SVGLoader.d.ts","./node_modules/three-stdlib/loaders/3DMLoader.d.ts","./node_modules/three-stdlib/loaders/OBJLoader.d.ts","./node_modules/three-stdlib/loaders/AMFLoader.d.ts","./node_modules/three-stdlib/loaders/MMDLoader.d.ts","./node_modules/three-stdlib/loaders/MD2Loader.d.ts","./node_modules/three-stdlib/loaders/KTXLoader.d.ts","./node_modules/three-stdlib/loaders/TiltLoader.d.ts","./node_modules/three-stdlib/loaders/HDRCubeTextureLoader.d.ts","./node_modules/three-stdlib/loaders/PDBLoader.d.ts","./node_modules/three-stdlib/loaders/PRWMLoader.d.ts","./node_modules/three-stdlib/loaders/RGBMLoader.d.ts","./node_modules/three-stdlib/loaders/VOXLoader.d.ts","./node_modules/three-stdlib/loaders/PCDLoader.d.ts","./node_modules/three-stdlib/loaders/LWOLoader.d.ts","./node_modules/three-stdlib/loaders/PLYLoader.d.ts","./node_modules/three-stdlib/lines/LineSegmentsGeometry.d.ts","./node_modules/three-stdlib/lines/LineGeometry.d.ts","./node_modules/three-stdlib/lines/LineMaterial.d.ts","./node_modules/three-stdlib/lines/Wireframe.d.ts","./node_modules/three-stdlib/lines/WireframeGeometry2.d.ts","./node_modules/three-stdlib/lines/LineSegments2.d.ts","./node_modules/three-stdlib/lines/Line2.d.ts","./node_modules/three-stdlib/helpers/LightProbeHelper.d.ts","./node_modules/three-stdlib/helpers/RaycasterHelper.d.ts","./node_modules/three-stdlib/helpers/VertexTangentsHelper.d.ts","./node_modules/three-stdlib/helpers/PositionalAudioHelper.d.ts","./node_modules/three-stdlib/helpers/VertexNormalsHelper.d.ts","./node_modules/three-stdlib/helpers/RectAreaLightHelper.d.ts","./node_modules/three-stdlib/lights/RectAreaLightUniformsLib.d.ts","./node_modules/three-stdlib/lights/LightProbeGenerator.d.ts","./node_modules/three-stdlib/curves/NURBSUtils.d.ts","./node_modules/three-stdlib/curves/NURBSCurve.d.ts","./node_modules/three-stdlib/curves/NURBSSurface.d.ts","./node_modules/three-stdlib/curves/CurveExtras.d.ts","./node_modules/three-stdlib/deprecated/Geometry.d.ts","./node_modules/three-stdlib/libs/MeshoptDecoder.d.ts","./node_modules/three-stdlib/index.d.ts","./node_modules/@react-three/drei/core/Line.d.ts","./node_modules/@react-three/drei/core/QuadraticBezierLine.d.ts","./node_modules/@react-three/drei/core/CubicBezierLine.d.ts","./node_modules/@react-three/drei/core/CatmullRomLine.d.ts","./node_modules/@react-three/drei/core/PositionalAudio.d.ts","./node_modules/@react-three/drei/core/Text.d.ts","./node_modules/@react-three/drei/core/useFont.d.ts","./node_modules/@react-three/drei/core/Text3D.d.ts","./node_modules/@react-three/drei/core/Effects.d.ts","./node_modules/@react-three/drei/core/GradientTexture.d.ts","./node_modules/@react-three/drei/core/Image.d.ts","./node_modules/@react-three/drei/core/Edges.d.ts","./node_modules/@react-three/drei/core/Outlines.d.ts","./node_modules/meshline/dist/MeshLineGeometry.d.ts","./node_modules/meshline/dist/MeshLineMaterial.d.ts","./node_modules/meshline/dist/raycast.d.ts","./node_modules/meshline/dist/index.d.ts","./node_modules/@react-three/drei/core/Trail.d.ts","./node_modules/@react-three/drei/core/Sampler.d.ts","./node_modules/@react-three/drei/core/ComputedAttribute.d.ts","./node_modules/@react-three/drei/core/Clone.d.ts","./node_modules/@react-three/drei/core/MarchingCubes.d.ts","./node_modules/@react-three/drei/core/Decal.d.ts","./node_modules/@react-three/drei/core/Svg.d.ts","./node_modules/@react-three/drei/core/Gltf.d.ts","./node_modules/@react-three/drei/core/AsciiRenderer.d.ts","./node_modules/@react-three/drei/core/Splat.d.ts","./node_modules/@react-three/drei/core/OrthographicCamera.d.ts","./node_modules/@react-three/drei/core/PerspectiveCamera.d.ts","./node_modules/@react-three/drei/core/CubeCamera.d.ts","./node_modules/@react-three/drei/core/DeviceOrientationControls.d.ts","./node_modules/@react-three/drei/core/FlyControls.d.ts","./node_modules/@react-three/drei/core/MapControls.d.ts","./node_modules/@react-three/drei/core/OrbitControls.d.ts","./node_modules/@react-three/drei/core/TrackballControls.d.ts","./node_modules/@react-three/drei/core/ArcballControls.d.ts","./node_modules/@react-three/drei/core/TransformControls.d.ts","./node_modules/@react-three/drei/core/PointerLockControls.d.ts","./node_modules/@react-three/drei/core/FirstPersonControls.d.ts","./node_modules/camera-controls/dist/index.d.ts","./node_modules/@react-three/drei/core/CameraControls.d.ts","./node_modules/@react-three/drei/core/MotionPathControls.d.ts","./node_modules/@react-three/drei/core/GizmoHelper.d.ts","./node_modules/@react-three/drei/core/GizmoViewcube.d.ts","./node_modules/@react-three/drei/core/GizmoViewport.d.ts","./node_modules/@react-three/drei/core/Grid.d.ts","./node_modules/@react-three/drei/core/CubeTexture.d.ts","./node_modules/@react-three/drei/core/Fbx.d.ts","./node_modules/@react-three/drei/core/Ktx2.d.ts","./node_modules/@react-three/drei/core/Progress.d.ts","./node_modules/@react-three/drei/core/Texture.d.ts","./node_modules/hls.js/dist/hls.d.mts","./node_modules/@react-three/drei/core/VideoTexture.d.ts","./node_modules/@react-three/drei/core/useSpriteLoader.d.ts","./node_modules/@react-three/drei/core/Helper.d.ts","./node_modules/@react-three/drei/core/Stats.d.ts","./node_modules/stats-gl/dist/stats-gl.d.ts","./node_modules/@react-three/drei/core/StatsGl.d.ts","./node_modules/@react-three/drei/core/useDepthBuffer.d.ts","./node_modules/@react-three/drei/core/useAspect.d.ts","./node_modules/@react-three/drei/core/useCamera.d.ts","./node_modules/detect-gpu/dist/src/index.d.ts","./node_modules/@react-three/drei/core/DetectGPU.d.ts","./node_modules/three-mesh-bvh/src/index.d.ts","./node_modules/@react-three/drei/core/Bvh.d.ts","./node_modules/@react-three/drei/core/useContextBridge.d.ts","./node_modules/@react-three/drei/core/useAnimations.d.ts","./node_modules/@react-three/drei/core/Fbo.d.ts","./node_modules/@react-three/drei/core/useIntersect.d.ts","./node_modules/@react-three/drei/core/useBoxProjectedEnv.d.ts","./node_modules/@react-three/drei/core/BBAnchor.d.ts","./node_modules/@react-three/drei/core/TrailTexture.d.ts","./node_modules/@react-three/drei/core/Example.d.ts","./node_modules/@react-three/drei/core/Instances.d.ts","./node_modules/@react-three/drei/core/SpriteAnimator.d.ts","./node_modules/@react-three/drei/core/CurveModifier.d.ts","./node_modules/@react-three/drei/core/MeshDistortMaterial.d.ts","./node_modules/@react-three/drei/core/MeshWobbleMaterial.d.ts","./node_modules/@react-three/drei/materials/MeshReflectorMaterial.d.ts","./node_modules/@react-three/drei/core/MeshReflectorMaterial.d.ts","./node_modules/@react-three/drei/materials/MeshRefractionMaterial.d.ts","./node_modules/@react-three/drei/core/MeshRefractionMaterial.d.ts","./node_modules/@react-three/drei/core/MeshTransmissionMaterial.d.ts","./node_modules/@react-three/drei/core/MeshDiscardMaterial.d.ts","./node_modules/@react-three/drei/core/MultiMaterial.d.ts","./node_modules/@react-three/drei/core/PointMaterial.d.ts","./node_modules/@react-three/drei/core/shaderMaterial.d.ts","./node_modules/@react-three/drei/core/softShadows.d.ts","./node_modules/@react-three/drei/core/shapes.d.ts","./node_modules/@react-three/drei/core/RoundedBox.d.ts","./node_modules/@react-three/drei/core/ScreenQuad.d.ts","./node_modules/@react-three/drei/core/Center.d.ts","./node_modules/@react-three/drei/core/Resize.d.ts","./node_modules/@react-three/drei/core/Bounds.d.ts","./node_modules/@react-three/drei/core/CameraShake.d.ts","./node_modules/@react-three/drei/core/Float.d.ts","./node_modules/@react-three/drei/helpers/environment-assets.d.ts","./node_modules/@react-three/drei/core/useEnvironment.d.ts","./node_modules/@react-three/drei/core/Environment.d.ts","./node_modules/@react-three/drei/core/ContactShadows.d.ts","./node_modules/@react-three/drei/core/AccumulativeShadows.d.ts","./node_modules/@react-three/drei/core/Stage.d.ts","./node_modules/@react-three/drei/core/Backdrop.d.ts","./node_modules/@react-three/drei/core/Shadow.d.ts","./node_modules/@react-three/drei/core/Caustics.d.ts","./node_modules/@react-three/drei/core/SpotLight.d.ts","./node_modules/@react-three/drei/core/Lightformer.d.ts","./node_modules/@react-three/drei/core/Sky.d.ts","./node_modules/@react-three/drei/core/Stars.d.ts","./node_modules/@react-three/drei/core/Cloud.d.ts","./node_modules/@react-three/drei/core/Sparkles.d.ts","./node_modules/@react-three/drei/core/MatcapTexture.d.ts","./node_modules/@react-three/drei/core/NormalTexture.d.ts","./node_modules/@react-three/drei/materials/WireframeMaterial.d.ts","./node_modules/@react-three/drei/core/Wireframe.d.ts","./node_modules/@react-three/drei/core/ShadowAlpha.d.ts","./node_modules/@react-three/drei/core/Points.d.ts","./node_modules/@react-three/drei/core/Segments.d.ts","./node_modules/@react-three/drei/core/Detailed.d.ts","./node_modules/@react-three/drei/core/Preload.d.ts","./node_modules/@react-three/drei/core/BakeShadows.d.ts","./node_modules/@react-three/drei/core/meshBounds.d.ts","./node_modules/@react-three/drei/core/AdaptiveDpr.d.ts","./node_modules/@react-three/drei/core/AdaptiveEvents.d.ts","./node_modules/@react-three/drei/core/PerformanceMonitor.d.ts","./node_modules/@react-three/drei/core/RenderTexture.d.ts","./node_modules/@react-three/drei/core/RenderCubeTexture.d.ts","./node_modules/@react-three/drei/core/Mask.d.ts","./node_modules/@react-three/drei/core/Hud.d.ts","./node_modules/@react-three/drei/core/Fisheye.d.ts","./node_modules/@react-three/drei/core/MeshPortalMaterial.d.ts","./node_modules/@react-three/drei/core/calculateScaleFactor.d.ts","./node_modules/@react-three/drei/core/index.d.ts","./node_modules/@react-three/drei/web/View.d.ts","./node_modules/@react-three/drei/web/pivotControls/context.d.ts","./node_modules/@react-three/drei/web/pivotControls/index.d.ts","./node_modules/@react-three/drei/web/ScreenVideoTexture.d.ts","./node_modules/@react-three/drei/web/WebcamVideoTexture.d.ts","./node_modules/@mediapipe/tasks-vision/vision.d.ts","./node_modules/@react-three/drei/web/Facemesh.d.ts","./node_modules/@react-three/drei/web/FaceControls.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/utils.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/state.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/config.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/internalConfig.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/handlers.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/config/resolver.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/EventStore.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/TimeoutStore.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/Controller.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/engines/Engine.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/action.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types/index.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/types.d.ts","./node_modules/@use-gesture/core/types/dist/use-gesture-core-types.cjs.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/types.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useDrag.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/usePinch.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useWheel.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useScroll.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useMove.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useHover.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/useGesture.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/createUseGesture.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/utils/maths.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/utils.d.ts","./node_modules/@use-gesture/core/utils/dist/use-gesture-core-utils.cjs.d.ts","./node_modules/@use-gesture/core/dist/declarations/src/actions.d.ts","./node_modules/@use-gesture/core/actions/dist/use-gesture-core-actions.cjs.d.ts","./node_modules/@use-gesture/react/dist/declarations/src/index.d.ts","./node_modules/@use-gesture/react/dist/use-gesture-react.cjs.d.ts","./node_modules/@react-three/drei/web/DragControls.d.ts","./node_modules/@react-three/drei/web/FaceLandmarker.d.ts","./node_modules/@react-three/drei/web/index.d.ts","./node_modules/@react-three/drei/index.d.ts","./src/routes/archive/2023.OnOrbits.tsx","./node_modules/@react-pdf/font/lib/index.d.ts","./node_modules/@react-pdf/types/pdf.d.ts","./node_modules/@react-pdf/types/svg.d.ts","./node_modules/@react-pdf/stylesheet/lib/index.d.ts","./node_modules/@react-pdf/types/style.d.ts","./node_modules/@react-pdf/primitives/lib/index.d.ts","./node_modules/@react-pdf/types/primitive.d.ts","./node_modules/@react-pdf/types/font.d.ts","./node_modules/@react-pdf/types/page.d.ts","./node_modules/@react-pdf/types/bookmark.d.ts","./node_modules/@react-pdf/types/node.d.ts","./node_modules/@react-pdf/types/image.d.ts","./node_modules/@react-pdf/types/context.d.ts","./node_modules/@react-pdf/types/index.d.ts","./node_modules/@react-pdf/renderer/lib/react-pdf.d.ts","./src/lib/post/Book.tsx","./src/lib/post/Post.tsx","./src/@orbitmines/js/react/Modules.tsx","./src/@orbitmines/js/react/IModule.ts","./src/lib/prism/ray.ts","./src/@ether/UI/pages/Placeholder.tsx","./src/@ether/UI/pages/language/ErrorsPanel.tsx","./src/@ether/UI/pages/language/LanguageList.tsx","./src/@ether/UI/pages/language/ProgramPanel.tsx","./src/@ether/UI/pages/language/SidebarPanel.tsx","./src/@ether/UI/pages/language/LanguageCreator.tsx","./src/@ether/UI/pages/language/LangPage.tsx","./src/@ether/UI/pages/library/icons.tsx","./src/@ether/UI/pages/library/Socials.tsx","./src/@ether/UI/pages/library/DisplayPanel.tsx","./src/@ether/UI/pages/library/Dropdown.tsx","./src/@ether/UI/pages/library/SelectionContext.tsx","./src/@ether/UI/pages/library/EntryView.tsx","./src/@ether/UI/pages/library/ProjectList.tsx","./src/@ether/UI/pages/library/SettingsPanel.tsx","./src/@ether/UI/pages/library/Library.tsx","./src/@ether/UI/pages/pullrequests/Header.tsx","./src/@ether/UI/pages/pullrequests/CategoryView.tsx","./src/@ether/UI/pages/pullrequests/CommitDiff.tsx","./src/@ether/UI/pages/pullrequests/DetailView.tsx","./src/@ether/UI/pages/pullrequests/ListView.tsx","./src/@ether/UI/pages/pullrequests/NewPRForm.tsx","./src/@ether/UI/pages/pullrequests/PullRequests.tsx","./src/@ether/UI/pages/repository/AccessBadge.tsx","./src/@ether/UI/pages/repository/ClonePopup.tsx","./src/@ether/UI/pages/repository/ActionButtons.tsx","./src/@ether/UI/pages/repository/Breadcrumb.tsx","./src/@ether/UI/pages/repository/FileListing.tsx","./src/@ether/UI/pages/repository/FileViewer.tsx","./src/@ether/UI/pages/repository/IframeMount.tsx","./src/@ether/UI/pages/repository/ProfileNames.tsx","./src/routes/profiles/fadi-shawki/FadiShawki.tsx","./src/@ether/UI/pages/repository/userDefaults.tsx","./src/@ether/UI/pages/repository/Profile.tsx","./src/@ether/UI/pages/repository/Sidebar.tsx","./src/@ether/UI/pages/repository/Repository.tsx","./src/@ether/UI/pages/settings/Settings.tsx","./src/@ether/UI/router/EtherRoutes.tsx","./src/@orbitmines/ether/Ether.tsx","./src/routes/Minimap.tsx","./src/@ether/UI/router/EtherOrMinimap.tsx","./src/lib/post/ImageGallery.tsx","./src/routes/Almanac.tsx","./src/routes/Error.tsx","./src/routes/archive/2024.02.OrbitMines_as_a_Game_Project.tsx","./src/routes/archive/2022.OnIntelligibility.tsx","./src/routes/archive/2025.TowardsAUniversalLanguage.tsx","./src/routes/archive/2026.MinecraftArchive.tsx","./src/routes/archive/2026.RayCalculiAndPhysics.tsx","./src/routes/Archive.tsx","./src/routes/archive/Physics.tsx","./src/routes/archive/Physics2.tsx","./src/routes/profiles/Profiles.tsx","./app/almanac/[[...section]]/AlmanacClient.tsx","./app/almanac/[[...section]]/page.tsx","./app/archive/[item]/ArchiveClient.tsx","./app/archive/[item]/page.tsx","./app/profiles/[profile]/ProfileRedirect.tsx","./app/profiles/[profile]/page.tsx","./app/sitemap.ts","./app/Providers.tsx","./app/layout.tsx","./app/not-found.tsx","./app/page.tsx","./app/[...path]/CatchAllClient.tsx","./app/[...path]/page.tsx","./app/papers/[[...slug]]/PapersRedirect.tsx","./app/papers/[[...slug]]/page.tsx","./app/thumbnail/ThumbnailClient.tsx","./app/thumbnail/page.tsx","./.next/types/cache-life.d.ts","./.next/types/routes.d.ts","./.next/types/validator.ts","./.next/dev/types/cache-life.d.ts","./.next/dev/types/validator.ts","./node_modules/@types/draco3d/index.d.ts","./node_modules/@types/istanbul-lib-coverage/index.d.ts","./node_modules/@types/istanbul-lib-report/index.d.ts","./node_modules/@types/istanbul-reports/index.d.ts","./node_modules/@jest/expect-utils/build/index.d.ts","./node_modules/chalk/index.d.ts","./node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.d.mts","./node_modules/@sinclair/typebox/build/esm/type/symbols/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/any/any.d.mts","./node_modules/@sinclair/typebox/build/esm/type/any/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.d.mts","./node_modules/@sinclair/typebox/build/esm/type/async-iterator/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/readonly/readonly.d.mts","./node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/readonly/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.d.mts","./node_modules/@sinclair/typebox/build/esm/type/readonly-optional/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.d.mts","./node_modules/@sinclair/typebox/build/esm/type/constructor/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/literal/literal.d.mts","./node_modules/@sinclair/typebox/build/esm/type/literal/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/enum/enum.d.mts","./node_modules/@sinclair/typebox/build/esm/type/enum/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/function/function.d.mts","./node_modules/@sinclair/typebox/build/esm/type/function/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/computed/computed.d.mts","./node_modules/@sinclair/typebox/build/esm/type/computed/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/never/never.d.mts","./node_modules/@sinclair/typebox/build/esm/type/never/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intersect/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/union/union-type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.d.mts","./node_modules/@sinclair/typebox/build/esm/type/union/union.d.mts","./node_modules/@sinclair/typebox/build/esm/type/union/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.d.mts","./node_modules/@sinclair/typebox/build/esm/type/recursive/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.d.mts","./node_modules/@sinclair/typebox/build/esm/type/unsafe/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/ref/ref.d.mts","./node_modules/@sinclair/typebox/build/esm/type/ref/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.d.mts","./node_modules/@sinclair/typebox/build/esm/type/tuple/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/error/error.d.mts","./node_modules/@sinclair/typebox/build/esm/type/error/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/string/string.d.mts","./node_modules/@sinclair/typebox/build/esm/type/string/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.d.mts","./node_modules/@sinclair/typebox/build/esm/type/boolean/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/number/number.d.mts","./node_modules/@sinclair/typebox/build/esm/type/number/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/integer/integer.d.mts","./node_modules/@sinclair/typebox/build/esm/type/integer/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.d.mts","./node_modules/@sinclair/typebox/build/esm/type/bigint/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/template-literal.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/union.d.mts","./node_modules/@sinclair/typebox/build/esm/type/template-literal/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.d.mts","./node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.d.mts","./node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/indexed/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.d.mts","./node_modules/@sinclair/typebox/build/esm/type/iterator/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/promise/promise.d.mts","./node_modules/@sinclair/typebox/build/esm/type/promise/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/sets/set.d.mts","./node_modules/@sinclair/typebox/build/esm/type/sets/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/mapped/mapped.d.mts","./node_modules/@sinclair/typebox/build/esm/type/mapped/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/optional/optional.d.mts","./node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/optional/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.d.mts","./node_modules/@sinclair/typebox/build/esm/type/awaited/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.d.mts","./node_modules/@sinclair/typebox/build/esm/type/keyof/keyof.d.mts","./node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-entries.d.mts","./node_modules/@sinclair/typebox/build/esm/type/keyof/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/omit/omit.d.mts","./node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/omit/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/pick/pick.d.mts","./node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/pick/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/null/null.d.mts","./node_modules/@sinclair/typebox/build/esm/type/null/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.d.mts","./node_modules/@sinclair/typebox/build/esm/type/symbol/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.d.mts","./node_modules/@sinclair/typebox/build/esm/type/undefined/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/partial/partial.d.mts","./node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/partial/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.d.mts","./node_modules/@sinclair/typebox/build/esm/type/regexp/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/record/record.d.mts","./node_modules/@sinclair/typebox/build/esm/type/record/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/required/required.d.mts","./node_modules/@sinclair/typebox/build/esm/type/required/required-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/required/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/transform/transform.d.mts","./node_modules/@sinclair/typebox/build/esm/type/transform/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/module/compute.d.mts","./node_modules/@sinclair/typebox/build/esm/type/module/infer.d.mts","./node_modules/@sinclair/typebox/build/esm/type/module/module.d.mts","./node_modules/@sinclair/typebox/build/esm/type/module/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/not/not.d.mts","./node_modules/@sinclair/typebox/build/esm/type/not/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/static/static.d.mts","./node_modules/@sinclair/typebox/build/esm/type/static/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/object/object.d.mts","./node_modules/@sinclair/typebox/build/esm/type/object/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/helpers/helpers.d.mts","./node_modules/@sinclair/typebox/build/esm/type/helpers/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/array/array.d.mts","./node_modules/@sinclair/typebox/build/esm/type/array/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/date/date.d.mts","./node_modules/@sinclair/typebox/build/esm/type/date/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.d.mts","./node_modules/@sinclair/typebox/build/esm/type/uint8array/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.d.mts","./node_modules/@sinclair/typebox/build/esm/type/unknown/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/void/void.d.mts","./node_modules/@sinclair/typebox/build/esm/type/void/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/schema/schema.d.mts","./node_modules/@sinclair/typebox/build/esm/type/schema/anyschema.d.mts","./node_modules/@sinclair/typebox/build/esm/type/schema/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/clone/type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/clone/value.d.mts","./node_modules/@sinclair/typebox/build/esm/type/clone/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/create/type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/create/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/argument/argument.d.mts","./node_modules/@sinclair/typebox/build/esm/type/argument/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/guard/kind.d.mts","./node_modules/@sinclair/typebox/build/esm/type/guard/type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/guard/value.d.mts","./node_modules/@sinclair/typebox/build/esm/type/guard/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.d.mts","./node_modules/@sinclair/typebox/build/esm/type/patterns/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/registry/format.d.mts","./node_modules/@sinclair/typebox/build/esm/type/registry/type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/registry/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/composite/composite.d.mts","./node_modules/@sinclair/typebox/build/esm/type/composite/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/const/const.d.mts","./node_modules/@sinclair/typebox/build/esm/type/const/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.d.mts","./node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-template-literal.d.mts","./node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.d.mts","./node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/exclude/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/extends-check.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/extends.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/extends-undefined.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extends/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extract/extract.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.d.mts","./node_modules/@sinclair/typebox/build/esm/type/extract/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/instance-type/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.d.mts","./node_modules/@sinclair/typebox/build/esm/type/instantiate/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic-from-mapped-key.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/lowercase.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/uncapitalize.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/uppercase.d.mts","./node_modules/@sinclair/typebox/build/esm/type/intrinsic/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.d.mts","./node_modules/@sinclair/typebox/build/esm/type/parameters/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/rest/rest.d.mts","./node_modules/@sinclair/typebox/build/esm/type/rest/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.d.mts","./node_modules/@sinclair/typebox/build/esm/type/return-type/index.d.mts","./node_modules/@sinclair/typebox/build/esm/type/type/json.d.mts","./node_modules/@sinclair/typebox/build/esm/type/type/javascript.d.mts","./node_modules/@sinclair/typebox/build/esm/type/type/index.d.mts","./node_modules/@sinclair/typebox/build/esm/index.d.mts","./node_modules/@jest/schemas/build/index.d.ts","./node_modules/pretty-format/build/index.d.ts","./node_modules/jest-diff/build/index.d.ts","./node_modules/jest-matcher-utils/build/index.d.ts","./node_modules/expect/node_modules/jest-mock/build/index.d.ts","./node_modules/expect/build/index.d.ts","./node_modules/@types/jest/index.d.ts","./node_modules/@types/offscreencanvas/index.d.ts","./node_modules/@types/react-reconciler/index.d.ts","./node_modules/@types/stack-utils/index.d.ts","./node_modules/@types/stats.js/index.d.ts","./node_modules/@types/three/index.d.ts","./node_modules/@types/yargs-parser/index.d.ts","./node_modules/@types/yargs/index.d.ts"],"fileIdsList":[[94,157,165,169,172,174,175,176,189,506,507,508,509,1648],[94,157,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,249,550,552,1098,1632,1634,1636,1639,1641,1643,1645,1647,1648,1651],[94,157,165,169,172,174,175,176,189,506,507,508,509,1651],[94,157,165,169,172,174,175,176,189,249,550,1098,1632,1634,1636,1639,1641,1643,1645,1647,1648,1649,1651],[85,94,157,165,169,172,174,175,176,189,249,567,621,634,1098,1575,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1618,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1636,1642,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1620,1648,1651],[94,157,165,169,172,174,175,176,181,189,249,551,636,1098,1631,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1627,1648,1651],[94,157,165,169,172,174,175,176,181,189,249,551,1098,1633,1648,1651],[94,157,165,169,172,174,175,176,189,249,548,551,1098,1638,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,540,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,551,1098,1644,1648,1651],[94,157,165,169,172,174,175,176,189,249,551,1098,1635,1648,1651],[94,157,165,169,172,174,175,176,181,189,249,551,1098,1632,1634,1636,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1574,1648,1651],[94,157,165,169,172,174,175,176,189,249,551,1098,1646,1648,1651],[94,157,165,169,172,174,175,176,189,551,552,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1850],[85,94,157,165,169,172,174,175,176,189,1571,1648,1651],[94,157,165,169,172,174,175,176,189,1558,1648,1651],[94,157,165,169,172,174,175,176,189,1559,1560,1562,1564,1565,1566,1567,1568,1569,1570,1648,1651],[94,157,165,169,172,174,175,176,189,1562,1564,1565,1566,1567,1648,1651],[94,157,165,169,172,174,175,176,189,1563,1648,1651],[94,157,165,169,172,174,175,176,189,1561,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1104,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1103,1104,1381,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1103,1389,1390,1392,1408,1427,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1103,1104,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1103,1104,1389,1390,1392,1408,1421,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1104,1648,1651],[94,157,165,169,172,174,175,176,189,1104,1381,1382,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1092,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1104,1381,1382,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1104,1381,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1443,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1381,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1478,1479,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1402,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1103,1104,1381,1389,1390,1392,1408,1427,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1381,1389,1390,1392,1402,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1084,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1092,1103,1104,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1103,1104,1389,1390,1392,1408,1427,1455,1458,1459,1460,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1462,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1088,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1092,1103,1389,1390,1392,1408,1427,1435,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1103,1389,1390,1392,1408,1427,1455,1458,1459,1461,1463,1464,1465,1473,1478,1480,1481,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1104,1438,1648,1651],[85,94,157,165,169,172,174,175,176,189,1103,1104,1389,1390,1392,1408,1427,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1104,1381,1388,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1104,1398,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1433,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1495,1496,1498,1499,1512,1648,1651],[94,157,165,169,172,174,175,176,189,1113,1114,1115,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1434,1435,1436,1437,1439,1440,1441,1442,1444,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1461,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1445,1478,1648,1651],[94,157,165,169,172,174,175,176,189,1381,1648,1651],[94,157,165,169,172,174,175,176,189,1555,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1104,1445,1552,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1434,1445,1520,1521,1648,1651],[85,94,157,165,169,172,174,175,176,189,1520,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1084,1103,1104,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1433,1434,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1104,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1105,1106,1107,1108,1109,1110,1111,1112,1514,1515,1517,1518,1519,1521,1522,1553,1554,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1104,1445,1516,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1090,1092,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1090,1091,1092,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1090,1091,1092,1093,1094,1095,1096,1648,1651],[94,157,165,169,172,174,175,176,189,711,1090,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1085,1090,1092,1093,1098,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1090,1091,1092,1093,1098,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,711,1079,1088,1089,1092,1093,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,1079,1090,1091,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1097,1098,1100,1101,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,215,216,217,218,219,249,479,501,546,1079,1092,1097,1445,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,1097,1098,1099,1648,1651],[94,157,165,169,172,174,175,176,189,1090,1093,1648,1651],[94,157,165,169,172,174,175,176,189,1102,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1662,1666,1669,1671,1673,1675,1677,1679,1683,1687,1691,1693,1695,1697,1699,1701,1703,1705,1707,1709,1711,1719,1724,1726,1728,1730,1732,1735,1737,1742,1746,1750,1752,1754,1756,1759,1761,1763,1766,1768,1772,1774,1776,1778,1780,1782,1784,1786,1788,1790,1793,1796,1798,1800,1804,1806,1809,1811,1813,1815,1819,1825,1829,1831,1833,1840,1842,1844,1846,1849],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1661],[94,157,165,169,172,174,175,176,189,1648,1651,1799],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1776,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1781],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1776,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1665],[94,157,165,169,172,174,175,176,189,1648,1651,1681,1687,1691,1697,1728,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1736],[94,157,165,169,172,174,175,176,189,1648,1651,1710],[94,157,165,169,172,174,175,176,189,1648,1651,1704],[94,157,165,169,172,174,175,176,189,1648,1651,1794,1795],[94,157,165,169,172,174,175,176,189,1648,1651,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1687,1724,1730,1742,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1810],[94,157,165,169,172,174,175,176,189,1648,1651,1659,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1680],[94,157,165,169,172,174,175,176,189,1648,1651,1662,1669,1675,1679,1683,1699,1711,1752,1754,1756,1778,1780,1784,1786,1788,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1812],[94,157,165,169,172,174,175,176,189,1648,1651,1673,1683,1699,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1814],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1669,1671,1735,1776,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1672],[94,157,165,169,172,174,175,176,189,1648,1651,1797],[94,157,165,169,172,174,175,176,189,1648,1651,1791],[94,157,165,169,172,174,175,176,189,1648,1651,1783],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1675,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1676],[94,157,165,169,172,174,175,176,189,1648,1651,1700],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1778,1793,1817],[94,157,165,169,172,174,175,176,189,1648,1651,1719,1793,1817],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1691,1719,1732,1776,1780,1793,1816,1818],[94,157,165,169,172,174,175,176,189,1648,1651,1816,1817,1818],[94,157,165,169,172,174,175,176,189,1648,1651,1701,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1732,1778,1780,1793,1822],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1778,1793,1822],[94,157,165,169,172,174,175,176,189,1648,1651,1691,1732,1776,1780,1793,1821,1823],[94,157,165,169,172,174,175,176,189,1648,1651,1820,1821,1822,1823,1824],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1778,1793,1827],[94,157,165,169,172,174,175,176,189,1648,1651,1719,1793,1827],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1691,1719,1732,1776,1780,1793,1826,1828],[94,157,165,169,172,174,175,176,189,1648,1651,1826,1827,1828],[94,157,165,169,172,174,175,176,189,1648,1651,1678],[94,157,165,169,172,174,175,176,189,1648,1651,1801,1802,1803],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1662,1666,1669,1673,1675,1679,1681,1683,1687,1691,1693,1695,1697,1699,1703,1705,1707,1709,1711,1719,1726,1728,1732,1735,1752,1754,1756,1761,1763,1768,1772,1774,1778,1782,1784,1786,1788,1790,1793,1800],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1662,1666,1669,1673,1675,1679,1681,1683,1687,1691,1693,1695,1697,1699,1701,1703,1705,1707,1709,1711,1719,1726,1728,1732,1735,1752,1754,1756,1761,1763,1768,1772,1774,1778,1782,1784,1786,1788,1790,1793,1800],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1779],[94,157,165,169,172,174,175,176,189,1648,1651,1720,1721,1722,1723],[94,157,165,169,172,174,175,176,189,1648,1651,1722,1732,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1720,1724,1732,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1707,1709,1719,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1681,1683,1687,1691,1693,1697,1699,1720,1721,1723,1732,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1830],[94,157,165,169,172,174,175,176,189,1648,1651,1673,1683,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1832],[94,157,165,169,172,174,175,176,189,1648,1651,1666,1669,1671,1673,1679,1687,1691,1699,1726,1728,1735,1763,1778,1782,1788,1793,1800],[94,157,165,169,172,174,175,176,189,1648,1651,1708],[94,157,165,169,172,174,175,176,189,1648,1651,1684,1685,1686],[94,157,165,169,172,174,175,176,189,1648,1651,1669,1683,1684,1735,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1684,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1793,1835],[94,157,165,169,172,174,175,176,189,1648,1651,1834,1835,1836,1837,1838,1839],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1732,1778,1780,1793,1835],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1719,1732,1793,1834],[94,157,165,169,172,174,175,176,189,1648,1651,1725],[94,157,165,169,172,174,175,176,189,1648,1651,1738,1739,1740,1741],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1739,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1687,1691,1693,1699,1730,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1681,1691,1697,1707,1732,1738,1740,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1674],[94,157,165,169,172,174,175,176,189,1648,1651,1663,1664,1731],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1663,1664,1666,1669,1673,1675,1677,1679,1687,1691,1699,1724,1726,1728,1730,1735,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1666,1669,1673,1677,1679,1681,1683,1687,1691,1697,1699,1724,1726,1735,1737,1742,1746,1750,1759,1763,1766,1768,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1771],[94,157,165,169,172,174,175,176,189,1648,1651,1666,1669,1673,1677,1679,1687,1691,1693,1697,1699,1726,1735,1763,1776,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1769,1770,1776,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1682],[94,157,165,169,172,174,175,176,189,1648,1651,1773],[94,157,165,169,172,174,175,176,189,1648,1651,1751],[94,157,165,169,172,174,175,176,189,1648,1651,1706],[94,157,165,169,172,174,175,176,189,1648,1651,1777],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1669,1735,1776,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1743,1744,1745],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1744,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1744,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1681,1687,1691,1693,1697,1724,1732,1743,1745,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1733,1734],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1733,1778],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1732,1734,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1841],[94,157,165,169,172,174,175,176,189,1648,1651,1679,1683,1699,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1757,1758],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1757,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1669,1671,1675,1681,1687,1691,1693,1697,1703,1705,1707,1709,1711,1732,1735,1752,1754,1756,1758,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1805],[94,157,165,169,172,174,175,176,189,1648,1651,1747,1748,1749],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1748,1778,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1748,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1681,1687,1691,1693,1697,1724,1732,1747,1749,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1727],[94,157,165,169,172,174,175,176,189,1648,1651,1670],[94,157,165,169,172,174,175,176,189,1648,1651,1669,1735,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1667,1668],[94,157,165,169,172,174,175,176,189,1648,1651,1667,1732,1778],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1668,1732,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1762],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1662,1675,1677,1683,1691,1703,1705,1707,1709,1719,1761,1776,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1692],[94,157,165,169,172,174,175,176,189,1648,1651,1696],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1695,1776,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1760],[94,157,165,169,172,174,175,176,189,1648,1651,1807,1808],[94,157,165,169,172,174,175,176,189,1648,1651,1764,1765],[94,157,165,169,172,174,175,176,189,1648,1651,1732,1764,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1669,1671,1675,1681,1687,1691,1693,1697,1703,1705,1707,1709,1711,1732,1735,1752,1754,1756,1765,1778,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1843],[94,157,165,169,172,174,175,176,189,1648,1651,1687,1691,1699,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1845],[94,157,165,169,172,174,175,176,189,1648,1651,1679,1683,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1662,1666,1673,1675,1677,1679,1687,1691,1693,1697,1699,1703,1705,1707,1709,1711,1719,1726,1728,1752,1754,1756,1761,1763,1774,1778,1782,1784,1786,1788,1790,1791],[94,157,165,169,172,174,175,176,189,1648,1651,1791,1792],[94,157,165,169,172,174,175,176,189,1648,1651,1660],[94,157,165,169,172,174,175,176,189,1648,1651,1729],[94,157,165,169,172,174,175,176,189,1648,1651,1775],[94,157,165,169,172,174,175,176,189,1648,1651,1666,1669,1673,1677,1679,1683,1687,1691,1693,1695,1697,1699,1726,1728,1735,1763,1768,1772,1774,1778,1780,1782,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1702],[94,157,165,169,172,174,175,176,189,1648,1651,1753],[94,157,165,169,172,174,175,176,189,1648,1651,1659],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1701,1703,1705,1707,1709,1711,1712,1719],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1701,1705,1712,1713,1719,1780],[94,157,165,169,172,174,175,176,189,1648,1651,1712,1713,1714,1715,1716,1717,1718],[94,157,165,169,172,174,175,176,189,1648,1651,1701],[94,157,165,169,172,174,175,176,189,1648,1651,1701,1719],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1703,1705,1707,1711,1719,1780],[94,157,165,169,172,174,175,176,189,1648,1651,1660,1675,1683,1691,1703,1705,1707,1709,1711,1715,1776,1780,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1675,1691,1717,1776,1780],[94,157,165,169,172,174,175,176,189,1648,1651,1767],[94,157,165,169,172,174,175,176,189,1648,1651,1698],[94,157,165,169,172,174,175,176,189,1648,1651,1847,1848],[94,157,165,169,172,174,175,176,189,1648,1651,1666,1673,1679,1711,1726,1728,1737,1754,1756,1761,1784,1786,1790,1793,1800,1815,1831,1833,1842,1846,1847],[94,157,165,169,172,174,175,176,189,1648,1651,1662,1669,1671,1675,1677,1683,1687,1691,1693,1695,1697,1699,1703,1705,1707,1709,1719,1724,1732,1735,1742,1746,1750,1752,1759,1763,1766,1768,1772,1774,1778,1782,1788,1793,1811,1813,1819,1825,1829,1840,1844],[94,157,165,169,172,174,175,176,189,1648,1651,1785],[94,157,165,169,172,174,175,176,189,1648,1651,1755],[94,157,165,169,172,174,175,176,189,1648,1651,1688,1689,1690],[94,157,165,169,172,174,175,176,189,1648,1651,1669,1683,1688,1735,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1683,1688,1793],[94,157,165,169,172,174,175,176,189,1648,1651,1787],[94,157,165,169,172,174,175,176,189,1648,1651,1694],[94,157,165,169,172,174,175,176,189,1648,1651,1789],[94,157,165,169,172,174,175,176,189,1648,1651,1654],[94,157,165,169,172,174,175,176,189,1648,1651,1655],[94,157,165,169,172,174,175,176,189,1648,1651,1852,1856],[94,157,165,169,172,174,175,176,189,608,610,611,612,613,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,611,612,613,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,609,610,611,612,613,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,612,613,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,613,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,614,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,615,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,616,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,615,617,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,615,616,618,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,615,616,617,619,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,615,616,617,618,620,1648,1651],[94,157,165,169,172,174,175,176,189,608,609,610,611,612,613,614,615,616,617,618,619,1648,1651],[94,154,155,157,165,169,172,174,175,176,189,1648,1651],[94,156,157,165,169,172,174,175,176,189,1648,1651],[157,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,197,1648,1651],[94,157,158,163,165,168,169,172,174,175,176,178,189,194,206,1648,1651],[94,157,158,159,165,168,169,172,174,175,176,189,1648,1651],[94,157,160,165,169,172,174,175,176,189,207,1648,1651],[94,157,161,162,165,169,172,174,175,176,180,189,1648,1651],[94,157,162,165,169,172,174,175,176,189,194,203,1648,1651],[94,157,163,165,168,169,172,174,175,176,178,189,1648,1651],[94,156,157,164,165,169,172,174,175,176,189,1648,1651],[94,157,165,166,169,172,174,175,176,189,1648,1651],[94,157,165,167,168,169,172,174,175,176,189,1648,1651],[94,156,157,165,168,169,172,174,175,176,189,1648,1651],[94,157,165,168,169,170,172,174,175,176,189,194,206,1648,1651],[94,157,165,168,169,170,172,174,175,176,189,194,197,1648,1651],[94,144,157,165,168,169,171,172,174,175,176,178,189,194,206,1648,1651],[94,157,165,168,169,171,172,174,175,176,178,189,194,203,206,1648,1651],[94,157,165,169,171,172,173,174,175,176,189,194,203,206,1648,1651],[92,93,94,95,96,97,98,99,100,101,102,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,1648,1651],[94,157,165,168,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,176,189,1648,1651],[94,157,165,169,172,174,175,176,177,189,206,1648,1651],[94,157,165,168,169,172,174,175,176,178,189,194,1648,1651],[94,157,165,169,172,174,175,176,180,189,1648,1651],[94,157,165,169,172,174,175,176,181,189,1648,1651],[94,157,165,168,169,172,174,175,176,184,189,1648,1651],[94,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,1648,1651],[94,157,165,169,172,174,175,176,186,189,1648,1651],[94,157,165,169,172,174,175,176,187,189,1648,1651],[94,157,162,165,169,172,174,175,176,178,189,197,1648,1651],[94,157,165,168,169,172,174,175,176,189,190,1648,1651],[94,157,165,169,172,174,175,176,189,191,207,210,1648,1651],[94,157,165,168,169,172,174,175,176,189,194,196,197,1648,1651],[94,157,165,169,172,174,175,176,189,195,197,1648,1651],[94,157,165,169,172,174,175,176,189,197,207,1648,1651],[94,157,165,169,172,174,175,176,189,198,1648,1651],[94,154,157,165,169,172,174,175,176,189,194,200,206,1648,1651],[94,157,165,169,172,174,175,176,189,194,199,1648,1651],[94,157,165,168,169,172,174,175,176,189,201,202,1648,1651],[94,157,165,169,172,174,175,176,189,201,202,1648,1651],[94,157,162,165,169,172,174,175,176,178,189,194,203,1648,1651],[94,157,165,169,172,174,175,176,189,204,1648,1651],[94,157,165,169,172,174,175,176,178,189,205,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,206,1648,1651],[94,157,165,169,172,174,175,176,189,207,208,1648,1651],[94,157,162,165,169,172,174,175,176,189,208,1648,1651],[94,157,165,169,172,174,175,176,189,194,209,1648,1651],[94,157,165,169,172,174,175,176,177,189,210,1648,1651],[94,157,165,169,172,174,175,176,189,211,1648,1651],[94,157,160,165,169,172,174,175,176,189,1648,1651],[94,157,162,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,207,1648,1651],[94,144,157,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,206,1648,1651],[94,157,165,169,172,174,175,176,189,212,1648,1651],[94,157,165,169,172,174,175,176,184,189,1648,1651],[94,157,165,169,172,174,175,176,189,202,1648,1651],[94,144,157,165,168,169,170,172,174,175,176,184,189,194,197,206,209,210,212,1648,1651],[94,157,165,169,172,174,175,176,189,194,213,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,215,216,217,219,501,546,1098,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,215,216,217,218,482,501,546,1098,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,215,216,218,219,501,546,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,219,482,483,1648,1651],[85,94,157,165,169,172,174,175,176,189,219,482,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,216,217,218,219,501,546,1098,1648,1651],[85,89,94,157,165,169,172,174,175,176,189,215,217,218,219,501,546,1098,1648,1651],[83,84,94,157,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,1078,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,681,682,683,684,685,686,687,688,689,690,691,692,693,694,696,709,712,713,714,716,717,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,772,786,794,795,796,810,837,848,863,864,869,870,871,872,877,882,883,884,887,889,890,895,896,898,899,903,941,962,978,979,980,981,982,983,984,985,996,997,998,999,1000,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1648,1651],[94,157,165,169,172,174,175,176,189,695,697,698,699,700,701,702,703,704,705,706,707,708,710,717,718,719,720,721,722,723,977,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1648,1651],[94,157,165,169,172,174,175,176,189,646,669,730,734,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,661,662,668,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,667,669,681,730,731,733,735,941,1648,1651],[94,157,165,169,172,174,175,176,189,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,649,669,736,1648,1651],[94,157,165,169,172,174,175,176,189,646,649,664,665,666,667,1648,1651],[94,157,165,169,172,174,175,176,189,726,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,732,1648,1651],[94,157,165,169,172,174,175,176,189,668,1648,1651],[94,157,165,169,172,174,175,176,189,646,668,1648,1651],[94,157,165,169,172,174,175,176,189,730,744,941,1648,1651],[94,157,165,169,172,174,175,176,189,745,1648,1651],[94,157,165,169,172,174,175,176,189,712,1648,1651],[94,157,165,169,172,174,175,176,189,646,654,655,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,656,687,730,941,976,977,1648,1651],[94,157,165,169,172,174,175,176,189,656,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,647,656,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,648,654,1648,1651],[94,157,165,169,172,174,175,176,189,647,649,651,652,654,661,675,678,680,681,682,1648,1651],[94,157,165,169,172,174,175,176,189,649,1648,1651],[94,157,165,169,172,174,175,176,189,683,1648,1651],[94,157,165,169,172,174,175,176,189,649,650,1648,1651],[94,157,165,169,172,174,175,176,189,646,649,651,1648,1651],[94,157,165,169,172,174,175,176,189,648,649,650,654,1648,1651],[94,157,165,169,172,174,175,176,189,648,652,653,654,656,661,669,673,681,683,684,690,691,694,719,724,726,727,729,962,1648,1651],[94,157,165,169,172,174,175,176,189,647,656,661,717,727,728,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,655,681,686,691,1648,1651],[94,157,165,169,172,174,175,176,189,687,1648,1651],[94,157,165,169,172,174,175,176,189,646,681,863,1648,1651],[94,157,165,169,172,174,175,176,189,681,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,661,689,691,694,709,719,962,1648,1651],[94,157,165,169,172,174,175,176,189,647,1648,1651],[94,157,165,169,172,174,175,176,189,646,691,1648,1651],[94,157,165,169,172,174,175,176,189,647,661,1648,1651],[94,157,165,169,172,174,175,176,189,647,661,670,1648,1651],[94,157,165,169,172,174,175,176,189,647,671,1648,1651],[94,157,165,169,172,174,175,176,189,647,672,1648,1651],[94,157,165,169,172,174,175,176,189,647,658,672,673,1648,1651],[94,157,165,169,172,174,175,176,189,986,1648,1651],[94,157,165,169,172,174,175,176,189,661,670,1648,1651],[94,157,165,169,172,174,175,176,189,647,670,1648,1651],[94,157,165,169,172,174,175,176,189,986,987,988,989,990,991,992,993,994,995,1648,1651],[94,157,165,169,172,174,175,176,189,970,1648,1651],[94,157,165,169,172,174,175,176,189,1005,1648,1651],[94,157,165,169,172,174,175,176,189,647,661,670,673,683,1648,1651],[94,157,165,169,172,174,175,176,189,970,971,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1648,1651],[94,157,165,169,172,174,175,176,189,647,683,1648,1651],[94,157,165,169,172,174,175,176,189,673,683,1648,1651],[94,157,165,169,172,174,175,176,189,661,670,683,1648,1651],[94,157,165,169,172,174,175,176,189,658,661,714,730,941,1021,1648,1651],[94,157,165,169,172,174,175,176,189,658,1023,1648,1651],[94,157,165,169,172,174,175,176,189,658,678,1023,1648,1651],[94,157,165,169,172,174,175,176,189,658,678,683,730,850,941,1023,1648,1651],[94,157,165,169,172,174,175,176,189,656,658,1023,1648,1651],[94,157,165,169,172,174,175,176,189,654,658,730,884,941,1021,1648,1651],[94,157,165,169,172,174,175,176,189,658,683,850,1023,1648,1651],[94,157,165,169,172,174,175,176,189,658,730,852,887,941,1648,1651],[94,157,165,169,172,174,175,176,189,658,676,1021,1648,1651],[94,157,165,169,172,174,175,176,189,658,714,899,1648,1651],[94,157,165,169,172,174,175,176,189,658,662,730,941,1023,1648,1651],[94,157,165,169,172,174,175,176,189,658,730,890,941,1023,1648,1651],[94,157,165,169,172,174,175,176,189,658,685,1648,1651],[94,157,165,169,172,174,175,176,189,658,685,730,872,877,883,941,1648,1651],[94,157,165,169,172,174,175,176,189,872,877,882,1648,1651],[94,157,165,169,172,174,175,176,189,658,685,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,658,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,685,730,895,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,654,655,656,685,687,730,751,754,758,760,783,784,801,828,832,834,845,871,906,908,909,918,927,939,940,941,1648,1651],[94,157,165,169,172,174,175,176,189,658,685,730,872,877,898,941,1648,1651],[94,157,165,169,172,174,175,176,189,712,872,877,1648,1651],[94,157,165,169,172,174,175,176,189,658,685,691,730,872,877,889,941,1648,1651],[94,157,165,169,172,174,175,176,189,669,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,683,981,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,688,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,689,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,725,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,1036,1648,1651],[94,157,165,169,172,174,175,176,189,1037,1648,1651],[94,157,165,169,172,174,175,176,189,691,724,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,669,683,690,691,724,730,941,981,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,691,1036,1037,1648,1651],[94,157,165,169,172,174,175,176,189,658,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,724,850,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,653,656,658,676,681,683,684,690,691,694,719,723,730,941,962,1648,1651],[94,157,165,169,172,174,175,176,189,724,850,851,852,853,854,855,856,857,858,859,860,861,862,865,866,867,868,1648,1651],[94,157,165,169,172,174,175,176,189,646,653,658,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,646,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,653,658,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,658,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,691,724,1648,1651],[94,157,165,169,172,174,175,176,189,647,658,691,724,859,1648,1651],[94,157,165,169,172,174,175,176,189,865,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,648,654,655,661,695,724,730,864,941,1648,1651],[94,157,165,169,172,174,175,176,189,658,724,1648,1651],[94,157,165,169,172,174,175,176,189,724,751,754,758,760,761,764,783,784,791,801,828,832,834,845,906,908,909,918,927,937,938,939,940,966,1648,1651],[94,157,165,169,172,174,175,176,189,649,685,724,769,937,938,965,975,1648,1651],[94,157,165,169,172,174,175,176,189,649,654,661,675,676,677,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,648,649,651,657,661,1648,1651],[94,157,165,169,172,174,175,176,189,646,648,658,661,1648,1651],[94,157,165,169,172,174,175,176,189,661,1648,1651],[94,157,165,169,172,174,175,176,189,652,654,661,1648,1651],[94,157,165,169,172,174,175,176,189,646,654,661,675,676,678,730,870,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,661,675,678,713,730,870,941,1648,1651],[94,157,165,169,172,174,175,176,189,654,661,1648,1651],[94,157,165,169,172,174,175,176,189,652,1648,1651],[94,157,165,169,172,174,175,176,189,647,654,661,1648,1651],[94,157,165,169,172,174,175,176,189,646,648,652,653,661,1648,1651],[94,157,165,169,172,174,175,176,189,648,654,661,674,675,678,1648,1651],[94,157,165,169,172,174,175,176,189,649,651,653,654,661,1648,1651],[94,157,165,169,172,174,175,176,189,654,661,675,676,678,1648,1651],[94,157,165,169,172,174,175,176,189,654,661,676,678,1648,1651],[94,157,165,169,172,174,175,176,189,647,649,651,655,661,676,678,1648,1651],[94,157,165,169,172,174,175,176,189,648,649,1648,1651],[94,157,165,169,172,174,175,176,189,648,649,651,652,653,654,656,658,659,660,1648,1651],[94,157,165,169,172,174,175,176,189,649,652,654,1648,1651],[94,157,165,169,172,174,175,176,189,663,1648,1651],[94,157,165,169,172,174,175,176,189,749,750,751,752,753,754,755,756,757,758,759,760,761,763,764,765,766,767,768,769,770,771,773,774,775,776,777,778,779,780,781,782,783,784,785,787,788,789,790,791,792,793,798,799,800,801,802,803,804,805,806,807,808,809,811,812,813,814,815,816,817,818,819,820,821,822,823,825,826,827,828,829,830,831,832,833,834,835,836,838,839,840,841,842,843,844,845,846,847,849,875,876,877,878,879,880,881,885,886,888,891,892,893,894,897,900,901,902,904,905,906,907,908,909,910,911,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,934,935,937,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,786,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,646,649,650,651,751,754,755,758,760,783,784,789,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,773,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,689,751,754,758,760,783,784,792,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,794,796,797,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,795,798,1648,1651],[94,157,165,169,172,174,175,176,189,724,801,802,1648,1651],[94,157,165,169,172,174,175,176,189,648,654,751,754,758,760,783,784,801,804,826,828,832,834,845,906,908,909,918,927,936,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,714,751,754,758,760,773,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,730,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,941,1648,1651],[94,157,165,169,172,174,175,176,189,802,975,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,810,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,649,679,749,751,754,758,760,780,781,783,784,788,789,797,801,813,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,691,749,751,754,758,760,783,784,792,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,691,751,754,758,760,783,784,792,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,691,751,754,758,760,773,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,788,789,801,812,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,802,1648,1651],[94,157,165,169,172,174,175,176,189,654,750,773,1648,1651],[94,157,165,169,172,174,175,176,189,753,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,750,1648,1651],[94,157,165,169,172,174,175,176,189,750,751,754,758,760,783,784,801,825,828,832,834,845,906,908,909,918,927,936,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,770,783,784,801,822,824,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,755,938,1648,1651],[94,157,165,169,172,174,175,176,189,685,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,759,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,937,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,691,762,763,826,936,1648,1651],[94,157,165,169,172,174,175,176,189,681,749,769,938,1648,1651],[94,157,165,169,172,174,175,176,189,683,691,724,730,749,751,754,758,759,760,765,774,775,776,779,783,784,801,828,832,834,845,906,908,909,912,918,927,937,939,940,941,975,1648,1651],[94,157,165,169,172,174,175,176,189,767,1648,1651],[94,157,165,169,172,174,175,176,189,656,694,724,730,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,941,962,975,1648,1651],[94,157,165,169,172,174,175,176,189,770,1648,1651],[94,157,165,169,172,174,175,176,189,824,1648,1651],[94,157,165,169,172,174,175,176,189,771,773,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,654,655,658,661,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,646,775,1648,1651],[94,157,165,169,172,174,175,176,189,777,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,780,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,654,655,658,661,749,755,769,771,772,938,1648,1651],[94,157,165,169,172,174,175,176,189,646,751,754,758,760,776,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,646,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,646,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,655,656,687,691,724,727,730,750,751,754,758,760,764,783,784,792,801,828,832,834,845,906,908,909,918,927,939,940,941,975,1648,1651],[94,157,165,169,172,174,175,176,189,646,750,751,754,758,760,783,784,801,809,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,656,658,694,751,754,758,760,783,784,801,828,831,832,834,845,906,908,909,918,927,939,940,962,1648,1651],[94,157,165,169,172,174,175,176,189,686,751,754,758,760,783,784,801,828,832,834,838,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,837,838,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,687,691,749,751,754,758,760,783,784,792,801,828,832,834,837,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,761,1648,1651],[94,157,165,169,172,174,175,176,189,933,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,761,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,647,655,658,661,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,975,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,849,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,848,877,1648,1651],[94,157,165,169,172,174,175,176,189,685,751,754,758,760,783,784,801,828,832,834,845,849,872,876,906,908,909,918,927,937,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,877,884,1648,1651],[94,157,165,169,172,174,175,176,189,661,751,754,758,760,773,783,784,801,828,832,834,845,877,887,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,891,1648,1651],[94,157,165,169,172,174,175,176,189,818,877,896,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,761,783,784,801,828,832,834,845,906,908,909,918,927,937,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,685,751,754,758,760,783,784,801,826,828,832,834,845,849,906,908,909,918,927,936,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,877,899,900,906,908,909,918,927,937,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,685,751,754,758,760,783,784,801,828,832,834,845,872,876,877,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,725,751,754,758,760,783,784,801,828,832,834,845,877,903,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,656,683,684,685,694,724,730,872,874,875,877,937,941,962,975,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,828,832,834,845,877,890,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,647,655,661,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,910,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,912,913,1648,1651],[94,157,165,169,172,174,175,176,189,691,750,751,754,758,760,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,654,655,658,661,751,754,756,758,760,772,779,783,784,801,828,832,834,845,906,908,909,918,927,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,769,783,784,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,826,828,832,834,845,906,908,909,918,927,936,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,826,828,832,834,845,906,908,909,918,927,936,938,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,691,773,792,1648,1651],[94,157,165,169,172,174,175,176,189,646,687,751,754,758,760,783,784,792,801,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,656,687,730,751,754,758,760,783,784,792,801,828,832,834,845,906,908,909,918,927,939,940,941,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,783,784,801,812,814,828,832,834,845,906,908,909,918,927,939,940,1648,1651],[94,157,165,169,172,174,175,176,189,654,655,656,658,675,678,683,714,724,1648,1651],[94,157,165,169,172,174,175,176,189,676,684,1648,1651],[94,157,165,169,172,174,175,176,189,649,654,658,675,678,683,714,724,725,730,794,941,1648,1651],[94,157,165,169,172,174,175,176,189,683,724,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,683,724,730,941,1021,1648,1651],[94,157,165,169,172,174,175,176,189,661,683,724,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,654,662,725,1648,1651],[94,157,165,169,172,174,175,176,189,646,654,661,675,678,683,714,724,726,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,647,683,730,869,941,1648,1651],[94,157,165,169,172,174,175,176,189,687,709,1058,1648,1651],[94,157,165,169,172,174,175,176,189,687,709,1060,1648,1651],[94,157,165,169,172,174,175,176,189,687,689,691,709,719,1648,1651],[94,157,165,169,172,174,175,176,189,687,691,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,649,655,656,658,661,676,678,683,691,694,696,697,698,700,701,702,703,708,709,710,718,724,730,941,962,1648,1651],[94,157,165,169,172,174,175,176,189,649,650,651,941,950,1648,1651],[94,157,165,169,172,174,175,176,189,646,730,975,1648,1651],[94,157,165,169,172,174,175,176,189,947,1648,1651],[94,157,165,169,172,174,175,176,189,646,1648,1651],[94,157,165,169,172,174,175,176,189,649,947,1648,1651],[94,157,165,169,172,174,175,176,189,684,1648,1651],[94,157,165,169,172,174,175,176,189,647,655,681,686,837,1648,1651],[94,157,165,169,172,174,175,176,189,648,654,655,656,676,694,873,962,1648,1651],[94,157,165,169,172,174,175,176,189,658,1648,1651],[94,157,165,169,172,174,175,176,189,687,691,975,1648,1651],[94,157,165,169,172,174,175,176,189,649,683,944,950,951,952,965,1648,1651],[94,157,165,169,172,174,175,176,189,649,679,1648,1651],[94,157,165,169,172,174,175,176,189,656,687,691,694,751,754,758,760,769,783,784,801,828,832,834,845,906,908,909,918,927,939,940,962,975,1648,1651],[94,157,165,169,172,174,175,176,189,685,730,937,941,1648,1651],[94,157,165,169,172,174,175,176,189,714,724,882,975,1648,1651],[94,157,165,169,172,174,175,176,189,655,656,686,687,691,764,874,1648,1651],[94,157,165,169,172,174,175,176,189,656,683,685,694,724,730,874,937,941,946,949,962,1648,1651],[94,157,165,169,172,174,175,176,189,649,650,656,683,694,724,730,874,937,941,948,949,953,954,962,963,964,966,975,1648,1651],[94,157,165,169,172,174,175,176,189,826,936,975,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,649,655,656,658,661,678,679,680,683,687,691,694,696,724,730,764,837,845,874,937,940,941,942,943,944,945,946,962,968,969,974,1648,1651],[94,157,165,169,172,174,175,176,189,649,794,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,654,655,658,661,772,1648,1651],[94,157,165,169,172,174,175,176,189,958,1648,1651],[94,157,165,169,172,174,175,176,189,956,957,959,1648,1651],[94,157,165,169,172,174,175,176,189,652,661,681,687,712,713,714,717,852,970,971,972,973,975,1648,1651],[94,157,165,169,172,174,175,176,189,751,754,758,760,765,783,784,801,828,832,834,845,906,908,909,918,927,939,940,948,966,1648,1651],[94,157,165,169,172,174,175,176,189,646,685,724,751,754,758,760,783,784,801,828,832,834,845,877,906,908,909,918,927,939,940,967,1648,1651],[94,157,165,169,172,174,175,176,189,656,691,694,724,730,751,754,758,760,769,783,784,801,828,832,834,845,906,908,909,918,927,937,939,940,941,950,954,955,961,962,965,975,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,654,655,658,661,772,774,956,1648,1651],[94,157,165,169,172,174,175,176,189,771,960,1648,1651],[94,157,165,169,172,174,175,176,189,695,1648,1651],[94,157,165,169,172,174,175,176,189,647,648,658,1648,1651],[94,157,165,169,172,174,175,176,189,695,864,1648,1651],[94,157,165,169,172,174,175,176,189,649,651,682,1648,1651],[94,157,165,169,172,174,175,176,189,649,683,700,704,724,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,698,701,1648,1651],[94,157,165,169,172,174,175,176,189,656,676,702,724,1648,1651],[94,157,165,169,172,174,175,176,189,691,1648,1651],[94,157,165,169,172,174,175,176,189,649,683,701,704,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,698,701,704,1648,1651],[94,157,165,169,172,174,175,176,189,700,1648,1651],[94,157,165,169,172,174,175,176,189,656,685,698,1648,1651],[94,157,165,169,172,174,175,176,189,683,701,704,705,706,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,699,719,1648,1651],[94,157,165,169,172,174,175,176,189,646,685,694,695,697,698,700,705,719,720,721,722,724,730,941,962,1648,1651],[94,157,165,169,172,174,175,176,189,683,684,694,702,724,730,941,962,1648,1651],[94,157,165,169,172,174,175,176,189,646,656,685,694,697,707,719,962,1648,1651],[94,157,165,169,172,174,175,176,189,646,655,698,709,724,1648,1651],[94,157,165,169,172,174,175,176,189,687,691,697,698,701,702,710,1075,1648,1651],[94,157,165,169,172,174,175,176,189,646,698,1648,1651],[94,157,165,169,172,174,175,176,189,661,684,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,714,716,718,1648,1651],[94,157,165,169,172,174,175,176,189,655,681,711,712,713,714,716,717,719,1648,1651],[94,157,165,169,172,174,175,176,189,653,658,691,692,693,724,730,941,1648,1651],[94,157,165,169,172,174,175,176,189,646,688,1648,1651],[94,157,165,169,172,174,175,176,189,646,649,691,1648,1651],[94,157,165,169,172,174,175,176,189,691,715,1648,1651],[94,157,165,169,172,174,175,176,189,646,647,648,681,687,688,689,690,1648,1651],[94,157,165,169,172,174,175,176,189,646,1065,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1863],[94,157,165,169,172,174,175,176,189,1549,1648,1651],[94,157,165,169,172,174,175,176,189,1529,1530,1535,1648,1651],[94,157,165,169,172,174,175,176,189,1531,1535,1648,1651],[94,157,165,169,172,174,175,176,189,1528,1535,1648,1651],[94,157,165,169,172,174,175,176,189,1535,1648,1651],[94,157,165,169,172,174,175,176,189,1529,1530,1531,1535,1648,1651],[94,157,165,169,172,174,175,176,189,1534,1648,1651],[94,157,165,169,172,174,175,176,189,1525,1528,1531,1532,1648,1651],[94,157,165,169,172,174,175,176,189,1523,1524,1648,1651],[94,157,165,169,172,174,175,176,189,1523,1524,1525,1648,1651],[94,157,165,169,172,174,175,176,189,1523,1524,1525,1526,1527,1533,1648,1651],[94,157,165,169,172,174,175,176,189,1523,1525,1648,1651],[94,157,165,169,172,174,175,176,189,1546,1648,1651],[94,157,165,169,172,174,175,176,189,1547,1648,1651],[94,157,165,169,172,174,175,176,189,1536,1537,1648,1651],[94,157,165,169,172,174,175,176,189,1536,1538,1539,1540,1541,1542,1543,1544,1545,1548,1550,1648,1651],[85,94,157,165,169,172,174,175,176,189,1536,1648,1651],[94,157,165,169,172,174,175,176,189,1551,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1657,1854,1855],[94,157,165,169,172,174,175,176,189,639,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1852],[94,157,165,169,172,174,175,176,189,1648,1651,1658,1853],[94,157,165,169,172,174,175,176,189,1395,1396,1397,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1396,1445,1648,1651],[94,157,165,169,172,174,175,176,189,504,1648,1651],[94,157,165,169,172,174,175,176,189,506,507,508,509,1648,1651],[94,157,165,169,172,174,175,176,189,452,515,516,1648,1651],[94,157,165,169,172,174,175,176,189,224,225,227,239,263,378,389,497,1648,1651],[94,157,165,169,172,174,175,176,189,227,258,259,260,262,497,1648,1651],[94,157,165,169,172,174,175,176,189,227,395,397,399,400,402,497,499,1648,1651],[94,157,165,169,172,174,175,176,189,227,261,298,497,1648,1651],[94,157,165,169,172,174,175,176,189,225,227,238,239,245,251,256,377,378,379,388,497,499,1648,1651],[94,157,165,169,172,174,175,176,189,497,1648,1651],[94,157,165,169,172,174,175,176,189,234,240,259,279,374,1648,1651],[94,157,165,169,172,174,175,176,189,227,1648,1651],[94,157,165,169,172,174,175,176,189,220,234,240,1648,1651],[94,157,165,169,172,174,175,176,189,406,1648,1651],[94,157,165,169,172,174,175,176,189,403,404,406,1648,1651],[94,157,165,169,172,174,175,176,189,403,405,497,1648,1651],[94,157,165,169,171,172,174,175,176,189,279,476,494,1648,1651],[94,157,165,169,171,172,174,175,176,189,350,353,369,374,494,1648,1651],[94,157,165,169,171,172,174,175,176,189,322,494,1648,1651],[94,157,165,169,172,174,175,176,189,382,1648,1651],[94,157,165,169,172,174,175,176,189,381,382,383,1648,1651],[94,157,165,169,172,174,175,176,189,381,1648,1651],[91,94,157,165,169,171,172,174,175,176,189,220,227,239,245,251,257,259,263,264,277,278,345,375,376,389,497,501,1648,1651],[94,157,165,169,172,174,175,176,189,224,227,261,298,395,396,401,497,549,1648,1651],[94,157,165,169,172,174,175,176,189,261,549,1648,1651],[94,157,165,169,172,174,175,176,189,224,278,447,497,549,1648,1651],[94,157,165,169,172,174,175,176,189,549,1648,1651],[94,157,165,169,172,174,175,176,189,227,261,262,549,1648,1651],[94,157,165,169,172,174,175,176,189,398,549,1648,1651],[94,157,165,169,172,174,175,176,189,264,377,380,387,1648,1651],[85,94,157,165,169,172,174,175,176,189,452,1648,1651],[94,157,165,169,172,174,175,176,187,189,234,249,1098,1648,1651],[94,157,165,169,172,174,175,176,189,234,249,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,319,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,240,249,452,1098,1648,1651],[94,157,165,169,172,174,175,176,189,234,305,319,320,531,538,1648,1651],[94,157,165,169,172,174,175,176,189,304,532,533,534,535,537,1648,1651],[94,157,165,169,172,174,175,176,189,355,1648,1651],[94,157,165,169,172,174,175,176,189,355,356,1648,1651],[94,157,165,169,172,174,175,176,189,238,240,307,308,1648,1651],[94,157,165,169,172,174,175,176,189,240,314,315,1648,1651],[94,157,165,169,172,174,175,176,189,240,309,317,1648,1651],[94,157,165,169,172,174,175,176,189,314,1648,1651],[94,157,165,169,172,174,175,176,189,232,240,307,308,309,310,311,312,313,314,317,1648,1651],[94,157,165,169,172,174,175,176,189,240,307,314,315,316,318,1648,1651],[94,157,165,169,172,174,175,176,189,240,308,310,311,1648,1651],[94,157,165,169,172,174,175,176,189,308,310,313,315,1648,1651],[94,157,165,169,172,174,175,176,189,536,1648,1651],[94,157,165,169,172,174,175,176,189,240,1648,1651],[85,94,157,165,169,172,174,175,176,189,228,525,1648,1651],[85,94,157,165,169,172,174,175,176,189,206,1648,1651],[85,94,157,165,169,172,174,175,176,189,261,296,1648,1651],[85,94,157,165,169,172,174,175,176,189,261,389,1648,1651],[94,157,165,169,172,174,175,176,189,294,299,1648,1651],[85,94,157,165,169,172,174,175,176,189,295,503,1648,1651],[85,89,94,157,165,169,171,172,174,175,176,189,215,216,217,218,219,501,545,1098,1648,1651],[94,157,165,169,171,172,174,175,176,189,240,1648,1651],[94,157,165,169,171,172,174,175,176,189,239,244,325,342,384,385,389,444,446,497,498,1648,1651],[94,157,165,169,172,174,175,176,189,277,386,1648,1651],[94,157,165,169,172,174,175,176,189,501,1648,1651],[94,157,165,169,172,174,175,176,189,226,1648,1651],[85,94,157,165,169,172,174,175,176,189,231,234,449,465,467,1648,1651],[94,157,165,169,172,174,175,176,187,189,234,449,464,465,466,548,1648,1651],[94,157,165,169,172,174,175,176,189,458,459,460,461,462,463,1648,1651],[94,157,165,169,172,174,175,176,189,460,1648,1651],[94,157,165,169,172,174,175,176,189,464,1648,1651],[94,157,165,169,172,174,175,176,189,249,413,414,416,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,240,407,408,409,410,415,1648,1651],[94,157,165,169,172,174,175,176,189,413,415,1648,1651],[94,157,165,169,172,174,175,176,189,411,1648,1651],[94,157,165,169,172,174,175,176,189,412,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,295,503,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,502,503,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,503,1098,1648,1651],[94,157,165,169,172,174,175,176,189,342,343,1648,1651],[94,157,165,169,172,174,175,176,189,343,1648,1651],[94,157,165,169,171,172,174,175,176,189,498,503,1648,1651],[94,157,165,169,172,174,175,176,189,372,1648,1651],[94,156,157,165,169,172,174,175,176,189,371,1648,1651],[94,157,165,169,172,174,175,176,189,234,240,246,248,350,363,367,369,446,449,486,487,494,498,1648,1651],[94,157,165,169,172,174,175,176,189,240,289,311,1648,1651],[94,157,165,169,172,174,175,176,189,350,361,364,369,1648,1651],[85,94,157,165,169,172,174,175,176,189,231,234,350,353,369,372,406,453,454,455,456,457,468,469,470,471,472,473,474,475,549,1648,1651],[94,157,165,169,172,174,175,176,189,231,234,259,350,357,358,359,362,363,1648,1651],[94,157,165,169,172,174,175,176,189,194,240,259,361,368,449,450,494,1648,1651],[94,157,165,169,172,174,175,176,189,365,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,228,240,244,254,286,287,290,342,345,410,444,445,486,497,498,499,501,549,1648,1651],[94,157,165,169,172,174,175,176,189,231,232,234,1648,1651],[94,157,165,169,172,174,175,176,189,350,1648,1651],[94,156,157,165,169,172,174,175,176,189,259,286,287,344,345,346,347,348,349,498,1648,1651],[94,157,165,169,172,174,175,176,189,369,1648,1651],[94,156,157,165,169,172,174,175,176,189,233,234,244,248,284,350,357,358,359,360,361,364,365,366,367,368,487,1648,1651],[94,157,165,169,171,172,174,175,176,189,284,285,357,498,499,1648,1651],[94,157,165,169,172,174,175,176,189,259,287,342,345,350,446,498,1648,1651],[94,157,165,169,171,172,174,175,176,189,497,499,1648,1651],[94,157,165,169,171,172,174,175,176,189,194,494,498,499,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,220,234,239,246,248,251,254,261,281,286,287,288,289,290,325,326,328,331,333,336,337,338,339,341,389,444,446,494,497,498,499,1648,1651],[94,157,165,169,171,172,174,175,176,189,194,1648,1651],[94,157,165,169,172,174,175,176,189,227,228,229,257,494,495,496,501,503,549,1648,1651],[94,157,165,169,172,174,175,176,189,224,225,497,1648,1651],[94,157,165,169,172,174,175,176,189,418,1648,1651],[94,157,165,169,171,172,174,175,176,189,194,206,236,402,406,407,408,409,410,416,417,549,1648,1651],[94,157,165,169,172,174,175,176,187,189,206,220,234,236,248,251,287,326,331,341,342,395,422,423,424,430,433,434,444,446,494,497,1648,1651],[94,157,165,169,172,174,175,176,189,251,257,264,277,287,345,497,1648,1651],[94,157,165,169,171,172,174,175,176,189,206,228,239,248,287,428,494,497,1648,1651],[94,157,165,169,172,174,175,176,189,448,1648,1651],[94,157,165,169,171,172,174,175,176,189,418,431,432,441,1648,1651],[94,157,165,169,172,174,175,176,189,494,497,1648,1651],[94,157,165,169,172,174,175,176,189,347,487,1648,1651],[94,157,165,169,172,174,175,176,189,248,286,389,503,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,226,331,391,395,424,430,433,436,494,1648,1651],[94,157,165,169,171,172,174,175,176,189,264,277,395,437,1648,1651],[94,157,165,169,172,174,175,176,189,227,288,389,439,497,499,1648,1651],[94,157,165,169,171,172,174,175,176,189,206,410,497,1648,1651],[94,157,165,169,171,172,174,175,176,189,261,288,389,390,391,400,418,438,440,497,1648,1651],[91,94,157,165,169,171,172,174,175,176,189,286,443,501,503,1648,1651],[94,157,165,169,172,174,175,176,189,340,444,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,234,237,239,240,246,248,254,263,264,277,287,290,326,328,338,341,342,389,422,423,424,425,427,429,444,446,494,503,1648,1651],[94,157,165,169,171,172,174,175,176,189,194,264,430,435,441,494,1648,1651],[94,157,165,169,172,174,175,176,189,267,268,269,270,271,272,273,274,275,276,1648,1651],[94,157,165,169,172,174,175,176,189,281,332,1648,1651],[94,157,165,169,172,174,175,176,189,334,1648,1651],[94,157,165,169,172,174,175,176,189,332,1648,1651],[94,157,165,169,172,174,175,176,189,334,335,1648,1651],[94,157,165,169,171,172,174,175,176,189,238,239,240,244,245,498,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,226,228,246,250,286,289,290,324,444,494,499,501,503,1648,1651],[94,157,165,169,171,172,174,175,176,187,189,206,230,237,238,248,250,287,442,487,493,498,1648,1651],[94,157,165,169,172,174,175,176,189,357,1648,1651],[94,157,165,169,172,174,175,176,189,358,1648,1651],[94,157,165,169,172,174,175,176,189,240,251,486,1648,1651],[94,157,165,169,172,174,175,176,189,359,1648,1651],[94,157,165,169,172,174,175,176,189,233,1648,1651],[94,157,165,169,172,174,175,176,189,235,247,1648,1651],[94,157,165,169,171,172,174,175,176,189,235,239,246,1648,1651],[94,157,165,169,172,174,175,176,189,242,247,1648,1651],[94,157,165,169,172,174,175,176,189,243,1648,1651],[94,157,165,169,172,174,175,176,189,235,236,1648,1651],[94,157,165,169,172,174,175,176,189,235,291,1648,1651],[94,157,165,169,172,174,175,176,189,235,1648,1651],[94,157,165,169,172,174,175,176,189,237,281,330,1648,1651],[94,157,165,169,172,174,175,176,189,329,1648,1651],[94,157,165,169,172,174,175,176,189,234,236,237,1648,1651],[94,157,165,169,172,174,175,176,189,237,327,1648,1651],[94,157,165,169,172,174,175,176,189,234,236,1648,1651],[94,157,165,169,172,174,175,176,189,286,389,1648,1651],[94,157,165,169,172,174,175,176,189,486,1648,1651],[94,157,165,169,171,172,174,175,176,189,206,246,248,252,286,389,443,446,449,450,451,477,478,481,485,487,494,498,1648,1651],[94,157,165,169,172,174,175,176,189,300,303,305,306,319,320,1648,1651],[85,94,157,165,169,172,174,175,176,189,217,219,249,479,480,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,217,219,249,479,480,484,1098,1648,1651],[94,157,165,169,172,174,175,176,189,373,1648,1651],[94,157,165,169,172,174,175,176,189,259,280,285,286,350,351,352,353,354,356,369,370,372,375,443,446,497,499,1648,1651],[94,157,165,169,172,174,175,176,189,319,1648,1651],[94,157,165,169,171,172,174,175,176,189,324,494,1648,1651],[94,157,165,169,172,174,175,176,189,324,1648,1651],[94,157,165,169,171,172,174,175,176,189,246,292,321,323,325,443,494,501,503,1648,1651],[94,157,165,169,172,174,175,176,189,300,301,302,303,305,306,319,320,502,1648,1651],[91,94,157,165,169,171,172,174,175,176,187,189,206,235,236,248,254,286,287,290,389,441,442,444,494,497,498,501,1648,1651],[94,157,165,169,172,174,175,176,189,231,234,241,1648,1651],[94,157,165,169,172,174,175,176,189,285,287,419,422,1648,1651],[94,157,165,169,172,174,175,176,189,285,420,488,489,490,491,492,1648,1651],[94,157,165,169,171,172,174,175,176,189,281,497,1648,1651],[94,157,165,169,171,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,284,369,1648,1651],[94,157,165,169,172,174,175,176,189,283,1648,1651],[94,157,165,169,172,174,175,176,189,285,338,1648,1651],[94,157,165,169,172,174,175,176,189,282,284,497,1648,1651],[94,157,165,169,171,172,174,175,176,189,230,285,419,420,421,494,497,498,1648,1651],[85,94,157,165,169,172,174,175,176,189,234,240,318,1648,1651],[85,94,157,165,169,172,174,175,176,189,232,1648,1651],[94,157,165,169,172,174,175,176,189,222,223,1648,1651],[85,94,157,165,169,172,174,175,176,189,228,1648,1651],[85,94,157,165,169,172,174,175,176,189,234,304,1648,1651],[85,91,94,157,165,169,172,174,175,176,189,286,290,501,503,1648,1651],[94,157,165,169,172,174,175,176,189,228,525,526,1648,1651],[85,94,157,165,169,172,174,175,176,189,299,1648,1651],[85,94,157,165,169,172,174,175,176,187,189,206,226,293,295,297,298,503,1648,1651],[94,157,165,169,172,174,175,176,189,234,261,498,1648,1651],[94,157,165,169,172,174,175,176,189,234,426,1648,1651],[85,94,157,165,169,171,172,174,175,176,187,189,224,226,299,397,501,502,1648,1651],[85,94,157,165,169,172,174,175,176,189,215,216,217,218,219,501,546,1098,1648,1651],[85,86,87,88,89,94,157,165,169,172,174,175,176,189,1648,1651],[94,157,165,169,172,174,175,176,189,392,393,394,1648,1651],[94,157,165,169,172,174,175,176,189,392,1648,1651],[85,89,94,157,165,169,171,172,173,174,175,176,187,189,214,215,216,217,218,219,220,226,254,259,436,464,499,500,503,546,1098,1648,1651],[94,157,165,169,172,174,175,176,189,511,1648,1651],[94,157,165,169,172,174,175,176,189,513,1648,1651],[94,157,165,169,172,174,175,176,189,517,1648,1651],[94,157,165,169,172,174,175,176,189,519,1648,1651],[94,157,165,169,172,174,175,176,189,521,522,523,1648,1651],[94,157,165,169,172,174,175,176,189,527,1648,1651],[90,94,157,165,169,172,174,175,176,189,505,510,512,514,518,520,524,528,530,540,541,543,547,548,549,550,1648,1651],[94,157,165,169,172,174,175,176,189,529,1648,1651],[94,157,165,169,172,174,175,176,189,539,1648,1651],[94,157,165,169,172,174,175,176,189,295,1648,1651],[94,157,165,169,172,174,175,176,189,542,1648,1651],[94,156,157,165,169,172,174,175,176,189,285,419,420,422,488,489,491,492,544,546,1648,1651],[94,157,165,169,172,174,175,176,189,214,1648,1651],[94,157,165,169,172,174,175,176,189,1648,1651,1851],[85,94,157,165,169,172,174,175,176,189,643,1648,1651],[94,157,165,169,172,174,175,176,189,194,214,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1149,1150,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1175,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1186,1192,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1186,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1255,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1256,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1246,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1253,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1187,1188,1189,1190,1191,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1307,1445,1648,1651],[94,157,165,169,172,174,175,176,189,711,1079,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1361,1362,1365,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1360,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1360,1362,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1238,1239,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1330,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1324,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1126,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1321,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1238,1240,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1181,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1127,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1160,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1153,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1154,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1218,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1229,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1222,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1207,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1203,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1200,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1163,1198,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1198,1199,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1225,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1199,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1199,1648,1651],[94,157,165,169,172,174,175,176,189,711,1079,1233,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1240,1241,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1233,1244,1445,1648,1651],[94,157,165,169,172,174,175,176,189,1079,1245,1445,1648,1651],[94,109,112,115,116,157,165,169,172,174,175,176,189,206,1648,1651],[94,112,157,165,169,172,174,175,176,189,194,206,1648,1651],[94,112,116,157,165,169,172,174,175,176,189,206,1648,1651],[94,157,165,169,172,174,175,176,189,194,1648,1651],[94,106,157,165,169,172,174,175,176,189,1648,1651],[94,110,157,165,169,172,174,175,176,189,1648,1651],[94,108,109,112,157,165,169,172,174,175,176,189,206,1648,1651],[94,157,165,169,172,174,175,176,178,189,203,1648,1651],[94,106,157,165,169,172,174,175,176,189,214,1648,1651],[94,108,112,157,165,169,172,174,175,176,178,189,206,1648,1651],[94,103,104,105,107,111,157,165,168,169,172,174,175,176,189,194,206,1648,1651],[94,112,121,129,157,165,169,172,174,175,176,189,1648,1651],[94,104,110,157,165,169,172,174,175,176,189,1648,1651],[94,112,138,139,157,165,169,172,174,175,176,189,1648,1651],[94,104,107,112,157,165,169,172,174,175,176,189,197,206,214,1648,1651],[94,112,157,165,169,172,174,175,176,189,1648,1651],[94,108,112,157,165,169,172,174,175,176,189,206,1648,1651],[94,103,157,165,169,172,174,175,176,189,1648,1651],[94,106,107,108,110,111,112,113,114,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,139,140,141,142,143,157,165,169,172,174,175,176,189,1648,1651],[94,112,131,134,157,165,169,172,174,175,176,189,1648,1651],[94,112,121,122,123,157,165,169,172,174,175,176,189,1648,1651],[94,110,112,122,124,157,165,169,172,174,175,176,189,1648,1651],[94,111,157,165,169,172,174,175,176,189,1648,1651],[94,104,106,112,157,165,169,172,174,175,176,189,1648,1651],[94,112,116,122,124,157,165,169,172,174,175,176,189,1648,1651],[94,116,157,165,169,172,174,175,176,189,1648,1651],[94,110,112,115,157,165,169,172,174,175,176,189,206,1648,1651],[94,104,108,112,121,157,165,169,172,174,175,176,189,1648,1651],[94,112,131,157,165,169,172,174,175,176,189,1648,1651],[94,124,157,165,169,172,174,175,176,189,1648,1651],[94,106,112,138,157,165,169,172,174,175,176,189,197,212,214,1648,1651],[94,157,165,169,172,174,175,176,189,1080,1081,1082,1083,1648,1651],[94,157,165,169,172,174,175,176,189,1080,1648,1651],[94,157,165,169,172,174,175,176,189,1081,1648,1651],[94,157,165,169,172,174,175,176,189,1086,1087,1648,1651],[94,157,165,169,172,174,175,176,189,1086,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,555,559,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,555,559,564,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,555,556,557,558,560,562,563,565,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,555,559,561,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,559,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,558,561,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,555,559,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,568,569,570,571,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,568,572,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,568,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,568,569,570,571,572,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,574,576,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,574,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,574,575,576,577,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,556,558,560,561,562,563,564,565,566,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,559,579,580,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,579,580,581,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,579,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,583,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,590,1098,1580,1583,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,578,582,583,584,585,586,1098,1579,1581,1582,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,557,573,578,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,583,584,586,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,578,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,583,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,573,583,584,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,583,584,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,588,1098,1585,1586,1648,1651],[85,94,157,165,169,172,174,175,176,189,217,219,249,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,587,1098,1585,1588,1589,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,557,582,587,588,1098,1585,1586,1587,1589,1591,1592,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,587,1098,1590,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,587,588,1098,1585,1591,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,588,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,587,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,559,573,578,589,590,591,1098,1594,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,578,590,591,607,1098,1594,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,578,589,590,591,607,1098,1594,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,590,591,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,558,573,578,590,591,1098,1594,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,590,1098,1595,1596,1597,1598,1599,1648,1651],[94,157,165,169,172,174,175,176,189,249,590,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,578,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,593,594,1098,1602,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,1098,1603,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,593,594,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,578,592,1098,1601,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,573,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,592,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,594,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,573,592,593,594,596,605,634,1098,1604,1605,1608,1610,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,573,593,594,595,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,557,559,573,582,590,592,593,594,596,597,605,1098,1603,1604,1605,1606,1607,1611,1612,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,559,573,578,592,594,1098,1601,1648,1651],[94,157,165,169,172,174,175,176,189,249,593,594,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,573,592,594,596,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,593,594,638,642,1098,1574,1609,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,557,559,590,598,599,600,601,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,598,599,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,598,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,1098,1615,1617,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,602,1098,1578,1584,1593,1600,1613,1614,1648,1651],[94,157,165,169,172,174,175,176,189,249,558,590,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,548,559,604,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,603,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,603,604,605,606,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,634,1098,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,620,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,621,1098,1575,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,621,622,635,1098,1574,1576,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,620,623,634,1098,1576,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,1098,1576,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,624,625,626,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,624,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,623,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,559,624,625,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,217,219,249,559,624,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,623,624,625,626,627,628,629,630,631,632,633,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,1098,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,634,637,1098,1574,1648,1651],[85,94,157,160,165,169,172,174,175,176,189,249,484,557,559,620,625,634,637,638,640,642,644,1098,1557,1558,1572,1573,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,636,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,644,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,634,638,641,642,643,644,645,1098,1556,1557,1574,1577,1616,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,1098,1557,1621,1622,1623,1624,1625,1626,1648,1651],[94,157,165,169,172,174,175,176,189,249,1098,1617,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,634,638,642,645,1098,1557,1574,1616,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,638,641,642,645,1098,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,620,634,638,640,641,642,645,1079,1098,1103,1389,1390,1392,1408,1427,1445,1455,1458,1459,1461,1463,1464,1465,1480,1482,1486,1490,1491,1492,1496,1498,1499,1512,1556,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,638,642,645,1098,1557,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,638,642,644,645,1098,1557,1574,1577,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,638,642,644,645,1098,1557,1574,1619,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,634,641,645,1098,1574,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,557,1098,1609,1621,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,638,641,642,645,1098,1557,1574,1648,1651],[94,157,165,169,172,174,175,176,189,249,638,1098,1648,1651],[94,157,165,169,172,174,175,176,189,249,641,1098,1648,1651],[85,94,157,165,169,172,174,175,176,189,249,638,642,1098,1648,1651]],"fileInfos":[{"version":"c430d44666289dae81f30fa7b2edebf186ecc91a2d4c71266ea6ae76388792e1","affectsGlobalScope":true,"impliedFormat":1},{"version":"45b7ab580deca34ae9729e97c13cfd999df04416a79116c3bfb483804f85ded4","impliedFormat":1},{"version":"3facaf05f0c5fc569c5649dd359892c98a85557e3e0c847964caeb67076f4d75","impliedFormat":1},{"version":"e44bb8bbac7f10ecc786703fe0a6a4b952189f908707980ba8f3c8975a760962","impliedFormat":1},{"version":"5e1c4c362065a6b95ff952c0eab010f04dcd2c3494e813b493ecfd4fcb9fc0d8","impliedFormat":1},{"version":"68d73b4a11549f9c0b7d352d10e91e5dca8faa3322bfb77b661839c42b1ddec7","impliedFormat":1},{"version":"5efce4fc3c29ea84e8928f97adec086e3dc876365e0982cc8479a07954a3efd4","impliedFormat":1},{"version":"feecb1be483ed332fad555aff858affd90a48ab19ba7272ee084704eb7167569","impliedFormat":1},{"version":"ee7bad0c15b58988daa84371e0b89d313b762ab83cb5b31b8a2d1162e8eb41c2","impliedFormat":1},{"version":"27bdc30a0e32783366a5abeda841bc22757c1797de8681bbe81fbc735eeb1c10","impliedFormat":1},{"version":"8fd575e12870e9944c7e1d62e1f5a73fcf23dd8d3a321f2a2c74c20d022283fe","impliedFormat":1},{"version":"2ab096661c711e4a81cc464fa1e6feb929a54f5340b46b0a07ac6bbf857471f0","impliedFormat":1},{"version":"080941d9f9ff9307f7e27a83bcd888b7c8270716c39af943532438932ec1d0b9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2e80ee7a49e8ac312cc11b77f1475804bee36b3b2bc896bead8b6e1266befb43","affectsGlobalScope":true,"impliedFormat":1},{"version":"c57796738e7f83dbc4b8e65132f11a377649c00dd3eee333f672b8f0a6bea671","affectsGlobalScope":true,"impliedFormat":1},{"version":"dc2df20b1bcdc8c2d34af4926e2c3ab15ffe1160a63e58b7e09833f616efff44","affectsGlobalScope":true,"impliedFormat":1},{"version":"515d0b7b9bea2e31ea4ec968e9edd2c39d3eebf4a2d5cbd04e88639819ae3b71","affectsGlobalScope":true,"impliedFormat":1},{"version":"0559b1f683ac7505ae451f9a96ce4c3c92bdc71411651ca6ddb0e88baaaad6a3","affectsGlobalScope":true,"impliedFormat":1},{"version":"0dc1e7ceda9b8b9b455c3a2d67b0412feab00bd2f66656cd8850e8831b08b537","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce691fb9e5c64efb9547083e4a34091bcbe5bdb41027e310ebba8f7d96a98671","affectsGlobalScope":true,"impliedFormat":1},{"version":"8d697a2a929a5fcb38b7a65594020fcef05ec1630804a33748829c5ff53640d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ff2a353abf8a80ee399af572debb8faab2d33ad38c4b4474cff7f26e7653b8d","affectsGlobalScope":true,"impliedFormat":1},{"version":"fb0f136d372979348d59b3f5020b4cdb81b5504192b1cacff5d1fbba29378aa1","affectsGlobalScope":true,"impliedFormat":1},{"version":"d15bea3d62cbbdb9797079416b8ac375ae99162a7fba5de2c6c505446486ac0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"68d18b664c9d32a7336a70235958b8997ebc1c3b8505f4f1ae2b7e7753b87618","affectsGlobalScope":true,"impliedFormat":1},{"version":"eb3d66c8327153d8fa7dd03f9c58d351107fe824c79e9b56b462935176cdf12a","affectsGlobalScope":true,"impliedFormat":1},{"version":"38f0219c9e23c915ef9790ab1d680440d95419ad264816fa15009a8851e79119","affectsGlobalScope":true,"impliedFormat":1},{"version":"69ab18c3b76cd9b1be3d188eaf8bba06112ebbe2f47f6c322b5105a6fbc45a2e","affectsGlobalScope":true,"impliedFormat":1},{"version":"a680117f487a4d2f30ea46f1b4b7f58bef1480456e18ba53ee85c2746eeca012","affectsGlobalScope":true,"impliedFormat":1},{"version":"2f11ff796926e0832f9ae148008138ad583bd181899ab7dd768a2666700b1893","affectsGlobalScope":true,"impliedFormat":1},{"version":"4de680d5bb41c17f7f68e0419412ca23c98d5749dcaaea1896172f06435891fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"954296b30da6d508a104a3a0b5d96b76495c709785c1d11610908e63481ee667","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac9538681b19688c8eae65811b329d3744af679e0bdfa5d842d0e32524c73e1c","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a969edff4bd52585473d24995c5ef223f6652d6ef46193309b3921d65dd4376","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e9fbd7030c440b33d021da145d3232984c8bb7916f277e8ffd3dc2e3eae2bdb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811ec78f7fefcabbda4bfa93b3eb67d9ae166ef95f9bff989d964061cbf81a0c","affectsGlobalScope":true,"impliedFormat":1},{"version":"717937616a17072082152a2ef351cb51f98802fb4b2fdabd32399843875974ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"d7e7d9b7b50e5f22c915b525acc5a49a7a6584cf8f62d0569e557c5cfc4b2ac2","affectsGlobalScope":true,"impliedFormat":1},{"version":"71c37f4c9543f31dfced6c7840e068c5a5aacb7b89111a4364b1d5276b852557","affectsGlobalScope":true,"impliedFormat":1},{"version":"576711e016cf4f1804676043e6a0a5414252560eb57de9faceee34d79798c850","affectsGlobalScope":true,"impliedFormat":1},{"version":"89c1b1281ba7b8a96efc676b11b264de7a8374c5ea1e6617f11880a13fc56dc6","affectsGlobalScope":true,"impliedFormat":1},{"version":"74f7fa2d027d5b33eb0471c8e82a6c87216223181ec31247c357a3e8e2fddc5b","affectsGlobalScope":true,"impliedFormat":1},{"version":"d6d7ae4d1f1f3772e2a3cde568ed08991a8ae34a080ff1151af28b7f798e22ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"063600664504610fe3e99b717a1223f8b1900087fab0b4cad1496a114744f8df","affectsGlobalScope":true,"impliedFormat":1},{"version":"934019d7e3c81950f9a8426d093458b65d5aff2c7c1511233c0fd5b941e608ab","affectsGlobalScope":true,"impliedFormat":1},{"version":"52ada8e0b6e0482b728070b7639ee42e83a9b1c22d205992756fe020fd9f4a47","affectsGlobalScope":true,"impliedFormat":1},{"version":"3bdefe1bfd4d6dee0e26f928f93ccc128f1b64d5d501ff4a8cf3c6371200e5e6","affectsGlobalScope":true,"impliedFormat":1},{"version":"59fb2c069260b4ba00b5643b907ef5d5341b167e7d1dbf58dfd895658bda2867","affectsGlobalScope":true,"impliedFormat":1},{"version":"639e512c0dfc3fad96a84caad71b8834d66329a1f28dc95e3946c9b58176c73a","affectsGlobalScope":true,"impliedFormat":1},{"version":"368af93f74c9c932edd84c58883e736c9e3d53cec1fe24c0b0ff451f529ceab1","affectsGlobalScope":true,"impliedFormat":1},{"version":"af3dd424cf267428f30ccfc376f47a2c0114546b55c44d8c0f1d57d841e28d74","affectsGlobalScope":true,"impliedFormat":1},{"version":"995c005ab91a498455ea8dfb63aa9f83fa2ea793c3d8aa344be4a1678d06d399","affectsGlobalScope":true,"impliedFormat":1},{"version":"959d36cddf5e7d572a65045b876f2956c973a586da58e5d26cde519184fd9b8a","affectsGlobalScope":true,"impliedFormat":1},{"version":"965f36eae237dd74e6cca203a43e9ca801ce38824ead814728a2807b1910117d","affectsGlobalScope":true,"impliedFormat":1},{"version":"3925a6c820dcb1a06506c90b1577db1fdbf7705d65b62b99dce4be75c637e26b","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a3d63ef2b853447ec4f749d3f368ce642264246e02911fcb1590d8c161b8005","affectsGlobalScope":true,"impliedFormat":1},{"version":"8cdf8847677ac7d20486e54dd3fcf09eda95812ac8ace44b4418da1bbbab6eb8","affectsGlobalScope":true,"impliedFormat":1},{"version":"8444af78980e3b20b49324f4a16ba35024fef3ee069a0eb67616ea6ca821c47a","affectsGlobalScope":true,"impliedFormat":1},{"version":"3287d9d085fbd618c3971944b65b4be57859f5415f495b33a6adc994edd2f004","affectsGlobalScope":true,"impliedFormat":1},{"version":"b4b67b1a91182421f5df999988c690f14d813b9850b40acd06ed44691f6727ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"df83c2a6c73228b625b0beb6669c7ee2a09c914637e2d35170723ad49c0f5cd4","affectsGlobalScope":true,"impliedFormat":1},{"version":"436aaf437562f276ec2ddbee2f2cdedac7664c1e4c1d2c36839ddd582eeb3d0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e3c06ea092138bf9fa5e874a1fdbc9d54805d074bee1de31b99a11e2fec239d","affectsGlobalScope":true,"impliedFormat":1},{"version":"87dc0f382502f5bbce5129bdc0aea21e19a3abbc19259e0b43ae038a9fc4e326","affectsGlobalScope":true,"impliedFormat":1},{"version":"b1cb28af0c891c8c96b2d6b7be76bd394fddcfdb4709a20ba05a7c1605eea0f9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2fef54945a13095fdb9b84f705f2b5994597640c46afeb2ce78352fab4cb3279","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac77cb3e8c6d3565793eb90a8373ee8033146315a3dbead3bde8db5eaf5e5ec6","affectsGlobalScope":true,"impliedFormat":1},{"version":"56e4ed5aab5f5920980066a9409bfaf53e6d21d3f8d020c17e4de584d29600ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ece9f17b3866cc077099c73f4983bddbcb1dc7ddb943227f1ec070f529dedd1","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a6282c8827e4b9a95f4bf4f5c205673ada31b982f50572d27103df8ceb8013c","affectsGlobalScope":true,"impliedFormat":1},{"version":"1c9319a09485199c1f7b0498f2988d6d2249793ef67edda49d1e584746be9032","affectsGlobalScope":true,"impliedFormat":1},{"version":"e3a2a0cee0f03ffdde24d89660eba2685bfbdeae955a6c67e8c4c9fd28928eeb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811c71eee4aa0ac5f7adf713323a5c41b0cf6c4e17367a34fbce379e12bbf0a4","affectsGlobalScope":true,"impliedFormat":1},{"version":"51ad4c928303041605b4d7ae32e0c1ee387d43a24cd6f1ebf4a2699e1076d4fa","affectsGlobalScope":true,"impliedFormat":1},{"version":"60037901da1a425516449b9a20073aa03386cce92f7a1fd902d7602be3a7c2e9","affectsGlobalScope":true,"impliedFormat":1},{"version":"d4b1d2c51d058fc21ec2629fff7a76249dec2e36e12960ea056e3ef89174080f","affectsGlobalScope":true,"impliedFormat":1},{"version":"22adec94ef7047a6c9d1af3cb96be87a335908bf9ef386ae9fd50eeb37f44c47","affectsGlobalScope":true,"impliedFormat":1},{"version":"196cb558a13d4533a5163286f30b0509ce0210e4b316c56c38d4c0fd2fb38405","affectsGlobalScope":true,"impliedFormat":1},{"version":"73f78680d4c08509933daf80947902f6ff41b6230f94dd002ae372620adb0f60","affectsGlobalScope":true,"impliedFormat":1},{"version":"c5239f5c01bcfa9cd32f37c496cf19c61d69d37e48be9de612b541aac915805b","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e7f8264d0fb4c5339605a15daadb037bf238c10b654bb3eee14208f860a32ea","affectsGlobalScope":true,"impliedFormat":1},{"version":"782dec38049b92d4e85c1585fbea5474a219c6984a35b004963b00beb1aab538","affectsGlobalScope":true,"impliedFormat":1},{"version":"7e29f41b158de217f94cb9676bf9cbd0cd9b5a46e1985141ed36e075c52bf6ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac51dd7d31333793807a6abaa5ae168512b6131bd41d9c5b98477fc3b7800f9f","impliedFormat":1},{"version":"bd7dee3446a5b94651d58000ddfda40296f073e9372891f65003a524b4620697","impliedFormat":1},{"version":"acd8fd5090ac73902278889c38336ff3f48af6ba03aa665eb34a75e7ba1dccc4","impliedFormat":1},{"version":"d6258883868fb2680d2ca96bc8b1352cab69874581493e6d52680c5ffecdb6cc","impliedFormat":1},{"version":"1b61d259de5350f8b1e5db06290d31eaebebc6baafd5f79d314b5af9256d7153","impliedFormat":1},{"version":"f258e3960f324a956fc76a3d3d9e964fff2244ff5859dcc6ce5951e5413ca826","impliedFormat":1},{"version":"643f7232d07bf75e15bd8f658f664d6183a0efaca5eb84b48201c7671a266979","impliedFormat":1},{"version":"21da358700a3893281ce0c517a7a30cbd46be020d9f0c3f2834d0a8ad1f5fc75","impliedFormat":1},{"version":"d153a11543fd884b596587ccd97aebbeed950b26933ee000f94009f1ab142848","affectsGlobalScope":true,"impliedFormat":1},{"version":"0ccdaa19852d25ecd84eec365c3bfa16e7859cadecf6e9ca6d0dbbbee439743f","affectsGlobalScope":true,"impliedFormat":1},{"version":"438b41419b1df9f1fbe33b5e1b18f5853432be205991d1b19f5b7f351675541e","affectsGlobalScope":true,"impliedFormat":1},{"version":"096116f8fedc1765d5bd6ef360c257b4a9048e5415054b3bf3c41b07f8951b0b","affectsGlobalScope":true,"impliedFormat":1},{"version":"e5e01375c9e124a83b52ee4b3244ed1a4d214a6cfb54ac73e164a823a4a7860a","affectsGlobalScope":true,"impliedFormat":1},{"version":"f90ae2bbce1505e67f2f6502392e318f5714bae82d2d969185c4a6cecc8af2fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"4b58e207b93a8f1c88bbf2a95ddc686ac83962b13830fe8ad3f404ffc7051fb4","affectsGlobalScope":true,"impliedFormat":1},{"version":"1fefabcb2b06736a66d2904074d56268753654805e829989a46a0161cd8412c5","affectsGlobalScope":true,"impliedFormat":1},{"version":"9798340ffb0d067d69b1ae5b32faa17ab31b82466a3fc00d8f2f2df0c8554aaa","affectsGlobalScope":true,"impliedFormat":1},{"version":"c18a99f01eb788d849ad032b31cafd49de0b19e083fe775370834c5675d7df8e","affectsGlobalScope":true,"impliedFormat":1},{"version":"5247874c2a23b9a62d178ae84f2db6a1d54e6c9a2e7e057e178cc5eea13757fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"cdcf9ea426ad970f96ac930cd176d5c69c6c24eebd9fc580e1572d6c6a88f62c","impliedFormat":1},{"version":"23cd712e2ce083d68afe69224587438e5914b457b8acf87073c22494d706a3d0","impliedFormat":1},{"version":"156a859e21ef3244d13afeeba4e49760a6afa035c149dda52f0c45ea8903b338","impliedFormat":1},{"version":"10ec5e82144dfac6f04fa5d1d6c11763b3e4dbbac6d99101427219ab3e2ae887","impliedFormat":1},{"version":"615754924717c0b1e293e083b83503c0a872717ad5aa60ed7f1a699eb1b4ea5c","impliedFormat":1},{"version":"074de5b2fdead0165a2757e3aaef20f27a6347b1c36adea27d51456795b37682","impliedFormat":1},{"version":"68834d631c8838c715f225509cfc3927913b9cc7a4870460b5b60c8dbdb99baf","impliedFormat":1},{"version":"24371e69a38fc33e268d4a8716dbcda430d6c2c414a99ff9669239c4b8f40dea","impliedFormat":1},{"version":"ccab02f3920fc75c01174c47fcf67882a11daf16baf9e81701d0a94636e94556","impliedFormat":1},{"version":"3e11fce78ad8c0e1d1db4ba5f0652285509be3acdd519529bc8fcef85f7dafd9","impliedFormat":1},{"version":"ea6bc8de8b59f90a7a3960005fd01988f98fd0784e14bc6922dde2e93305ec7d","impliedFormat":1},{"version":"36107995674b29284a115e21a0618c4c2751b32a8766dd4cb3ba740308b16d59","impliedFormat":1},{"version":"914a0ae30d96d71915fc519ccb4efbf2b62c0ddfb3a3fc6129151076bc01dc60","impliedFormat":1},{"version":"9c32412007b5662fd34a8eb04292fb5314ec370d7016d1c2fb8aa193c807fe22","impliedFormat":1},{"version":"7fd1b31fd35876b0aa650811c25ec2c97a3c6387e5473eb18004bed86cdd76b6","impliedFormat":1},{"version":"4d327f7d72ad0918275cea3eee49a6a8dc8114ae1d5b7f3f5d0774de75f7439a","impliedFormat":1},{"version":"6ebe8ebb8659aaa9d1acbf3710d7dae3e923e97610238b9511c25dc39023a166","impliedFormat":1},{"version":"e85d7f8068f6a26710bff0cc8c0fc5e47f71089c3780fbede05857331d2ddec9","impliedFormat":1},{"version":"7befaf0e76b5671be1d47b77fcc65f2b0aad91cc26529df1904f4a7c46d216e9","impliedFormat":1},{"version":"0a60a292b89ca7218b8616f78e5bbd1c96b87e048849469cccb4355e98af959a","impliedFormat":1},{"version":"0b6e25234b4eec6ed96ab138d96eb70b135690d7dd01f3dd8a8ab291c35a683a","impliedFormat":1},{"version":"9666f2f84b985b62400d2e5ab0adae9ff44de9b2a34803c2c5bd3c8325b17dc0","impliedFormat":1},{"version":"40cd35c95e9cf22cfa5bd84e96408b6fcbca55295f4ff822390abb11afbc3dca","impliedFormat":1},{"version":"b1616b8959bf557feb16369c6124a97a0e74ed6f49d1df73bb4b9ddf68acf3f3","impliedFormat":1},{"version":"5b03a034c72146b61573aab280f295b015b9168470f2df05f6080a2122f9b4df","impliedFormat":1},{"version":"40b463c6766ca1b689bfcc46d26b5e295954f32ad43e37ee6953c0a677e4ae2b","impliedFormat":1},{"version":"249b9cab7f5d628b71308c7d9bb0a808b50b091e640ba3ed6e2d0516f4a8d91d","impliedFormat":1},{"version":"80aae6afc67faa5ac0b32b5b8bc8cc9f7fa299cff15cf09cc2e11fd28c6ae29e","impliedFormat":1},{"version":"f473cd2288991ff3221165dcf73cd5d24da30391f87e85b3dd4d0450c787a391","impliedFormat":1},{"version":"499e5b055a5aba1e1998f7311a6c441a369831c70905cc565ceac93c28083d53","impliedFormat":1},{"version":"8aee8b6d4f9f62cf3776cda1305fb18763e2aade7e13cea5bbe699112df85214","impliedFormat":1},{"version":"c63b9ada8c72f95aac5db92aea07e5e87ec810353cdf63b2d78f49a58662cf6c","impliedFormat":1},{"version":"1cc2a09e1a61a5222d4174ab358a9f9de5e906afe79dbf7363d871a7edda3955","impliedFormat":1},{"version":"5d0375ca7310efb77e3ef18d068d53784faf62705e0ad04569597ae0e755c401","impliedFormat":1},{"version":"59af37caec41ecf7b2e76059c9672a49e682c1a2aa6f9d7dc78878f53aa284d6","impliedFormat":1},{"version":"addf417b9eb3f938fddf8d81e96393a165e4be0d4a8b6402292f9c634b1cb00d","impliedFormat":1},{"version":"b64d4d1c5f877f9c666e98e833f0205edb9384acc46e98a1fef344f64d6aba44","impliedFormat":1},{"version":"adf27937dba6af9f08a68c5b1d3fce0ca7d4b960c57e6d6c844e7d1a8e53adae","impliedFormat":1},{"version":"12950411eeab8563b349cb7959543d92d8d02c289ed893d78499a19becb5a8cc","impliedFormat":1},{"version":"2e85db9e6fd73cfa3d7f28e0ab6b55417ea18931423bd47b409a96e4a169e8e6","impliedFormat":1},{"version":"c46e079fe54c76f95c67fb89081b3e399da2c7d109e7dca8e4b58d83e332e605","impliedFormat":1},{"version":"c9381908473a1c92cb8c516b184e75f4d226dad95c3a85a5af35f670064d9a2f","impliedFormat":1},{"version":"c3f5289820990ab66b70c7fb5b63cb674001009ff84b13de40619619a9c8175f","affectsGlobalScope":true,"impliedFormat":1},{"version":"b3275d55fac10b799c9546804126239baf020d220136163f763b55a74e50e750","affectsGlobalScope":true,"impliedFormat":1},{"version":"fa68a0a3b7cb32c00e39ee3cd31f8f15b80cac97dce51b6ee7fc14a1e8deb30b","affectsGlobalScope":true,"impliedFormat":1},{"version":"1cf059eaf468efcc649f8cf6075d3cb98e9a35a0fe9c44419ec3d2f5428d7123","affectsGlobalScope":true,"impliedFormat":1},{"version":"6c36e755bced82df7fb6ce8169265d0a7bb046ab4e2cb6d0da0cb72b22033e89","affectsGlobalScope":true,"impliedFormat":1},{"version":"e7721c4f69f93c91360c26a0a84ee885997d748237ef78ef665b153e622b36c1","affectsGlobalScope":true,"impliedFormat":1},{"version":"7a93de4ff8a63bafe62ba86b89af1df0ccb5e40bb85b0c67d6bbcfdcf96bf3d4","affectsGlobalScope":true,"impliedFormat":1},{"version":"90e85f9bc549dfe2b5749b45fe734144e96cd5d04b38eae244028794e142a77e","affectsGlobalScope":true,"impliedFormat":1},{"version":"e0a5deeb610b2a50a6350bd23df6490036a1773a8a71d70f2f9549ab009e67ee","affectsGlobalScope":true,"impliedFormat":1},{"version":"3fad5618174d74a34ee006406d4eb37e8d07dd62eb1315dbf52f48d31a337547","impliedFormat":1},{"version":"7e49f52a159435fc8df4de9dc377ef5860732ca2dc9efec1640531d3cf5da7a3","impliedFormat":1},{"version":"dd4bde4bdc2e5394aed6855e98cf135dfdf5dd6468cad842e03116d31bbcc9bc","impliedFormat":1},{"version":"4d4e879009a84a47c05350b8dca823036ba3a29a3038efed1be76c9f81e45edf","affectsGlobalScope":true,"impliedFormat":1},{"version":"8b50a819485ffe0d237bf0d131e92178d14d11e2aa873d73615a9ec578b341f5","impliedFormat":1},{"version":"9ba13b47cb450a438e3076c4a3f6afb9dc85e17eae50f26d4b2d72c0688c9251","impliedFormat":1},{"version":"b64cd4401633ea4ecadfd700ddc8323a13b63b106ac7127c1d2726f32424622c","impliedFormat":1},{"version":"37c6e5fe5715814412b43cc9b50b24c67a63c4e04e753e0d1305970d65417a60","impliedFormat":1},{"version":"1d024184fb57c58c5c91823f9d10b4915a4867b7934e89115fd0d861a9df27c8","impliedFormat":1},{"version":"ee0e4946247f842c6dd483cbb60a5e6b484fee07996e3a7bc7343dfb68a04c5d","impliedFormat":1},{"version":"ef051f42b7e0ef5ca04552f54c4552eac84099d64b6c5ad0ef4033574b6035b8","impliedFormat":1},{"version":"853a43154f1d01b0173d9cbd74063507ece57170bad7a3b68f3fa1229ad0a92f","impliedFormat":1},{"version":"56231e3c39a031bfb0afb797690b20ed4537670c93c0318b72d5180833d98b72","impliedFormat":1},{"version":"5cc7c39031bfd8b00ad58f32143d59eb6ffc24f5d41a20931269011dccd36c5e","impliedFormat":1},{"version":"12d602a8fe4c2f2ba4f7804f5eda8ba07e0c83bf5cf0cda8baffa2e9967bfb77","affectsGlobalScope":true,"impliedFormat":1},{"version":"f96a48183254c00d24575401f1a761b4ce4927d927407e7862a83e06ce5d6964","impliedFormat":1},{"version":"cc25940cfb27aa538e60d465f98bb5068d4d7d33131861ace43f04fe6947d68f","impliedFormat":1},{"version":"8db46b61a690f15b245cf16270db044dc047dce9f93b103a59f50262f677ea1f","impliedFormat":1},{"version":"01ff95aa1443e3f7248974e5a771f513cb2ac158c8898f470a1792f817bee497","impliedFormat":1},{"version":"757227c8b345c57d76f7f0e3bbad7a91ffca23f1b2547cbed9e10025816c9cb7","impliedFormat":1},{"version":"42a05d8f239f74587d4926aba8cc54792eed8e8a442c7adc9b38b516642aadfe","impliedFormat":1},{"version":"e843c4c3582948689477a98129c080d2a6919cf44b6b1eed8f992642fe141cf5","impliedFormat":1},{"version":"101f482fd48cb4c7c0468dcc6d62c843d842977aea6235644b1edd05e81fbf22","impliedFormat":1},{"version":"266bee0a41e9c3ba335583e21e9277ae03822402cf5e8e1d99f5196853613b98","affectsGlobalScope":true,"impliedFormat":1},{"version":"386606f8a297988535cb1401959041cfa7f59d54b8a9ed09738e65c98684c976","impliedFormat":1},{"version":"4967529644e391115ca5592184d4b63980569adf60ee685f968fd59ab1557188","impliedFormat":1},{"version":"3ef397f12387eff17f550bc484ea7c27d21d43816bbe609d495107f44b97e933","impliedFormat":1},{"version":"1023282e2ba810bc07905d3668349fbd37a26411f0c8f94a70ef3c05fe523fcf","impliedFormat":1},{"version":"b214ebcf76c51b115453f69729ee8aa7b7f8eccdae2a922b568a45c2d7ff52f7","impliedFormat":1},{"version":"429c9cdfa7d126255779efd7e6d9057ced2d69c81859bbab32073bad52e9ba76","impliedFormat":1},{"version":"e236b5eba291f51bdf32c231673e6cab81b5410850e61f51a7a524dddadc0f95","impliedFormat":1},{"version":"9cc9d479fb2283d21495e1eb22dccce6cbeaa1e2d87832fe390f6b61b1ff537d","affectsGlobalScope":true,"impliedFormat":1},{"version":"7f2c62938251b45715fd2a9887060ec4fbc8724727029d1cbce373747252bdd7","impliedFormat":1},{"version":"e3ace08b6bbd84655d41e244677b474fd995923ffef7149ddb68af8848b60b05","impliedFormat":1},{"version":"132580b0e86c48fab152bab850fc57a4b74fe915c8958d2ccb052b809a44b61c","impliedFormat":1},{"version":"90a278f5fab7557e69e97056c0841adf269c42697194f0bd5c5e69152637d4b3","impliedFormat":1},{"version":"69c9a5a9392e8564bd81116e1ed93b13205201fb44cb35a7fde8c9f9e21c4b23","impliedFormat":1},{"version":"5f8fc37f8434691ffac1bfd8fc2634647da2c0e84253ab5d2dd19a7718915b35","impliedFormat":1},{"version":"5981c2340fd8b076cae8efbae818d42c11ffc615994cb060b1cd390795f1be2b","impliedFormat":1},{"version":"3e4e0959c67965a12a0976d58ba1ef64c49d852aaaf0e91148a64d3681ca22c9","impliedFormat":1},{"version":"1edcf2f36fc332615846bde6dcc71a8fe526065505bc5e3dcfd65a14becdf698","affectsGlobalScope":true,"impliedFormat":1},{"version":"0250da3eb85c99624f974e77ef355cdf86f43980251bc371475c2b397ba55bcd","impliedFormat":1},{"version":"f1c93e046fb3d9b7f8249629f4b63dc068dd839b824dd0aa39a5e68476dc9420","impliedFormat":1},{"version":"3d3a5f27ffbc06c885dd4d5f9ee20de61faf877fe2c3a7051c4825903d9a7fdc","impliedFormat":1},{"version":"12806f9f085598ef930edaf2467a5fa1789a878fba077cd27e85dc5851e11834","impliedFormat":1},{"version":"1c7573c37465af751be31717e70588b16a272a974e790427fc9558b8e9b199d1","impliedFormat":1},{"version":"a43fe41c33d0a192a0ecaf9b92e87bef3709c9972e6d53c42c49251ccb962d69","impliedFormat":1},{"version":"a177959203c017fad3ecc4f3d96c8757a840957a4959a3ae00dab9d35961ca6c","affectsGlobalScope":true,"impliedFormat":1},{"version":"6fc727ccf9b36e257ff982ea0badeffbfc2c151802f741bddff00c6af3b784cf","impliedFormat":1},{"version":"ca279fadaa088b63f123c86ffb4dda5116f8dba23e6e93e63a2b48262320be38","impliedFormat":1},{"version":"4844a4c9b4b1e812b257676ed8a80b3f3be0e29bf05e742cc2ea9c3c6865e6c6","impliedFormat":1},{"version":"064878a60367e0407c42fb7ba02a2ea4d83257357dc20088e549bd4d89433e9c","impliedFormat":1},{"version":"cca8917838a876e2d7016c9b6af57cbf11fdf903c5fdd8e613fa31840b2957bf","impliedFormat":1},{"version":"d91ae55e4282c22b9c21bc26bd3ef637d3fe132507b10529ae68bf76f5de785b","impliedFormat":1},{"version":"b484ec11ba00e3a2235562a41898d55372ccabe607986c6fa4f4aba72093749f","impliedFormat":1},{"version":"bc9b17634d5e75b9040d8b414bb5bc936273e8100212816e905e39948cd9de96","impliedFormat":1},{"version":"41ef7992c555671a8fe54db302788adefa191ded810a50329b79d20a6772d14c","impliedFormat":1},{"version":"041a7781b9127ab568d2cdcce62c58fdea7c7407f40b8c50045d7866a2727130","impliedFormat":1},{"version":"4c5e90ddbcd177ad3f2ffc909ae217c87820f1e968f6959e4b6ba38a8cec935e","impliedFormat":1},{"version":"b70dd9a44e1ac42f030bb12e7d79117eac7cb74170d72d381a1e7913320af23a","impliedFormat":1},{"version":"55cdbeebe76a1fa18bbd7e7bf73350a2173926bd3085bb050cf5a5397025ee4e","impliedFormat":1},{"version":"2beff543f6e9a9701df88daeee3cdd70a34b4a1c11cb4c734472195a5cb2af54","impliedFormat":1},{"version":"2e07abf27aa06353d46f4448c0bbac73431f6065eef7113128a5cd804d0c384d","impliedFormat":1},{"version":"be1cc4d94ea60cbe567bc29ed479d42587bf1e6cba490f123d329976b0fe4ee5","impliedFormat":1},{"version":"42bc0e1a903408137c3df2b06dfd7e402cdab5bbfa5fcfb871b22ebfdb30bd0b","impliedFormat":1},{"version":"9894dafe342b976d251aac58e616ac6df8db91fb9d98934ff9dd103e9e82578f","impliedFormat":1},{"version":"413df52d4ea14472c2fa5bee62f7a40abd1eb49be0b9722ee01ee4e52e63beb2","impliedFormat":1},{"version":"db6d2d9daad8a6d83f281af12ce4355a20b9a3e71b82b9f57cddcca0a8964a96","impliedFormat":1},{"version":"446a50749b24d14deac6f8843e057a6355dd6437d1fac4f9e5ce4a5071f34bff","impliedFormat":1},{"version":"182e9fcbe08ac7c012e0a6e2b5798b4352470be29a64fdc114d23c2bab7d5106","impliedFormat":1},{"version":"2f4e6b4d39426a1b85ecf4bdeb9dddbf4d9b3397d95d8555d46f925c9519ec7d","impliedFormat":1},{"version":"78a2869ad0cbf3f9045dda08c0d4562b7e1b2bfe07b19e0db072f5c3c56e9584","impliedFormat":1},{"version":"89d5d28d4f57e000b836ac273079be1b75710e28ce14750d081fb420d37e2ca5","impliedFormat":1},{"version":"fd4e24ccff3966390600d7f5d6aa1fed5a512e92ada735ea5fbc933d313ad3d3","impliedFormat":1},{"version":"b7cddfe1aa6b86b5fad3c9ccb30d05b3ccb165aebbf112f48d2d8a5f69dd98b1","impliedFormat":1},{"version":"a86f82d646a739041d6702101afa82dcb935c416dd93cbca7fd754fd0282ce1f","impliedFormat":1},{"version":"ad0d1d75d129b1c80f911be438d6b61bfa8703930a8ff2be2f0e1f8a91841c64","impliedFormat":1},{"version":"bd2c7ada3dee03653d3f601011d30072194bc3970cd93208f9588fbdc0c69347","impliedFormat":1},{"version":"e480da45d32313e7174b265674da504f075f59ef326852f0c5a5d863b438ae85","impliedFormat":1},{"version":"ad54850f61fcf5d014e11be80d2f46fea9265cfa7e77456da876f7833ef81769","impliedFormat":1},{"version":"6f7c9e8bd2b5b6a080b07080065f94900bd3c7e5ebbd3047bc33fcce2fab1dd8","impliedFormat":1},{"version":"3e7efde639c6a6c3edb9847b3f61e308bf7a69685b92f665048c45132f51c218","impliedFormat":1},{"version":"df45ca1176e6ac211eae7ddf51336dc075c5314bc5c253651bae639defd5eec5","impliedFormat":1},{"version":"8a0e762ceb20c7e72504feef83d709468a70af4abccb304f32d6b9bac1129b2c","impliedFormat":1},{"version":"da5950ee2a90721df6f3fba45f5d05308f7e4c35835392215dd2cd404505e2de","impliedFormat":1},{"version":"ce75b1aebb33d510ff28af960a9221410a3eaf7f18fc5f21f9404075fba77256","impliedFormat":1},{"version":"f42d5fed19610d485c646a0c430e768115567d078c7fc855c57b0c578b3d6cd3","impliedFormat":1},{"version":"ee8df1cb8d0faaca4013a1b442e99130769ce06f438d18d510fed95890067563","impliedFormat":1},{"version":"d5630f2ad9b4541e5ce891648121022f9412ecdca1820baa1f0104f70fd7eff7","impliedFormat":1},{"version":"4d15375ab13497104bc8fe56fdef2b5fd6853f29255737d23a33fa306ff7fd69","impliedFormat":1},{"version":"2cd3fc1d0d6a1e85baffd2d4f50f5efb192b5446eef567e97c94765402f0aad4","impliedFormat":1},{"version":"e4cbf2f1e89ecccaddd2c045e600ae41b732295953fb06247c7dcbc2d281ed30","impliedFormat":1},{"version":"6dcedaef57dff0d79a05ab0ab602cde74db803d1e765468bf91263786a383e1b","impliedFormat":1},{"version":"8c1697d90c394a6fd955b98eae01238eff628e129b987a68aea10f898a48e7da","impliedFormat":1},{"version":"7580e62139cb2b44a0270c8d01abcbfcba2819a02514a527342447fa69b34ef1","impliedFormat":1},{"version":"42c169fb8c2d42f4f668c624a9a11e719d5d07dacbebb63cbcf7ef365b0a75b3","impliedFormat":1},{"version":"f374cb24e93e7798c4d9e83ff872fa52d2cdb36306392b840a6ddf46cb925cb6","impliedFormat":1},{"version":"d10d63718e1646c2279e3b33831f82c60e31f622b2b7020f1196409ca4c09242","impliedFormat":1},{"version":"106c6025f1d99fd468fd8bf6e5bda724e11e5905a4076c5d29790b6c3745e50c","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"148679c6d0f449210a96e7d2e562d589e56fcde87f843a92808b3ff103f1a774","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"02436d7e9ead85e09a2f8e27d5f47d9464bced31738dec138ca735390815c9f0","impliedFormat":1},{"version":"f8d5ff8eafd37499f2b6a98659dd9b45a321de186b8db6b6142faed0fea3de77","impliedFormat":1},{"version":"c86fe861cf1b4c46a0fb7d74dffe596cf679a2e5e8b1456881313170f092e3fa","impliedFormat":1},{"version":"a22dd55aa4d39906252000ab8e8a1b83b195eef7f4274eb51e457c1f11cf6580","impliedFormat":1},{"version":"540cc83ab772a2c6bc509fe1354f314825b5dba3669efdfbe4693ecd3048e34f","impliedFormat":1},{"version":"121b0696021ab885c570bbeb331be8ad82c6efe2f3b93a6e63874901bebc13e3","impliedFormat":1},{"version":"612d9da66bb046a9c1e2e8d026245ded881fc4b9f98cbfae714415d57ee0ae0b","impliedFormat":1},{"version":"32c2ad9494dad5d11b0564a619fee18f388db6c1e9e2cd3c360b3122549691eb","impliedFormat":1},{"version":"6c301d40aec56a74ec7bd7324e31a728dadf9bfba3e96def02938d3d973534ec","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"aa14cee20aa0db79f8df101fc027d929aec10feb5b8a8da3b9af3895d05b7ba2","impliedFormat":1},{"version":"493c700ac3bd317177b2eb913805c87fe60d4e8af4fb39c41f04ba81fae7e170","impliedFormat":1},{"version":"aeb554d876c6b8c818da2e118d8b11e1e559adbe6bf606cc9a611c1b6c09f670","impliedFormat":1},{"version":"acf5a2ac47b59ca07afa9abbd2b31d001bf7448b041927befae2ea5b1951d9f9","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"d71291eff1e19d8762a908ba947e891af44749f3a2cbc5bd2ec4b72f72ea795f","impliedFormat":1},{"version":"c0480e03db4b816dff2682b347c95f2177699525c54e7e6f6aa8ded890b76be7","impliedFormat":1},{"version":"25a5f6fd3a2243c859eddc99ab5fba11d970af2fe7a5df9c32b7668f76f97b01","impliedFormat":1},{"version":"8d207e1f9d2c30d6f77dfa693f3827c3fbf0d89240297e10bdfe1041d433df68","impliedFormat":1},{"version":"b620391fe8060cf9bedc176a4d01366e6574d7a71e0ac0ab344a4e76576fcbb8","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"2652448ac55a2010a1f71dd141f828b682298d39728f9871e1cdf8696ef443fd","impliedFormat":1},{"version":"d682336018141807fb602709e2d95a192828fcb8d5ba06dda3833a8ea98f69e3","impliedFormat":1},{"version":"6124e973eab8c52cabf3c07575204efc1784aca6b0a30c79eb85fe240a857efa","impliedFormat":1},{"version":"0d891735a21edc75df51f3eb995e18149e119d1ce22fd40db2b260c5960b914e","impliedFormat":1},{"version":"3b414b99a73171e1c4b7b7714e26b87d6c5cb03d200352da5342ab4088a54c85","impliedFormat":1},{"version":"4fbd3116e00ed3a6410499924b6403cc9367fdca303e34838129b328058ede40","impliedFormat":1},{"version":"9c82171d836c47486074e4ca8e059735bf97b205e70b196535b5efd40cbe1bc5","impliedFormat":1},{"version":"8c70ddc0c22d85e56011d49fddfaae3405eb53d47b59327b9dd589e82df672e7","impliedFormat":1},{"version":"2f9c89cbb29d362290531b48880a4024f258c6033aaeb7e59fbc62db26819650","impliedFormat":1},{"version":"a365c4d3bed3be4e4e20793c999c51f5cd7e6792322f14650949d827fbcd170f","impliedFormat":1},{"version":"c5426dbfc1cf90532f66965a7aa8c1136a78d4d0f96d8180ecbfc11d7722f1a5","impliedFormat":1},{"version":"65a15fc47900787c0bd18b603afb98d33ede930bed1798fc984d5ebb78b26cf9","impliedFormat":1},{"version":"9d202701f6e0744adb6314d03d2eb8fc994798fc83d91b691b75b07626a69801","impliedFormat":1},{"version":"de9d2df7663e64e3a91bf495f315a7577e23ba088f2949d5ce9ec96f44fba37d","impliedFormat":1},{"version":"c7af78a2ea7cb1cd009cfb5bdb48cd0b03dad3b54f6da7aab615c2e9e9d570c5","impliedFormat":1},{"version":"1ee45496b5f8bdee6f7abc233355898e5bf9bd51255db65f5ff7ede617ca0027","impliedFormat":1},{"version":"273782b8454e78f6a8b30d2cfbf6860499c930595095fcc1689637115f0eddda","affectsGlobalScope":true,"impliedFormat":1},{"version":"3fbdd025f9d4d820414417eeb4107ffa0078d454a033b506e22d3a23bc3d9c41","affectsGlobalScope":true,"impliedFormat":1},{"version":"dba114fb6a32b355a9cfc26ca2276834d72fe0e94cd2c3494005547025015369","impliedFormat":1},{"version":"a8f8e6ab2fa07b45251f403548b78eaf2022f3c2254df3dc186cb2671fe4996d","affectsGlobalScope":true,"impliedFormat":1},{"version":"fa6c12a7c0f6b84d512f200690bfc74819e99efae69e4c95c4cd30f6884c526e","impliedFormat":1},{"version":"f1c32f9ce9c497da4dc215c3bc84b722ea02497d35f9134db3bb40a8d918b92b","impliedFormat":1},{"version":"b73c319af2cc3ef8f6421308a250f328836531ea3761823b4cabbd133047aefa","affectsGlobalScope":true,"impliedFormat":1},{"version":"e433b0337b8106909e7953015e8fa3f2d30797cea27141d1c5b135365bb975a6","impliedFormat":1},{"version":"9f9bb6755a8ce32d656ffa4763a8144aa4f274d6b69b59d7c32811031467216e","impliedFormat":1},{"version":"5c32bdfbd2d65e8fffbb9fbda04d7165e9181b08dad61154961852366deb7540","impliedFormat":1},{"version":"ddff7fc6edbdc5163a09e22bf8df7bef75f75369ebd7ecea95ba55c4386e2441","impliedFormat":1},{"version":"0c05e9842ec4f8b7bfebfd3ca61604bb8c914ba8da9b5337c4f25da427a005f2","impliedFormat":1},{"version":"faed7a5153215dbd6ebe76dfdcc0af0cfe760f7362bed43284be544308b114cf","impliedFormat":1},{"version":"7029e566b8df176f703fb59fd437a38670c7a0e02c58b2d66dfb5b2e2b2defdb","impliedFormat":1},{"version":"7f2aa4d4989a82530aaac3f72b3dceca90e9c25bee0b1a327e8a08a1262435ad","impliedFormat":1},{"version":"d96b39301d0ded3f1a27b47759676a33a02f6f5049bfcbde81e533fd10f50dcb","impliedFormat":1},{"version":"e9f147ecca73d9346a4c073432843c159ccbe50bdcb678a78f6da10eae2cecf4","impliedFormat":1},{"version":"de061f7d72bd65c06fc1419f841dfdcb29a8e22fe6fa527d1e6eb20b897d4de0","impliedFormat":1},{"version":"663beafc2446079574570cba86e9b15f986f908ddb1b01274509970126fee945","impliedFormat":1},{"version":"a3102887d5058bf4cb5b37fa6964c09e9527c42053b3b5c642b89878620748de","impliedFormat":1},{"version":"0aaaa1727edd29673d85c9b26d7ca4d54e5407a48586903c51b48b7f7d196f61","impliedFormat":1},{"version":"d35bca0b261bff02635758c48e8ab99c61c420d0dfabbcf467e847171d876b7d","impliedFormat":1},{"version":"3bc12c40d90c342ff88a3d876996c555ed5cbee5fe8c3308a240b321f401ee46","impliedFormat":1},{"version":"ba130768aae855a5477e9e148e5c879548e6e7ccbcc56fd1934c8a18ea5b7569","impliedFormat":1},{"version":"2e4f37ffe8862b14d8e24ae8763daaa8340c0df0b859d9a9733def0eee7562d9","impliedFormat":1},{"version":"d38530db0601215d6d767f280e3a3c54b2a83b709e8d9001acb6f61c67e965fc","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"b499af2054a037a162b3b72cd886f48bbf32a3502c865c6e29fac7d2ab3ce0b5","impliedFormat":1},{"version":"b83cb14474fa60c5f3ec660146b97d122f0735627f80d82dd03e8caa39b4388c","impliedFormat":1},{"version":"48773ca557b0319c2ee62ae249cf52a81709e8be139920d6479a66274de7c4ed","impliedFormat":1},{"version":"7274fbffbd7c9589d8d0ffba68157237afd5cecff1e99881ea3399127e60572f","impliedFormat":1},{"version":"b73cbf0a72c8800cf8f96a9acfe94f3ad32ca71342a8908b8ae484d61113f647","impliedFormat":1},{"version":"bae6dd176832f6423966647382c0d7ba9e63f8c167522f09a982f086cd4e8b23","impliedFormat":1},{"version":"20865ac316b8893c1a0cc383ccfc1801443fbcc2a7255be166cf90d03fac88c9","impliedFormat":1},{"version":"c9958eb32126a3843deedda8c22fb97024aa5d6dd588b90af2d7f2bfac540f23","impliedFormat":1},{"version":"461d0ad8ae5f2ff981778af912ba71b37a8426a33301daa00f21c6ccb27f8156","impliedFormat":1},{"version":"e927c2c13c4eaf0a7f17e6022eee8519eb29ef42c4c13a31e81a611ab8c95577","impliedFormat":1},{"version":"fcafff163ca5e66d3b87126e756e1b6dfa8c526aa9cd2a2b0a9da837d81bbd72","impliedFormat":1},{"version":"70246ad95ad8a22bdfe806cb5d383a26c0c6e58e7207ab9c431f1cb175aca657","impliedFormat":1},{"version":"f00f3aa5d64ff46e600648b55a79dcd1333458f7a10da2ed594d9f0a44b76d0b","impliedFormat":1},{"version":"772d8d5eb158b6c92412c03228bd9902ccb1457d7a705b8129814a5d1a6308fc","impliedFormat":1},{"version":"802e797bcab5663b2c9f63f51bdf67eff7c41bc64c0fd65e6da3e7941359e2f7","impliedFormat":1},{"version":"b01bd582a6e41457bc56e6f0f9de4cb17f33f5f3843a7cf8210ac9c18472fb0f","impliedFormat":1},{"version":"8b4327413e5af38cd8cb97c59f48c3c866015d5d642f28518e3a891c469f240e","impliedFormat":1},{"version":"4cceef18d7f088e797a463e90b7a9dad10c6bc667724b7686e3e740ae00122be","impliedFormat":1},{"version":"7ee86fbb3754388e004de0ef9e6505485ddfb3be7640783d6d015711c03d302d","impliedFormat":1},{"version":"cc1954b539604b1e562319119ac7e888172208b32ca873f9a357a92c826bd046","impliedFormat":1},{"version":"a67b87d0281c97dfc1197ef28dfe397fc2c865ccd41f7e32b53f647184cc7307","impliedFormat":1},{"version":"771ffb773f1ddd562492a6b9aaca648192ac3f056f0e1d997678ff97dbb6bf9b","impliedFormat":1},{"version":"43e96a3d5d1411ab40ba2f61d6a3192e58177bcf3b133a80ad2a16591611726d","impliedFormat":1},{"version":"232f70c0cf2b432f3a6e56a8dc3417103eb162292a9fd376d51a3a9ea5fbbf6f","impliedFormat":1},{"version":"bb8f2dbc03533abca2066ce4655c119bff353dd4514375beb93c08590c03e023","impliedFormat":1},{"version":"706dd95827e7ebaabda91d5db2b755233e0952d98570e9c032b0f066a15c1177","affectsGlobalScope":true,"impliedFormat":1},{"version":"0b103e9abfe82d14c0ad06a55d9f91d6747154ef7cacc73cf27ecad2bfb3afcf","impliedFormat":1},{"version":"cd9304972e6d616197fb44fce00540a904f38b54306a1951b5dbeaf3c01ab5bd","impliedFormat":1},{"version":"77438e2c397a3db78407621cfc57241a305b310ddea2c185f1d555248297f587","impliedFormat":1},{"version":"120599fd965257b1f4d0ff794bc696162832d9d8467224f4665f713a3119078b","impliedFormat":1},{"version":"43ba4f2fa8c698f5c304d21a3ef596741e8e85a810b7c1f9b692653791d8d97a","impliedFormat":1},{"version":"5433f33b0a20300cca35d2f229a7fc20b0e8477c44be2affeb21cb464af60c76","impliedFormat":1},{"version":"db036c56f79186da50af66511d37d9fe77fa6793381927292d17f81f787bb195","impliedFormat":1},{"version":"a6805fcafed712aea7759f8bc731014f9d22738c1d6ef9d43b8091d1d48346d5","impliedFormat":1},{"version":"c49469a5349b3cc1965710b5b0f98ed6c028686aa8450bcb3796728873eb923e","impliedFormat":1},{"version":"4a889f2c763edb4d55cb624257272ac10d04a1cad2ed2948b10ed4a7fda2a428","impliedFormat":1},{"version":"7bb79aa2fead87d9d56294ef71e056487e848d7b550c9a367523ee5416c44cfa","impliedFormat":1},{"version":"d88ea80a6447d7391f52352ec97e56b52ebec934a4a4af6e2464cfd8b39c3ba8","impliedFormat":1},{"version":"142617b3cdf902b69c6464c9fbd942b60ab3e733ca18c032b19e0f7e2adbefe8","impliedFormat":1},{"version":"0b603555f1881f87256ffd6344d3e3ed6d466c2e701eabf381f28be8c2125892","impliedFormat":1},{"version":"897e4f7662488e3ecc79e743bdd3b78f13bdb69a97851afa5b440c4211e32ea9","impliedFormat":1},{"version":"e2e1c6d3b2d93add5200bd7bc1a8cccb4e446836b2111ece45db8683a2c765de","impliedFormat":1},{"version":"251b03d5cd243854ce870d9a9a39f491faf69898c5d6b5eee28cc7649c57417b","impliedFormat":1},{"version":"27ff4196654e6373c9af16b6165120e2dd2169f9ad6abb5c935af5abd8c7938c","impliedFormat":1},{"version":"2c4de79f406d137390608e8c0a44fba2ff8e00bacfcae7c9d1781fef10e9440d","impliedFormat":1},{"version":"07ba23a10465791be5d22deaf5ef7de7658774ddff53721e5ea17fedea1bc721","impliedFormat":1},{"version":"dca8c645c5afeb03b1ecedbf16323f33e7d0afaa6256c8e047e6e38087a97f53","impliedFormat":1},{"version":"775f181bd4a533d6f8b5e55ec1d9f1624559720ae8a70e9432258da26b38d27c","impliedFormat":1},{"version":"796273b2edc72e78a04e86d7c58ae94d370ab93a0ddf40b1aa85a37a1c29ecd7","impliedFormat":1},{"version":"5df15a69187d737d6d8d066e189ae4f97e41f4d53712a46b2710ff9f8563ec9f","impliedFormat":1},{"version":"7715134a0cf07dd41a9da2895d708625a3a303a0385e355ecaaf0b8bfaef2550","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"622694a8522b46f6310c2a9b5d2530dde1e2854cb5829354e6d1ff8f371cf469","impliedFormat":1},{"version":"cd8ce8d68567f62dd580b3c3c37777ac3f5b81944c7417f5ea83030eab533385","impliedFormat":1},{"version":"e5c939d896565dcac0f6fbdbada11284e7728ef26a069561c09aa5aa4a788393","impliedFormat":1},{"version":"9e2739b32f741859263fdba0244c194ca8e96da49b430377930b8f721d77c000","impliedFormat":1},{"version":"a9e6c0ff3f8186fccd05752cf75fc94e147c02645087ac6de5cc16403323d870","impliedFormat":1},{"version":"49af4b52f0d4d2304c5f2c6fe5fab3e153e0acc38830d0202821b877c097dd02","impliedFormat":1},{"version":"49c346823ba6d4b12278c12c977fb3a31c06b9ca719015978cb145eb86da1c61","impliedFormat":1},{"version":"bfac6e50eaa7e73bb66b7e052c38fdc8ccfc8dbde2777648642af33cf349f7f1","impliedFormat":1},{"version":"92f7c1a4da7fbfd67a2228d1687d5c2e1faa0ba865a94d3550a3941d7527a45d","impliedFormat":1},{"version":"f53b120213a9289d9a26f5af90c4c686dd71d91487a0aa5451a38366c70dc64b","impliedFormat":1},{"version":"e68b8e5a1df7c1be2bc105141456ecba70215806e1c28bfbc5c12bfce4be6e68","impliedFormat":1},{"version":"511c8f02329808d47d00b859c532ae9115590048b17325a946c74dac48428650","impliedFormat":1},{"version":"57d67b72e06059adc5e9454de26bbfe567d412b962a501d263c75c2db430f40e","impliedFormat":1},{"version":"b5f9e66625783eefcbe3d2da074b2e7ba2066d61ce3fc6ef4f22805ad946cab4","impliedFormat":1},{"version":"e37115962d284b9f7a37c2bdd2add50f88365dde41f5e0ff591ffc48a8ec7575","impliedFormat":1},{"version":"6459054aabb306821a043e02b89d54da508e3a6966601a41e71c166e4ea1474f","impliedFormat":1},{"version":"bb37588926aba35c9283fe8d46ebf4e79ffe976343105f5c6d45f282793352b2","impliedFormat":1},{"version":"f89488602bec98a142072fae7ea5ba99431a569ff580c64b7be39896474799d8","impliedFormat":1},{"version":"bbbc47961f39a57df103cf4ca3bb8f8732b4b6678a18225a0aa76d59c466956c","impliedFormat":1},{"version":"2e6114a7dd6feeef85b2c80120fdbfb59a5529c0dcc5bfa8447b6996c97a69f5","impliedFormat":1},{"version":"2ffb043dc5163458e473b7010859f86e01dc4edffcae0a93d885d028b426a546","impliedFormat":1},{"version":"c8f004e6036aa1c764ad4ec543cf89a5c1893a9535c80ef3f2b653e370de45e6","impliedFormat":1},{"version":"dd80b1e600d00f5c6a6ba23f455b84a7db121219e68f89f10552c54ba46e4dc9","impliedFormat":1},{"version":"b064c36f35de7387d71c599bfcf28875849a1dbc733e82bd26cae3d1cd060521","impliedFormat":1},{"version":"05c7280d72f3ed26f346cbe7cbbbb002fb7f15739197cbbee6ab3fd1a6cb9347","impliedFormat":1},{"version":"8de9fe97fa9e00ec00666fa77ab6e91b35d25af8ca75dabcb01e14ad3299b150","impliedFormat":1},{"version":"04b7b2e0832dfd3c31e81df3975e8d8fda28e7ff999b0aa2932608a8f6661d5c","impliedFormat":1},{"version":"ca2d34c6ed5cbd3070b8b6f32f42ae54adcc6499c1e4b99f0a5798b3f27cc653","impliedFormat":1},{"version":"9ec68995e66dd6b9dac834bf5ae85fde802714ea2e82151a5d1d53ef01b463ef","impliedFormat":1},{"version":"5c4d626b4902f2ef8a1cc146d761d276cef988016dc674e3b98fbad70e64bc9f","impliedFormat":1},{"version":"fdfaa0aad899524962e2955287b5b991ffe3be50f64e02eb60c933ca44644a94","impliedFormat":1},{"version":"53c972a0f9bc3a4ec70fff7314123ea8cfcf75b3703046f767d2dc1eea87b2fb","impliedFormat":1},{"version":"f974e4a06953682a2c15d5bd5114c0284d5abf8bc0fe4da25cb9159427b70072","impliedFormat":1},{"version":"50256e9c31318487f3752b7ac12ff365c8949953e04568009c8705db802776fb","impliedFormat":1},{"version":"7d73b24e7bf31dfb8a931ca6c4245f6bb0814dfae17e4b60c9e194a631fe5f7b","impliedFormat":1},{"version":"d130c5f73768de51402351d5dc7d1b36eaec980ca697846e53156e4ea9911476","impliedFormat":1},{"version":"413586add0cfe7369b64979d4ec2ed56c3f771c0667fbde1bf1f10063ede0b08","impliedFormat":1},{"version":"06472528e998d152375ad3bd8ebcb69ff4694fd8d2effaf60a9d9f25a37a097a","impliedFormat":1},{"version":"7303b45138d2511035056a5901a1490ebdcbf055cbb1276f8629c5121cbe733e","impliedFormat":1},{"version":"27f874cd5327507eeff699a74567f60c1215b94509f4308633a7b01922471ed2","impliedFormat":1},{"version":"a401617604fa1f6ce437b81689563dfdc377069e4c58465dbd8d16069aede0a5","impliedFormat":1},{"version":"2c6cf04bc525caf6546e859e8ef10bfb9573837ec0bc5ec7b53a7b1b8ca72781","impliedFormat":1},{"version":"8695dec09ad439b0ceef3776ea68a232e381135b516878f0901ed2ea114fd0fe","impliedFormat":1},{"version":"304b44b1e97dd4c94697c3313df89a578dca4930a104454c99863f1784a54357","impliedFormat":1},{"version":"0a437ae178f999b46b6153d79095b60c42c996bc0458c04955f1c996dc68b971","impliedFormat":1},{"version":"74b2a5e5197bd0f2e0077a1ea7c07455bbea67b87b0869d9786d55104006784f","impliedFormat":1},{"version":"4a7baeb6325920044f66c0f8e5e6f1f52e06e6d87588d837bdf44feb6f35c664","impliedFormat":1},{"version":"87cc05fe13108f02e12da7e3efd8e360fef78d96a0c9e11408ea1b1b9fb3e03d","impliedFormat":1},{"version":"1abbf67c218d23c2ce76887caac2df6c7dab3d97ba2b65348432b876f510002a","impliedFormat":1},{"version":"1a82deef4c1d39f6882f28d275cad4c01f907b9b39be9cbc472fcf2cf051e05b","impliedFormat":1},{"version":"4b20fcf10a5413680e39f5666464859fc56b1003e7dfe2405ced82371ebd49b6","impliedFormat":1},{"version":"c06ef3b2569b1c1ad99fcd7fe5fba8d466e2619da5375dfa940a94e0feea899b","impliedFormat":1},{"version":"f7d628893c9fa52ba3ab01bcb5e79191636c4331ee5667ecc6373cbccff8ae12","impliedFormat":1},{"version":"1d879125d1ec570bf04bc1f362fdbe0cb538315c7ac4bcfcdf0c1e9670846aa6","impliedFormat":1},{"version":"dad97c99382889e9c7d1a9d8275500ff71235130fae9f8916fdbf3641d56e592","impliedFormat":1},{"version":"a6dba407fc287f1e25454e75028c91bbc00675f2d1c4e8b3edcc36c08611a486","impliedFormat":1},{"version":"d663134457d8d669ae0df34eabd57028bddc04fc444c4bc04bc5215afc91e1f4","impliedFormat":1},{"version":"e91f7b1344577a02f051b9b471f33044fef8334a76dc9e1de003d17595a5219b","impliedFormat":1},{"version":"c0723195c85e19656d6b5b9fdb81d3f3403c1ae4679e722c6ea058c516b38d12","impliedFormat":1},{"version":"b55eb9f72166093b5460d34b34f5d8699c968de3bc3fc696e40f2c93f2ebf650","impliedFormat":1},{"version":"71d9eb4c4e99456b78ae182fb20a5dfc20eb1667f091dbb9335b3c017dd1c783","impliedFormat":1},{"version":"cfa846a7b7847a1d973605fbb8c91f47f3a0f0643c18ac05c47077ebc72e71c7","impliedFormat":1},{"version":"1594da19968752a22b2ac48c2d0e60575700e745c577a8a4a676b841238ad5bb","impliedFormat":1},{"version":"e0cee12109e0a10a4c3d6769fcc7644b7c1ea7f52365bea51728f5af29f8a137","impliedFormat":1},{"version":"7d4254b4c6c67a29d5e7f65e67d72540480ac2cfb041ca484847f5ae70480b62","impliedFormat":1},{"version":"3536968defef8a75514f547ead5e2e9c1e984820290ec9b00c5fdfb6ef786535","impliedFormat":1},{"version":"d83773870080c30a230e322ce13a9c6f3398e8dacea4ea8a83e26370f3bac23e","impliedFormat":1},{"version":"dcfeaf98d66314fec29a9076c4290e45d0b196a65827becc19138e9c7b855f37","impliedFormat":1},{"version":"6849fe9210fe4946d5f085bfed36758f33dc6ae15a751338d178dd4daa017c46","impliedFormat":1},{"version":"888cda0fa66d7f74e985a3f7b1af1f64b8ff03eb3d5e80d051c3cbdeb7f32ab7","impliedFormat":1},{"version":"60681e13f3545be5e9477acb752b741eae6eaf4cc01658a25ec05bff8b82a2ef","impliedFormat":1},{"version":"ffae4e1e06aa848a1e4bcef162cd1c48e5909b26223515981310af9c036bdfc7","impliedFormat":1},{"version":"a57b1802794433adec9ff3fed12aa79d671faed86c49b09e02e1ac41b4f1d33a","impliedFormat":1},{"version":"34e16eb7c31768a11a08aebcfb3d70d7b8f0b016197e98d8419e566ceae6d6c8","impliedFormat":1},{"version":"f94ec1f7e4b709d26960306c9082a7a1b728a6e13089346aa48ba57c74cbf47e","impliedFormat":1},{"version":"9a11cb4033405e96c247cd5aa29790212aaffdd127869e8a5219103f0b389fd5","impliedFormat":1},{"version":"01479d9d5a5dda16d529b91811375187f61a06e74be294a35ecce77e0b9e8d6c","impliedFormat":1},{"version":"aff5213585cb72e94054dfe17250ff315f3569b3919d1ef1ad235f37c4ee894e","impliedFormat":1},{"version":"fb2ea35e1be6388d722d7725e2b49c697d34d9c890c3b96758faaeb86d35cef8","impliedFormat":1},{"version":"ce0df82a9ae6f914ba08409d4d883983cc08e6d59eb2df02d8e4d68309e7848b","impliedFormat":1},{"version":"1a4dc28334a926d90ba6a2d811ba0ff6c22775fcc13679521f034c124269fd40","impliedFormat":1},{"version":"f05315ff85714f0b87cc0b54bcd3dde2716e5a6b99aedcc19cad02bf2403e08c","impliedFormat":1},{"version":"5fad3b31fc17a5bc58095118a8b160f5260964787c52e7eb51e3d4fcf5d4a6f0","impliedFormat":1},{"version":"72105519d0390262cf0abe84cf41c926ade0ff475d35eb21307b2f94de985778","impliedFormat":1},{"version":"456006a6975b26c0a1785feddae165f6d307e2d601ffde27e21fc4a790e448a4","impliedFormat":1},{"version":"c857e0aae3f5f444abd791ec81206020fbcc1223e187316677e026d1c1d6fe08","impliedFormat":1},{"version":"ccf6dd45b708fb74ba9ed0f2478d4eb9195c9dfef0ff83a6092fa3cf2ff53b4f","impliedFormat":1},{"version":"1fe0d18b111e1145a7e7601855bccd4ca20f24e3b9a5aba6bb1fa9d1a7059170","impliedFormat":1},{"version":"5632c3c26d420c063eebe64c45b1248b9492a67bf44f1d0c57e9dc8f6cf449bb","impliedFormat":1},{"version":"0df5aa619ab12993a39ea6dae062ee46eadbb4d738916460e636ada52bced75b","impliedFormat":1},{"version":"8fca3039857709484e5893c05c1f9126ab7451fa6c29e19bb8c2411a2e937345","impliedFormat":1},{"version":"35069c2c417bd7443ae7c7cafd1de02f665bf015479fec998985ffbbf500628c","impliedFormat":1},{"version":"10ab7be91f87ebe8916b62cf28af2e45b5601fc7b0e311adf838f912c6b31dd8","impliedFormat":1},{"version":"bc636fbc08e0979ceb7eb0731a33000283d77a33b62e1f71ee65be50394e40ba","impliedFormat":1},{"version":"7e0b7f91c5ab6e33f511efc640d36e6f933510b11be24f98836a20a2dc914c2d","impliedFormat":1},{"version":"045b752f44bf9bbdcaffd882424ab0e15cb8d11fa94e1448942e338c8ef19fba","impliedFormat":1},{"version":"2894c56cad581928bb37607810af011764a2f511f575d28c9f4af0f2ef02d1ab","impliedFormat":1},{"version":"0a72186f94215d020cb386f7dca81d7495ab6c17066eb07d0f44a5bf33c1b21a","impliedFormat":1},{"version":"75bbd3be047d539988a0ff0b56384ef7a6a25f3b676ad96bee547d44c31622a7","impliedFormat":1},{"version":"42960001a776b089ade681ab5cfddc936e0afb0615133ec1841f3dee89d3e1bf","impliedFormat":1},{"version":"0aedb02516baf3e66b2c1db9fef50666d6ed257edac0f866ea32f1aa05aa474f","impliedFormat":1},{"version":"da47712b394d944328245482603bc6f416d3949b67c9392279caab595076b510","affectsGlobalScope":true,"impliedFormat":1},{"version":"37d0071d8f0a06dc55c2c5e0ec3391affd4fd107c53410bf358196ec0bf3923f","impliedFormat":1},{"version":"b213dad76ca37fd552274c9499056e1c0d9c1bd38a55bb7f68b22ba6b84c3ad7","impliedFormat":1},{"version":"56ccb49443bfb72e5952f7012f0de1a8679f9f75fc93a5c1ac0bafb28725fc5f","impliedFormat":1},{"version":"20fa37b636fdcc1746ea0738f733d0aed17890d1cd7cb1b2f37010222c23f13e","impliedFormat":1},{"version":"d90b9f1520366d713a73bd30c5a9eb0040d0fb6076aff370796bc776fd705943","impliedFormat":1},{"version":"bc03c3c352f689e38c0ddd50c39b1e65d59273991bfc8858a9e3c0ebb79c023b","impliedFormat":1},{"version":"19df3488557c2fc9b4d8f0bac0fd20fb59aa19dec67c81f93813951a81a867f8","affectsGlobalScope":true,"impliedFormat":1},{"version":"b25350193e103ae90423c5418ddb0ad1168dc9c393c9295ef34980b990030617","affectsGlobalScope":true,"impliedFormat":1},{"version":"bef86adb77316505c6b471da1d9b8c9e428867c2566270e8894d4d773a1c4dc2","impliedFormat":1},{"version":"5a49adaef698b7ad7e6127949fa1b0bbd3d46b7cbd11c54e392a4dcdd51f5190","impliedFormat":1},{"version":"6ee598cdfdd0fa52039dca135b3dfff7b49035dc13292143e0a93843e3861967","impliedFormat":1},{"version":"27be6622e2922a1b412eb057faa854831b95db9db5035c3f6d4b677b902ab3b7","impliedFormat":1},{"version":"5c634644d45a1b6bc7b05e71e05e52ec04f3d73d9ac85d5927f647a5f965181a","impliedFormat":1},{"version":"2489bf04d77dc025ba67f49f1a56eb24b9db477d5ff88123d887e163ed1776aa","impliedFormat":1},{"version":"63a7595a5015e65262557f883463f934904959da563b4f788306f699411e9bac","impliedFormat":1},{"version":"4ba137d6553965703b6b55fd2000b4e07ba365f8caeb0359162ad7247f9707a6","impliedFormat":1},{"version":"0b77b819b5417775fccb20c678293cf614c054a5b1a65421a5b933a9124ba998","impliedFormat":1},{"version":"eb5acb58487367e502d994b57e2c58255d8241f481ea8efa8e79af23af3f41c2","impliedFormat":1},{"version":"9252d498a77517aab5d8d4b5eb9d71e4b225bbc7123df9713e08181de63180f6","impliedFormat":1},{"version":"b1f1d57fde8247599731b24a733395c880a6561ec0c882efaaf20d7df968c5af","impliedFormat":1},{"version":"6715dc4eb59c8ea9abe2b78c235ed331dc710a06fe56798868dbc4d40cd1b707","impliedFormat":1},{"version":"35e6379c3f7cb27b111ad4c1aa69538fd8e788ab737b8ff7596a1b40e96f4f90","impliedFormat":1},{"version":"1fffe726740f9787f15b532e1dc870af3cd964dbe29e191e76121aa3dd8693f2","impliedFormat":1},{"version":"5a3ea721d03a361ccbdd7390ccd75f6e84cbca3a3f01f4b331ecc9af31890c49","impliedFormat":1},{"version":"e7dfaee4af38d45b1cab8a1ee0b3bc1f85ddcf64545ed391d675d78ae6526274","affectsGlobalScope":true,"impliedFormat":1},{"version":"e8daa443eaf9a27fd382cc1f8ebe30330c0f4d89511cfb469166874806751d35","impliedFormat":1},{"version":"af48e58339188d5737b608d41411a9c054685413d8ae88b8c1d0d9bfabdf6e7e","impliedFormat":1},{"version":"616775f16134fa9d01fc677ad3f76e68c051a056c22ab552c64cc281a9686790","impliedFormat":1},{"version":"65c24a8baa2cca1de069a0ba9fba82a173690f52d7e2d0f1f7542d59d5eb4db0","impliedFormat":1},{"version":"f9fe6af238339a0e5f7563acee3178f51db37f32a2e7c09f85273098cee7ec49","impliedFormat":1},{"version":"1de8c302fd35220d8f29dea378a4ae45199dc8ff83ca9923aca1400f2b28848a","impliedFormat":1},{"version":"77e71242e71ebf8528c5802993697878f0533db8f2299b4d36aa015bae08a79c","impliedFormat":1},{"version":"98a787be42bd92f8c2a37d7df5f13e5992da0d967fab794adbb7ee18370f9849","impliedFormat":1},{"version":"332248ee37cca52903572e66c11bef755ccc6e235835e63d3c3e60ddda3e9b93","impliedFormat":1},{"version":"94e8cc88ae2ef3d920bb3bdc369f48436db123aa2dc07f683309ad8c9968a1e1","impliedFormat":1},{"version":"4545c1a1ceca170d5d83452dd7c4994644c35cf676a671412601689d9a62da35","impliedFormat":1},{"version":"320f4091e33548b554d2214ce5fc31c96631b513dffa806e2e3a60766c8c49d9","impliedFormat":1},{"version":"a2d648d333cf67b9aeac5d81a1a379d563a8ffa91ddd61c6179f68de724260ff","impliedFormat":1},{"version":"d90d5f524de38889d1e1dbc2aeef00060d779f8688c02766ddb9ca195e4a713d","impliedFormat":1},{"version":"07ed3ddab975995eea41b22f3010506fb9f5fb301d04820b07d7a1aee5477d7c","impliedFormat":1},{"version":"969d8b0965849f4bae7cab0ba90bd1e1220e95999c2c6f01117fa7500901c017","impliedFormat":1},{"version":"6ec840ee5e2bc103f557fe38b1d585ee250540468713d7634ee066de372bf332","impliedFormat":1},{"version":"b0309e1eda99a9e76f87c18992d9c3689b0938266242835dd4611f2b69efe456","impliedFormat":1},{"version":"47699512e6d8bebf7be488182427189f999affe3addc1c87c882d36b7f2d0b0e","impliedFormat":1},{"version":"6ceb10ca57943be87ff9debe978f4ab73593c0c85ee802c051a93fc96aaf7a20","impliedFormat":1},{"version":"1de3ffe0cc28a9fe2ac761ece075826836b5a02f340b412510a59ba1d41a505a","impliedFormat":1},{"version":"e46d6cc08d243d8d0d83986f609d830991f00450fb234f5b2f861648c42dc0d8","impliedFormat":1},{"version":"1c0a98de1323051010ce5b958ad47bc1c007f7921973123c999300e2b7b0ecc0","impliedFormat":1},{"version":"ff863d17c6c659440f7c5c536e4db7762d8c2565547b2608f36b798a743606ca","impliedFormat":1},{"version":"5412ad0043cd60d1f1406fc12cb4fb987e9a734decbdd4db6f6acf71791e36fe","impliedFormat":1},{"version":"ad036a85efcd9e5b4f7dd5c1a7362c8478f9a3b6c3554654ca24a29aa850a9c5","impliedFormat":1},{"version":"fedebeae32c5cdd1a85b4e0504a01996e4a8adf3dfa72876920d3dd6e42978e7","impliedFormat":1},{"version":"e297c0a524edee7677939122f90027bfbe5f2698939d9a85728e5044b39c7124","impliedFormat":1},{"version":"cdf21eee8007e339b1b9945abf4a7b44930b1d695cc528459e68a3adc39a622e","impliedFormat":1},{"version":"bc9ee0192f056b3d5527bcd78dc3f9e527a9ba2bdc0a2c296fbc9027147df4b2","impliedFormat":1},{"version":"b62381cae176db34f003cc6172ee8f3e0122014889d66391aa73698105cf4934","impliedFormat":1},{"version":"1d9c0a9a6df4e8f29dc84c25c5aa0bb1da5456ebede7a03e03df08bb8b27bae6","impliedFormat":1},{"version":"84380af21da938a567c65ef95aefb5354f676368ee1a1cbb4cae81604a4c7d17","impliedFormat":1},{"version":"1af3e1f2a5d1332e136f8b0b95c0e6c0a02aaabd5092b36b64f3042a03debf28","impliedFormat":1},{"version":"30d8da250766efa99490fc02801047c2c6d72dd0da1bba6581c7e80d1d8842a4","impliedFormat":1},{"version":"03566202f5553bd2d9de22dfab0c61aa163cabb64f0223c08431fb3fc8f70280","impliedFormat":1},{"version":"41eb514d9ce0a6e87957f08a4b7af70d93f87637f37dee706e2d92a6601c25a9","impliedFormat":1},{"version":"e7765aa8bcb74a38b3230d212b4547686eb9796621ffb4367a104451c3f9614f","impliedFormat":1},{"version":"1de80059b8078ea5749941c9f863aa970b4735bdbb003be4925c853a8b6b4450","impliedFormat":1},{"version":"1d079c37fa53e3c21ed3fa214a27507bda9991f2a41458705b19ed8c2b61173d","impliedFormat":1},{"version":"5bf5c7a44e779790d1eb54c234b668b15e34affa95e78eada73e5757f61ed76a","impliedFormat":1},{"version":"5835a6e0d7cd2738e56b671af0e561e7c1b4fb77751383672f4b009f4e161d70","impliedFormat":1},{"version":"4b7f74b772140395e7af67c4841be1ab867c11b3b82a51b1aeb692822b76c872","impliedFormat":1},{"version":"7bd01f0f28cd3aeb2046274d85208e245965f6f2948edf4f7b2057bcf9f22ccc","impliedFormat":99},{"version":"d2f2cf2b8cc92bea913cda4a076e0f790b23a21e84f989d12f0116a7fe3906e0","impliedFormat":99},{"version":"6de125ea94866c736c6d58d68eb15272cf7d1020a5b459fea1c660027eca9a90","affectsGlobalScope":true,"impliedFormat":1},{"version":"f5b20bc288ee49989c95b20847fc93b96bf61cc0845598897a6a53a967dd7d07","affectsGlobalScope":true,"impliedFormat":1},{"version":"064ac1c2ac4b2867c2ceaa74bbdce0cb6a4c16e7c31a6497097159c18f74aa7c","impliedFormat":1},{"version":"3dc14e1ab45e497e5d5e4295271d54ff689aeae00b4277979fdd10fa563540ae","impliedFormat":1},{"version":"d3b315763d91265d6b0e7e7fa93cfdb8a80ce7cdd2d9f55ba0f37a22db00bdb8","impliedFormat":1},{"version":"f31c4f2e95ea48a5359b8b12d88e7f9df3e84c55297384c7ba6321fee2bca54c","affectsGlobalScope":true},"ae8d85097b2e3ca7910e75a092754a9de290a942051cc11af8fc10bfc6fb1fe5","08b16fa5ec6827b78461463bb8b8d3416c4b2237df8055161aa2b41a45de9631","d9cd90ae269f326eac20dd51658fc66c07d8dd7df401059e80facfcfdebbd95d","8c32f95805603eec3f9df5f16d63016cb4521a069774c80b3cbb33d772a61d27","d0541498b8ffe3f0810dc1f4bab9b7cdbc2e567cbef3bcf676c77a554150ceba","b7da7aa99a62fc2189ab75e2f606b72f448484a33e5f3ac0720ca39482772db2",{"version":"1dfdec0ec9c299625d20c5cb8f96e2a801c81d91669c6245f520e8734a92fb3d","impliedFormat":1},"e41d55ec6e3b685a818a601aa7dff02a8dd68842125cd0bae50f1162a93a5738","d43879eb72c4143f6f92099a9f6a8107b0a6d865c7f2a5d73ff67bb73abab1af","14d2410b254ce3e227fcfe74f24f5dce18aeb499a8c8c8b488a6cf8aa1a2ae6f","ba4f3d5afb5c3f38ca6c16c12c6b0c91c461857a5b94dfdfa9ad2bf7b0c9933e","bba517f643c523e46369fbaa55c2963dfd6150ff0cdbef54c2a8ecc99ea8ffbb","bf595ac8c5518a2e2539fd9e66ede0e1d73e89addc5b02c3cebae42231d507a6","fef69ddc966de18a819aa844ad9ce197c362c75e3f9f6a9be1a2b79345f20b10","18c2404f1e7f9c5f1a0684b9f3a37118a7b180298d003a734f31b35f66a22bb4","961d074ef6c51ff899d1ca1073fc015647183701e90ede472a4ff3c64be77afe","289a91c03a072be4358fded46a7ea7ead5d4388c84e28c5167d5d7fae5422db3","6add98f953747a4f57dfeba9cc05cc538bf2d6f4c178133af985904d2ad7ed44","7dbbc095661fc3931fd9010979ee76bca923383662fbed0c8aafac4adfa16377","7d97c4c275368f6dce9a7daab4ee39dbbc522c04fa53bcf72d3d7252c58b43bb","badf8c46467a7eeee968d184b1815966d2967893783f908b54772174f071d8ac","90c2762d08fe1d9f0b7eb1aa8b6f0548454835d92bce49e66b141be1e742c313","15d32674ac63504ff4626a7ba14671bd79cfd6badfa675cecfe0e810d58f70d2","c3c8d65911e0f4ce15b649ba59b33d4bae3aef4f5a0eb0c0539469878bff9e1b","7cd2985d47d3693bcffbaa6c8b877249d60a6010d56d5bc092cd21ea4bacf53f","506053623e708163d08eb391adce33e5183dce4b2e4874a27a0f326719802ac4","456404f4ab6e2bc310dce007f013e33ca7068717fd9d46e2ac5c323a17682e68","1b634365ff92792fafac251a2e7fd5e40f39a2aa8acb8603af2df65bd6406253","9f7434398b2c04b4000b982deecdf4a8c2556a5d9eb41bbad996e72d55fbd665","4a81e60de094f4e76cdef27220c0ceef66ac115c20b931db2d64c8cffba040f3","03a8052a3c163c543aac1df6fa28dceb02e6449e66a545894d5e58800b6983be","c414ecaff699cc052345486dcb0a8fd15297d4b937c63c4d7555fb8cfbc9e246","51fb71bb549769160d2d7ba00c7f7a8a757777a2f82e1ed6cbc28eb1b1e8d550","9fa0db2a413974b233b1772c1a7ba20cb207c9a69296201e116b2a4ea67517e9","c6552f2c41a799b5a83385bcf4ffd06c5445c4799501642332df5be94f638976","378962f1a6794913320d10ae1806e2a3d16e79d050e4b6164555d54e69b6bd68","d0bd3f295852f766084a428db3a267b8ceab8721e4ee42aa431aae6a0fbe7515","604d54ca2485a17a16ecfd235ca0924606ad5627e6c994ee4836de7da31a80fe","f54d21f0ee4bea6c6d2600bb0540ebf3bc8f8efa906f66a2b880e4bbd7a534f3","e859cd3fc426f7e33f0f01c22d68642890c4369667b2bf7292fbffece47f4d9f","c22c49274f197d70ddcf8f409b2ddda249f58e141fd24cac2de2afbe6e67841e","21f924231e3a0dd240fa297b0702ccaa45fa5335140e48ab355a45bed2d5714e","bb4a859dc8cad3715529deb3cca425d0a18a270af43ac4006125e6fd63d45863","71665c31058b210df2433d3f660e67e2b220b6f816f3e8220b2026aa40e387b4","cfd5c399ffa9ff9da19ccf9f8fc75968116e8258fa736fca60fb41c5a340f4f8","ef39dd3b68894e75685b87924a2a39dada129ef9bb93f1b28e7b5a9f932d9f21","fa6582d402c561447d5c6ecb02a9d13d49dc0e11a34fecfb424cf723be8649b6","5105756f9e6311aa4db5096bdb3256d23f2d3af3b2f07316af3b86983a78eec6","e299f731ba4a09752b014b9821c0df0c80c7de65bb879313cc28d7dbec460ba3","5cdb84c45be3f1a9e68133e616515e9854f062a20e4e3ad9ba313a863eb53929","c18e34946bf3dee1677af389eeb04017f7a7c962f1659034031246d459559336","85438192af2cce03087c9a7bb9bab8302adebb0106a3f17244fd87097b32238f","f4a5b725c377699d3eee7073531b812314b1a183f89f8dd73ab5f73218885054","b7ecc5372362a545ebc53009a7aa4bff0b7b10368e8005ddefa48b564eec065d","ae99e81ddf03f4e0722ae28e33b9b8932539410e6cab49fd3085b5acaccef613",{"version":"380b919bfa0516118edaf25b99e45f855e7bc3fd75ce4163a1cfe4a666388804","impliedFormat":1},{"version":"40de86ced5175a6ffe84a52abe6ac59ac0efbc604a5975a8c6476c3ddc682ff1","impliedFormat":1},{"version":"fcf79300e5257a23ed3bacaa6861d7c645139c6f7ece134d15e6669447e5e6db","impliedFormat":1},{"version":"187119ff4f9553676a884e296089e131e8cc01691c546273b1d0089c3533ce42","impliedFormat":1},{"version":"aa2c18a1b5a086bbcaae10a4efba409cc95ba7287d8cf8f2591b53704fea3dea","impliedFormat":1},{"version":"5a0b15210129310cee9fa6af9200714bb4b12af4a04d890e15f34dbea1cf1852","impliedFormat":1},{"version":"0244119dbcbcf34faf3ffdae72dab1e9bc2bc9efc3c477b2240ffa94af3bca56","impliedFormat":1},{"version":"00baffbe8a2f2e4875367479489b5d43b5fc1429ecb4a4cc98cfc3009095f52a","impliedFormat":1},{"version":"a873c50d3e47c21aa09fbe1e2023d9a44efb07cc0cb8c72f418bf301b0771fd3","impliedFormat":1},{"version":"7c14ccd2eaa82619fffc1bfa877eb68a012e9fb723d07ee98db451fadb618906","impliedFormat":1},{"version":"49c36529ee09ea9ce19525af5bb84985ea8e782cb7ee8c493d9e36d027a3d019","impliedFormat":1},{"version":"df996e25faa505f85aeb294d15ebe61b399cf1d1e49959cdfaf2cc0815c203f9","impliedFormat":1},{"version":"4f6a12044ee6f458db11964153830abbc499e73d065c51c329ec97407f4b13dd","impliedFormat":1},"a954453e91ad849d0b72c1ffce1e6473e36dba89ac9753c10f88d3496e970469","d72383872d59e93e649943cc95b22d8ec044ea304cf282ab961463f66b97aa81","b877866b3183e4e11374b6c985aa073ca020a6da061e365fbb26882fbcb78932","6f0eaf74ca1d561aa69047935c346375a00aa9afc8b798b02a21116c331794e6","969b707247da9eb5079cf5cf4c940ad6ce46ab4c26d957f98692e897e6bc2fc0","fadd3b2a6010f5554f4e8732700d283f53d309d9fdaba4f8338b1fbe2cbfcf37","02e2fce631ff37cc6989d91f9a648c496111bf05d8240cf71fdcbab1c5725c00","0097f0e67aa4dbb698b7f56a19607af5216618025cb852f914e7f1e412a6e799","96636313d5d6c3dd1d0f8d2fdbe777f43ae283b17ce704259da29bb265a137cd","303da22472180b5bc8f931a4f66b347afbe3ab1eefd9b4ad658bab0f714d342f","d5e17431c18ff94fe4b4588284327433aa4b91519e2f18a53999565b99d9dd97","1e9dbd778d0303fb9650987349b4f2d46ffb505567b80a5353b859e3fba363a6","8df85af41d3bcadf70b2854078f3a1e92bfab08b2a6dd21597dfe8bc1e7ae164","efd73a3819f444c546b33cc043b5abee26da294f62098db9464df49fb0c822ed","65b7c05d37ae593fd742f594bbd1c600fc9c833631744e8cad6a3a4e342a097b","cbe9cebdd594d19b1afb49b7e73b87384afda3c616fe55434bfb51d12634f07b","b6256df7361e9de91305ff4f3965f1bf4218bc27dc59fc03ae86656ac277293d","06b46e0436118c77c1dd3dfb5ada140b04f721c3bf811b2a9ffe67392f9273f0",{"version":"ee09b9348d02aec6cd1cebb94c27896c10d47efa042a3fbc9c90dd6a7f6af752","impliedFormat":1},{"version":"bf673997a66d2225f43fe1b51cdddd497d0a8c08a990ee331457f2d017563075","impliedFormat":1},"f5adf462de6f79e70149f4f72db3a5dbce8ad78c5dc8ccd13986eeed7b820936","5a20aae73fc38f37c1b00f6a8afc57f31f7854f41daa3ed88b33f9183ae74669",{"version":"e85d04f57b46201ddc8ba238a84322432a4803a5d65e0bbd8b3b4f05345edd51","impliedFormat":1},{"version":"713140d254961f506a4077c1b6a64c503122c621972a596b54eb693721234db1","impliedFormat":1},"402bbb012b41d3f2261eb858c2f87be3c5f3868e98fba169af5e2d8502ce048e",{"version":"7abffaa258259a7943318d4e43f2c0cd7c229be719637a09a3a8be2b1cb44f30","impliedFormat":99},{"version":"d0e136d6bf3c38be7af296b7e01912b6e8944a428ba7fd1e415a10acd9e687e8","impliedFormat":99},{"version":"7a685305685db7f9d2195ae629df44ae5888c13371a032ebe629a615a177a45b","impliedFormat":99},{"version":"026b28bf8f8c6f88e4e3aee7dd69f2523b91df8310bf6557d71c853144ec0720","impliedFormat":99},{"version":"4bc5ace72e3fcd7da9d8872af098c4b157ad8bd98b1996c097212884dc8e09cb","impliedFormat":99},{"version":"c3aa1b9d09adac7ac5e49aba8e8fa7114c2c842d46c2c5f51da53ec889787bac","impliedFormat":99},{"version":"7cd8fbd00f9608795145d427ff641d7abc485cd485d833ea1d9a90222ee73778","impliedFormat":99},{"version":"0f4f54801406a0a67455a9ad950bed9f4d2921fd66a91682f83a985086d60082","impliedFormat":99},{"version":"7c128cd80303077ca51f3b70b6103f5715048642f5b232cacc02f515ea2c0149","impliedFormat":99},{"version":"8c18a2ccca01e6ec6bb951c9a376d12b08112ee5237826caa913d85b4e3cadb5","impliedFormat":99},{"version":"cb3ae8ed61b12ed84b755665ed971cbc8f85a6cb005f5675467cc838b208b16d","impliedFormat":99},{"version":"6aeb63cfffaa8f3274025ba556e6d90d9e90a0b5a664bdcd26fcb23486309efd","impliedFormat":99},{"version":"76b348ba0d4830b55acf7e86e1714030c16d25a26b04bc9638aa03b8819e3c0f","impliedFormat":99},{"version":"6e5aa91099e2fe5d1d05f6f3100a90e5a5d9b8aea7b0ea6f4d05a0f192899a64","impliedFormat":99},{"version":"bd85cba544b37cd32e8d02b138c3a2a4075930d01146b3f5e33d713b39dafe77","impliedFormat":99},{"version":"725853c4d825cbe68599d75fafc4ec9ec47eac1a0a0d1bb343ee735321cf5328","impliedFormat":99},{"version":"20ca05d62223bf6f117925ef8f9b9781e894cb146d30ac491e0763d34e53a5d0","impliedFormat":99},{"version":"4ba733d1a5ff0a0779b714468b13c9089f0d877e6fbd0147fac7c3af54c89fe0","impliedFormat":99},{"version":"0110a18108a64dcc1bdebec9d344a4fa312352bf4979a56547df3ec2d76bd410","impliedFormat":99},{"version":"697203f3f5a1fea90e40fe660360325090ab36e630dc9422a1909dd4faa2cacc","impliedFormat":99},{"version":"ad1226eba93a65cdccdb1b4f115d67c5469e12705dbe80139c2988d6b296d04d","impliedFormat":99},{"version":"4ea2c94c3a1c87029d10f11c209674d4c6a0c675a97503dc9668d2815ff6ea11","impliedFormat":99},{"version":"ada4ab3255e0175af9a12012ed2e0db427829260dab466b0296697a754422f35","impliedFormat":99},{"version":"83c564d98be54908f9b84d9c67525bc38f52b423093763eb18f143a0cff3dc0e","impliedFormat":99},{"version":"94cfe3be66e4a6a1d52eaff0eb03bea21b4cded83428272c28feedfa5f9a152a","impliedFormat":99},{"version":"c2cf5eb33fc641dd321afd12c726ac3e753a81ab1618270ce6cd508f927989c7","impliedFormat":99},{"version":"a7f2f38cd72a96e7678555a1166a4488771b94e5a9c799d1c8943974ada483bd","impliedFormat":99},{"version":"c519327110a82e5eeaad683dc64f36994f19d9893fe69c4ea2b19d41b7e3e45b","impliedFormat":99},{"version":"fa525a25eaf81e3eaef7ca328c352bf4b38e1392ba468aeef117477a5dc42ea7","impliedFormat":99},{"version":"74a3f8babbd6269b402051673c8b255ad31db07539e37bc15aedcf6311fbb53c","impliedFormat":99},{"version":"73c4f628937d4e4a94d5af1c04bf57008a9d2c5f94a8fe6d9da8d51783069e15","impliedFormat":99},{"version":"f8e1fd0e462a1208e7c1e804fa87790112a6ba8c90ad3dc341d7c6430a8b79e1","impliedFormat":99},{"version":"1636e5ef72e41182b6a6a3e62595a3ff60c48f8b6fdb7373b2e7f7eb0f9485d7","impliedFormat":99},{"version":"6fbdecf06e73381e692ae1c2637a93fe2fa21f08e7cfebfac1cd2d50c6c6df6c","impliedFormat":99},{"version":"e437fb52a096addea9cf385b00cadc5fc34b8b8f6a7e63ef02b26cdc495478ab","impliedFormat":99},{"version":"75ad38105b8decc3c60ee068c8d76e3f546b4db1ca55255d0a509f45e4b52990","impliedFormat":99},{"version":"13ce682bb57f9df36d87418dba739412fd47a143f0846ea8a1eb579f85eeed5d","impliedFormat":99},{"version":"6dd4686bc0fc894051b6a93cff4f77b6a0159dd20801841dbc233231c5275082","impliedFormat":99},{"version":"d45218d368df27abcfd0253d4b1287e1b954156f32ff263f31913bad81a80918","impliedFormat":99},{"version":"0845f67763e97ee959128157c3269440004f71bba837cc781606c0f30ffc477d","impliedFormat":99},{"version":"dfb31f55c4a39440f89ae132de8bad7d4ff09c0f419df24955800ab5266cd7f5","impliedFormat":99},{"version":"edd454b3d3813b5cc5d87c68ba3c982ad8ec4b22b6ebd5e03a4f6a06f56f6e98","impliedFormat":99},{"version":"c5b7d15ea876bf33972a2ab1d31aa0dd9328e23ee6e59349afff62fa784e6da2","impliedFormat":99},{"version":"bdefac7b63b287f001df6473f691e46819338cdade107df98781b1650c76a42c","impliedFormat":99},{"version":"827a02d7987f70a3675cadeef9e7128cb4d65135fd8ea6fca87f91263b6229db","impliedFormat":99},{"version":"bfc938fd99ffb5407a7c0bde6d49c42a3d23f0e8fbdbbb5a50926b72114d5d1f","impliedFormat":99},{"version":"cdad6c3490b00ab05d414adc133e8c73e560f0c3fbfccd0a95a64a051cbe749a","impliedFormat":99},{"version":"d8f79448f4f860aec6c69d9953abcc95dbb8d4c8b99df7a2fbf3dd7ef779254f","impliedFormat":99},{"version":"7e7d9e525ffaba7c8324167c43d8fbadc174f415020946b0f0ecedb7b5762800","impliedFormat":99},{"version":"12a8b9d50244961dd1c86471af8b7c34df210888753c4930eb5cb6711da2b92e","impliedFormat":99},{"version":"965bfde0433a808a389b80a8e45b717cd2d5a3a0cdf418707cfda3046e33fa5e","impliedFormat":99},{"version":"923814ad5e253966d718fae2f1308528eecd1209c627bfde484d740fe310d36f","impliedFormat":99},{"version":"235f9ab7ecfe06e72b7d86612ec7abe2e60a8521d10614ebde48af12915bcd64","impliedFormat":99},{"version":"069e9adb92a941ed9f45cebc7b6ecf5d6f249a46142d267dffea594f712b5e56","impliedFormat":99},{"version":"815095b585fc89e31a644c99c8533f542c485acab1e9e52e48de01eac616e325","impliedFormat":99},{"version":"14d3c7499d1759af5c78eec4f26a6f5b85bdd5b0e41ef3f5e6e813f1ae88c06a","impliedFormat":99},{"version":"7714308befeeb34cbc1d6715bb650d05e2b4e0516db9e58ef4c399e462d222b1","impliedFormat":99},{"version":"5cacaa1a79b82d19cb221ce9bb3eba0313fd9ac6e48d44af0ec3e54fb3d988b3","impliedFormat":99},{"version":"99e0db809b99a0a2d55a3eef8b41d2b247ce0233cf29e39b85704ddaa536c776","impliedFormat":99},{"version":"217800577a2c9a7232e5a9d1abd1c1836acbb004e7522a5261299aa867713f96","impliedFormat":99},{"version":"8ee28204ddb2be7d6dfb68891493f654cbf10f5e1667bd33bd62920d9eb9e164","impliedFormat":99},{"version":"0063836258a86deea4e1e16c22a508e57fa3c42307048c8703885bf6676e94e9","impliedFormat":99},{"version":"feef3243cf2988daa9cc63a7a0c40bf39e4748759c18f020837085d24745c526","impliedFormat":99},{"version":"017907864b01ae728f5be6be99ea7632e68b2a35c2d7c9606bde20f85f10f838","impliedFormat":99},{"version":"01a85d7df6537db7f55188614119dc9a9fbbbd1444bce68e5a4ad3263adf1edf","impliedFormat":99},{"version":"c8a40bb3df60346af02e8d786473985ba53b716bc7caefd21ab838f025ec103b","affectsGlobalScope":true,"impliedFormat":1},{"version":"6f85727348a1b82b55deb40e9bbf6be7f8f2a00f0ebe44c02e16477f52b090dd","impliedFormat":99},{"version":"2c8c3026b97c4f40d183f893d860fb2836c9c46644591d2b40bdc2417b002fcf","impliedFormat":99},{"version":"4ca5b927a7e047f0a0974c7daaeb882230ac08ba3fc165c8e63ddcbd10da5261","impliedFormat":99},{"version":"12f20310f22fa2cad6018638d2bfeaa966db651cea186272506e53d0f64d20dc","affectsGlobalScope":true,"impliedFormat":1},{"version":"0b6d4c3f82f8dc5ea956b45f38badb561e5b580651397c7d7c06c472f9a7f2c3","impliedFormat":99},{"version":"6d056661e4b636cc04e36c36b24a4eb692499b21fe0b18cb81f8bb655d7a3930","impliedFormat":99},{"version":"e71c5f5440bea23cee6fa272d088930e69694c09ccb89f8811b097feb7c078dc","impliedFormat":99},{"version":"2f3b6743fa1fb12ccd929484e1221c7aee4cfd1584b34ede390c2d97fdc1968d","impliedFormat":99},{"version":"60981ae7c2a8926f7855d8068c42e05a3b1959f0bb795a8bb9773c912a9a6f16","impliedFormat":99},{"version":"811600963f726a8eb66c6883bdf39aaed77cd94cb6b7fd92d4b882cf0fb23fb6","impliedFormat":99},{"version":"b3f9f3f76f8d7284ba488f843d7027395b7aad615ec69538b8b7a6bbe3c34e20","impliedFormat":99},{"version":"a21250bad063e85aca3745978df1f26b8ec40532fa8305a243d1021485a877e2","impliedFormat":99},{"version":"02a8bead44c8301369f970a697156d401897b046bdcfe8a6fc7fd0ecce513a57","impliedFormat":99},{"version":"8e8fa002f1dabd3fadbdc4c110274558e44279e0628f53053c23cf89070d6a99","impliedFormat":99},{"version":"cb5a0b21c3314c89fab4006c6505011f03877a35edf78735f35e97c0fd5dfcb1","impliedFormat":99},{"version":"ae046314c0651da4a01e9e48ddf370ce9d22ad21f48962f25a12c1c09de9b01a","impliedFormat":99},{"version":"8d4a70e05b1f8450f5fb8997e5bfc336dd0baec3f2c8117f6f260d4eb68de0ac","impliedFormat":99},{"version":"8fa060b55694a9427afa2346181d988302de37181cac7df6e29f252b3741164c","impliedFormat":99},{"version":"db30902a5f43e35799c4f17baaf605325d6567c57037f7848e0fe3fb8b694a32","impliedFormat":99},{"version":"10f60c4f46231065e5a4815651300d69925049b6d654c141eea7bc3410fa5b4d","impliedFormat":99},{"version":"8ca97507cc241216ed30a5c73091a6dd4818dc9cf6dbd3bdab039e40f474202e","impliedFormat":99},{"version":"89221579f7e073535bd1dc5fbfdb5047bbdbbe52995fdfbf238f71f428dcadb0","impliedFormat":99},{"version":"5d32df00db39a9a997a2f8e4e575892478f892e737b71c48c019b80a295856dd","impliedFormat":99},{"version":"8cc3ab398412f20af6fdd1d307176f933f3a4a6b7eeab11388d3a084b811bec8","impliedFormat":99},{"version":"150dad61fbc648ab6f9ab3b6cc4d74a99a20bbbec64c8b21b16abadfbac49e28","impliedFormat":99},{"version":"0ad91f6047d442d95d241de373c4c7e9066a0be6934363fd6f0df2758e0721c2","impliedFormat":99},{"version":"cdc154f5e44aa28c4f948ddce70d8cc57acd0992809549761b2f352c409e03b4","impliedFormat":99},{"version":"d7697f915c61a7f7ee03922e9f4e2dd3ef8122a3bcdafc1d7824f2c664b67ad0","impliedFormat":99},{"version":"8ae0357ed41745154782684b1cd3a8b9c84dc92935348d3711b8c949472d6398","impliedFormat":99},{"version":"ece19f08fb075c84c2e22fee2af1991bd2f67f60157b72a2993dc6d1087a7e80","impliedFormat":99},{"version":"4804c3e9ab498d31144a0c9b95defba9f913a4326063d19d8583eb4ba9708a15","impliedFormat":99},{"version":"f7292171fc81d858880863eeea33c85f9522909b6929559f780b5ed697c99020","impliedFormat":99},{"version":"8cfa20678d5f41cb97d6afdf5076903e9ede523379c97bb7ae47efe0d25566e2","impliedFormat":99},{"version":"7299aed934f999ad939eef04327c25c1db4019bde85c868298da307f1336ccb6","impliedFormat":99},{"version":"a56c6a07f61f7382a1744d14a0d13894e07994a503c90436489d37efa49e3aa1","impliedFormat":99},{"version":"88220b86da493923d05930d0e0ce94cca2813a4196929f5dee099d1bd763d6a1","impliedFormat":99},{"version":"ca15c38c9fdcc210ef6382fa4c06fb513eb5623ecacaf225f77f1750cf0fcff6","impliedFormat":99},{"version":"d836b34bc823fca290361ab1697d11e82a213a6fd3057d0f82f12d57676efc64","impliedFormat":99},{"version":"f648ba1e623bc9027029a3f5cb82ccabc0e2bd9af8072e2d98ef0d8f17e88e3d","impliedFormat":99},{"version":"3b059298411793c465c4f04f509e6402b0f81ed6d9aa6f4cb5e5fbd8a68a0e3c","impliedFormat":99},{"version":"b15e4936fce4442d8fe92dac9cefd531970d80a74cab7f1f5277ba638cce626b","impliedFormat":99},{"version":"2b35bc90f642e0572c960de7e1b444d725b3959c49718c479564e06970046fcf","impliedFormat":99},{"version":"9bed9d3d3b1ffbf89af378638ce3ef0742a7bbcfa4ac32c950d4acb163421436","impliedFormat":99},{"version":"0ce5d0ce2ab178aa2aa2e448e6a0c5cb5d4b38533ba0dd2491e5b85946783208","impliedFormat":99},{"version":"74ceda95ca7d1851a27d935612f65a6946548e1f80cf5dd1298cad48828c27fc","impliedFormat":99},{"version":"7deb559b01045a41440095d8860c5d59c5ab1b2aa96c01e36074f4c58632b365","impliedFormat":99},{"version":"259ecaedf76b39789c0c81f8603a92314a79f51b61be1bbc15f1e1b334da1c38","impliedFormat":99},{"version":"b6352f615b5720d827308152fc030237636d5ae9eadfc542f86ad8343ea600f4","impliedFormat":99},{"version":"43c212e31056c922b3928552737293a984c6b329d41e4ea30d819648de5242cd","impliedFormat":99},{"version":"bfb2c74ba09559b9ac6b0c21012a72e124c399e7d12eefd0df801acdcaef359d","impliedFormat":99},{"version":"3c823aae91938552265e8451ca319f87a1a951a978c6e79e37e080242d50ebcf","impliedFormat":99},{"version":"b1012eafec8c934bb9cb9fcb5e41e3e7e2e013e4ea8d2e5f537d3ad747030810","impliedFormat":99},{"version":"91212da70b95a54d93fb9becf138e14d9a770aa63163204835d633f32fb301ab","impliedFormat":99},{"version":"05489ce1388e63ed911ffbdc0986ffae9a1131e51897133d7a1bcd34d5b8b54d","impliedFormat":99},{"version":"97a51fa3169e333c5aec82f2bfc559e1a14cfe9a6e7b0c3684edbce0481e302c","impliedFormat":99},{"version":"037ea0ac2272c05cb37157bff722effde2402b224ea90cd6e0d4acabc7938480","impliedFormat":99},{"version":"48c7ace1bb243f4828b917a32ad4a44ad70ceeb996598a608a7d8e7e532d35b1","impliedFormat":99},{"version":"08de8f1d972b833791a9782eaee39816eab1138c53319ffcb90ba9defefef6a1","impliedFormat":99},{"version":"ef1ce13d614f887ac1a4ce2a4a282c2582dc7e321477e87fb15564c5d7755dd5","impliedFormat":99},{"version":"f6bac2cf3c5d6043e24f74e200c0ddf6e4dff6e37e0be075db3f474af5ecf7d7","impliedFormat":99},{"version":"292856f47dad178fe1cb3401554428b3b0157369a8fa52792587fd2bd06fcbec","impliedFormat":99},{"version":"84f6e48e6acfbee5b84c896957eecab0b1c82f28f76347e9b1f3e5beab0b507c","impliedFormat":99},{"version":"86c032d6a08297f2d6107881b091c3e4b494abb6cbabf7af04128bd315010133","impliedFormat":99},{"version":"1f85c894a5d2e46686ad0e3baf8f4d0d470032d781e4757ca9a9db1f9ed1a6c8","impliedFormat":99},{"version":"9689a980013b2f1787a2da7dae1aacbf82e9ce2fe5f5172b4867feca8f98e0b0","impliedFormat":99},{"version":"ecef49f31349ad695be11c15af4ecc4fffc95b5975aff0c3225492bbc8d55cfb","impliedFormat":99},{"version":"4363c23b6d9b290d6eb6ab986a62473892cae3a7783b7b1468a3d0c2a25f0f55","impliedFormat":99},{"version":"61a605be404b4fe829b2e86b24c856012d5abc41763f32d9ccf7bd051a8da75b","impliedFormat":99},{"version":"4754025df53b19165caec8e99e341b304aa0405ee8779020c85f202dc1efccf3","impliedFormat":99},{"version":"8eb7a21fdc1a83843d8669f589b04d6aa5ff8d83f66e62dc7ba7da6db56de1b6","impliedFormat":99},{"version":"9deec5832bc5f0cdc3045db3956b47fa92482a44b5262cdb97b7019552170ea5","impliedFormat":99},{"version":"b2f5ed72f0b2c9c98034a0ee12661defe50334f013fade322acf70bfef46a39c","impliedFormat":99},{"version":"9bdb6e828cb364d75e79cff4584e5e812f9b56b726e8bd51ca7c92dacee18814","impliedFormat":99},{"version":"c2bc879419d6b9ab6edfa8005126807838c1a496c20ad64bd2135f8b27078ee1","impliedFormat":99},{"version":"876a4f3883db4bde394c8bcad52ba312f8f94f7e6acac5c684dcd68c7bb4e7f1","impliedFormat":99},{"version":"81a1f5c255fbc25aafb355268e389ad94d898ff78c168ef9e04c87bb648780ae","impliedFormat":99},{"version":"490b9c476f66eb7b5168e6c1c8eeca3ece512f0227441a39f9dc69ed64de6d2f","impliedFormat":99},{"version":"8c5cdd079401ed60f317bdce7ad8d1f196c83ff5ba809769e0e072c7ba5130ff","impliedFormat":99},{"version":"59ed96cde583387980522a6c849eb384c6b957761c3cc91c2342d8b8ac60a79f","impliedFormat":99},{"version":"ccd5a443fc8f869f27b9f3bb04fe2b0c925d976c45127c5d0fa319c9ec5fc126","impliedFormat":99},{"version":"5c3bb593b853926153fac6366f61f6099f0a19d02bc31d4de73ed387ac2a3ee1","impliedFormat":99},{"version":"fa2c1d795363840e2debe01f19457c1a89d505b39fb5ceb96079057a483b435b","impliedFormat":99},{"version":"d94acd15b4a3517523756dfeabcb7b4fb8ee853bba680d892ccfd3df4c81edc1","impliedFormat":99},{"version":"a324e25d97c3fb7465c07b33953a0311abc74f6ec2f34dd6c3e9e2e2dcb35cc8","impliedFormat":99},{"version":"9abd03a84d5473e66b038270dbeae266129ab97261d348a5fbd32ec876161a85","impliedFormat":99},{"version":"e76b77b319d694a0a6eaa2083bfff21bc11a95f13c439dda60607d8d66dcec47","impliedFormat":99},{"version":"4745b7d941723a317d363952c2fb830e6741956db7e6a29a2d3367e3261c7a45","impliedFormat":99},{"version":"b39a0a13c3c39e523a448b72ffa429f25938d13ad21af702466baf6c87858ae6","impliedFormat":99},{"version":"25591800d3f1085f26bb818516c8102f675876597a25a0262094d47421834716","impliedFormat":99},{"version":"4caa4e2fca87541345762e26360d78a26903123001dadca36e222cd2d6f4c67f","impliedFormat":99},{"version":"909e3572ac981d7c60a58aab8956effcea348ef5c4fd4893fa49111ab9c8f27b","impliedFormat":99},{"version":"3bf2f14609fb722d92d9255faee239e241bb1536876be83580342ec8114e3fd3","impliedFormat":99},{"version":"acbb26b2575aaf25926e685314c43f40d0df046562d4cbc809739584be5e7641","impliedFormat":99},{"version":"57bca639d39adba274ad4c815d6e0dca58d2720f18b2c65fb363858f48fcdd6b","impliedFormat":99},{"version":"2eba0455e8a1f103ddb70d901e9ef927cc6ac33c843d17fbbdf8718f18d54a8c","impliedFormat":99},{"version":"3de5f40d2d7f91a7ac258399ec6814e92850aa84743f17efcbd4cc038f18cdd5","impliedFormat":99},{"version":"2752b702a7652cb6d1c254578d67e2b658fb933495cd93fcea09785bbb694f27","impliedFormat":99},{"version":"7d1de45ea13fddacf53d4586e1a3e8cb6da52395f640744246910c35f13bdb89","impliedFormat":99},{"version":"5a6bae49831f960e7f0bc66f49b2c40077b136d9573871f865507fde09580436","impliedFormat":99},{"version":"8e20818befa967faed7aa9d9edec27ba951d826b359b4415bee2f09204fbd0db","impliedFormat":99},{"version":"cfd0c572e36d17dff1c5a8826584c50ac5969e63b5cb0f9a4a2ea201ada2a7ba","impliedFormat":99},{"version":"f7b5edfa4d033068a292b298b326eb4671c257d065c06fdc03d9b18e88874eb5","impliedFormat":99},{"version":"3b05dae5f0c9bdf14cbe39d5310d6c19c171c36352ef0861e780b4925a73c08e","impliedFormat":99},{"version":"6dc06d72a5743ec50df6c01e35aabbe448fe9e54e150cb44f8feceddfa764cc1","impliedFormat":99},{"version":"2992a29cf3c36433ac5d5e70a67035ba4a5984d11c1cacc91a5528f96c9afd03","impliedFormat":99},{"version":"3d04d3a7d162c68f649aba06921e4e2327c881e9d0f8b658a29b18b0091f6c33","impliedFormat":99},{"version":"d526d476ecdc2d4f778f949eda6eea7ce4026f62fb7f29acdb8afd353e4cf9d7","impliedFormat":99},{"version":"0c209eeab11eaadde8d9757835fc6681155c4c7ed655411e67b8e230fd82308b","impliedFormat":99},{"version":"d625ee4c5de9967d36c5796ca651f253fb615f4408a7ec0801a0557abad68c85","impliedFormat":99},{"version":"b508bd524c943d80149d34dcb99e76a8d3431df9f707fbc5a5f5e5f07a69bb59","impliedFormat":99},{"version":"e3e1cc8cf08e8aae175190a365f0e62976007c0aeea56b71bec6aa30c9adb3bc","impliedFormat":99},{"version":"18c054d4a2eb6cacb592c27bdee6caae2027164f34364e82d4e950c9be7e7ddc","impliedFormat":99},{"version":"132d7d3bfa9fdabb1988e6c68930db6675e3fc34bbe296e5fa39821936836bdd","impliedFormat":99},{"version":"c573b0c6a67c0b0e1f2ee07374624fac22b63637254d1ac626cc361143dd1968","impliedFormat":99},{"version":"e8a8c70232932bf92f352e5f8f9651e33157cd39a9a1daa9aec04bb94303607f","impliedFormat":99},{"version":"80838a5ed85d36f87dedf97f97708740ae3953feb73183c10e4ea547f6473a5d","impliedFormat":99},{"version":"47debd6bda0249e4b57f5e04c56c9c6683a2b352bfac161fc24d866fed923c5f","impliedFormat":99},{"version":"4a6d8a7717689cdcf45e37109e29769748689fea7d617a769da4c26f1aeccb19","impliedFormat":99},{"version":"e87c5aca44bc0f01b68755e15f71eda9324737ddba4ad1bbd481abd20eb4de72","impliedFormat":99},{"version":"640e9e924c3228324f04a04c76b33276e432661a990a3d53ddff0352605d2ce4","impliedFormat":99},{"version":"9dc197564ebea5d0bb19aaa52e7e4fe4950f15f6bcb7126a2b6cb5bfadb07c35","impliedFormat":99},{"version":"ca9de142871e3b8b7a0c5611311fcbb7b0b9f988e9c946fb30636942c0b9323e","impliedFormat":99},{"version":"207afb6b973cd7256564ef84ded56b0a1986586a9a090808b01e8975e28aa3d4","impliedFormat":99},{"version":"4b8869f1ba1c4189b81db38bd1db63383fdc9b99ae7fc532a9a3ac9de39df668","impliedFormat":99},{"version":"7cb46212bd1a7a09ef93154a3e5c32a9a5cd896594d9120c8166826ab0221316","impliedFormat":99},{"version":"c6b196ae0b930bc53f969cac072d2d5484727ff7574533d65c52202c226433ac","impliedFormat":99},{"version":"a5c00d33d753e13207cbd7fd64aecb0d20cb148e44b2cd6db50fbe6b04389c4f","impliedFormat":99},{"version":"e24303a625ba2922c82ee5ba023dcfc22b5b7aa96e14885728551ef9a3e19fef","impliedFormat":99},{"version":"bc43cd39e4dcf3b341cd90967df9c100abcade224412ee1ea56b94129fa96250","impliedFormat":99},{"version":"54f15014cb20913f5270ab54780e9228ee844fd7aa611c121d9582bca4653f1c","impliedFormat":99},{"version":"d5f11d37515acf62da295080602cd1a1f67b6e2d2c1e00b868c5e53fd46c3342","impliedFormat":99},{"version":"714daaa3cfc14d59a1b7cb780a2b2b6613d359eee3258f68835aa5c0023a418c","impliedFormat":99},{"version":"17d6732811c073140dc207498efaa8341be9c3dc423e03adf68e207af582ff02","impliedFormat":99},{"version":"9b4031707c076f73c6dc66297d697d5d9952941071099f6f55f77e4b8b13e0ed","impliedFormat":99},{"version":"858e6ee8d60768456973ebfb15cc797a5c477173b585fb8df872cec543c6aaca","impliedFormat":99},{"version":"2efe611f66bdc7fa6e2105b55051308d546444d61a1d7e6379077be242590f2d","impliedFormat":99},{"version":"d9f027b229ad5d8b026a206ce31aa5b7898efe0ab708a96fe9a45f54c941e080","impliedFormat":99},{"version":"1d083ca29e6e874200bab83efd40e5d85c3d4da21b46b8b00799ba03e0f4fb86","impliedFormat":99},{"version":"ebdc3b72652592040fe10eaaa4ae53621460085eaf70be4b0e560fc30d459877","impliedFormat":99},{"version":"c35b0845639396a86ea5bf1276550dc0db6aadbbfb1d7145fe5974701065f99a","impliedFormat":99},{"version":"7c7dfb0cb2a27eb09a6e6b47566678a13e85de27c244d37d897ecb17399c24ea","impliedFormat":99},{"version":"f5f99c35649b9ad64c6b3dcdd8cfc7c9db3472d27eeb04156b15c17be0e30e5c","impliedFormat":99},{"version":"ecd5b86187507d8dd18df5c1dfdf466533fa0c219f1141874544cad4ee8181d0","impliedFormat":99},{"version":"374ddd65ff6bcec0783a687407c06848dcaa354f98fd885f0e44e73473b03b8e","impliedFormat":99},{"version":"f38ae89747f696e40b633f4c4813e4a7b1e677ffc4d1fe41fa842bc89ece4979","impliedFormat":99},{"version":"b3f309aab87ae7d8c0b3db432480f23a023204fcd58c9ebba001b53aa3ec313b","impliedFormat":99},{"version":"fdf5cf76bab3021864b225f9a1b50d6b2df656d5c9f6800d2860df6d99ea36cb","impliedFormat":99},{"version":"277835d2fa0011bc11b00e550e92a95c82c128af031405938d85a38d8de12ed8","impliedFormat":99},{"version":"70859886ddd69237ad8e8c2e20d052c778870c6e3d420dbcddf4d2d9d56878f8","impliedFormat":99},{"version":"ad42398997e18754aa0441a40d1c73e3a45adef0742ca4b4d4bdc335405f6735","impliedFormat":99},{"version":"ba2edd91e0df0a3d331b411440c9273f4cf55f1603ba36af2bf849f1ab9e7edb","impliedFormat":99},{"version":"c91b058ab74323c57dda1cbda7eb8cee56272002249a642deebbbd977c4a0baa","impliedFormat":99},{"version":"cb7f489960477f1f432a3389f691dc243ca075e87f20032a2866321dab05bae2","impliedFormat":99},{"version":"e57aeb7a5f347f2c6237135add5a5f7db5964c62b7b01211fe8931d8616b5ad7","impliedFormat":99},{"version":"13c2e1798a144acb07b57bc6b66d4eadf6e79f1bbd72472357d303e7b794842a","impliedFormat":99},{"version":"516f5feb685e00a96e4d4c148f9f71f0c388bdc223350c76b7fb97a2750d4d98","impliedFormat":99},{"version":"24c626960973658ff450798d90b9696c53271c2d60192ce73306bd4298dcbd1b","impliedFormat":99},{"version":"7c7a960997d3470573faaaa089e6effd21cd6233d97ba7245974b4adf46597fd","impliedFormat":99},{"version":"560ad98415f922fd0bbe0371224646932d43d3719a5f2b4375817dc3704cb77b","impliedFormat":99},{"version":"69a24ce73bd1a72860582848f778a9404611a2cb05adeb2313c7d13bbc8fbad1","impliedFormat":99},{"version":"abe0dd728aa9abcd8ec475319c6eb54938373f52726dae4e3e97aa7defa7f35b","impliedFormat":99},{"version":"579fa7e0a81dc470473e651382981f18557ade5146e7f88b73e963574cb4dea7","impliedFormat":99},{"version":"eab1832f2519b737bc5cb4f8bcbe2ab715640ef0066f2f242237265d3b26bb0c","impliedFormat":99},{"version":"28ea0039f108f37f8bea3db0f55f129a032ece3f864e56bc5741a34f87114e87","impliedFormat":99},{"version":"a87cbe494f7bc082f0b0eee445fb578ef7bc21b675495639434f9a6d567bf28e","impliedFormat":99},{"version":"d5b27f01ba5f58111d778a35fe732688c83140202ae614436946997557938f33","impliedFormat":99},{"version":"5220818fcb21764a4238fb5f6e80c33469da6ffc37312346266b7a4146450c62","impliedFormat":99},{"version":"223092be51660bc7f4d58c5e0d710af4a1d141640062211c79a39b6bd794c833","impliedFormat":99},{"version":"3e85bd0741475d6fd494462a5b2b0583669b24662586dcd84e79b0b57a4f473d","impliedFormat":99},{"version":"ea33b0b6a133fdc5f24d73731ca316d6746492cd1111fd8486ff18a0c5e4476c","impliedFormat":99},{"version":"edde198b353f71feac0536fdb7bbfc6822054d2b37990ddb60bf94ad2a0a9b4b","impliedFormat":99},{"version":"4542ce8669240889dd3352a9182afa770d03c4ebb6d3e7ea0f57b251e5cf1141","impliedFormat":99},{"version":"b05cdfa9e1da98c66320978c734e5799d87d65e4459a9e6c48379f481052b3af","impliedFormat":99},{"version":"7bf2a520da5bcd1e809b5dc2a97c4856b907310d499b7b1afee2e819870376c1","impliedFormat":99},{"version":"3f54f74fd23f4996d3d1e4f13c2f400f984e936f7c2624e66fdfd4dde3e01c74","impliedFormat":99},{"version":"220331b446307cba2380436654a5d152178fb9da8a21cdf5ff81fa976f18d391","impliedFormat":99},{"version":"a26869d90f718fda8826663a321d00676a1542cf8d2f9270ad4a123dec6d6c81","impliedFormat":99},{"version":"86c32c0d6f5b9a3154cc5f3a9940fe072c5039671bc6fefe093ad90ed942fca4","impliedFormat":99},{"version":"3b8e9ed55356244fe7f14bbf799432fd79722975a26e4260befdc9a12f56c4e4","impliedFormat":99},{"version":"8d83324e9e2c32400cb73467d84a62dd728211cedc97bbb87373644416e77d1c","impliedFormat":99},{"version":"0faaac76aaa8aac11ef1a5c7963a4f5f0a6d0bd4f4685a179861f0de5863118b","impliedFormat":99},{"version":"d82f6d8f1886f7b27e0d6d55edf506d6a6bd0c4dd469df07b839368f487f1e46","impliedFormat":99},{"version":"decf2f16fc753624272bcce7388ba5773143e29da5fd5c1f99f4dd7f256a63f7","impliedFormat":99},{"version":"94a2d7c15538d8e83415299f17fd00ab88c594b6a0a40be1e26c99febbab45f6","impliedFormat":99},{"version":"381f3accb1b022a35c043d19cbe0cd5218e97077ec6a90f40ed79fb987c40f23","impliedFormat":99},{"version":"db1c146bb98f18eefe1aa37079090ddc200713f10dd0b53e5795aa1c30612264","impliedFormat":99},{"version":"96a687e0c2304bc17be245728797469b6b8ea2eef6dcada4a2b849672596b516","impliedFormat":99},{"version":"cd24b9b6ddc36df82c5d3e128d5d64e8de214ee89f203638e4c00a1af24d27f3","impliedFormat":99},{"version":"92df9de23ce83ddf43371881daa7e996b4bcdce88a349a6a2d9fd08433500d8d","impliedFormat":99},{"version":"da0b84be87479b7d7be8c2e4101a231ca55328efa99714bb54a35d03f689bd4d","impliedFormat":99},{"version":"282612c337fafe5695bb3617d1d4d51cfaa11e0c4923af9fb65852c8dd5028db","impliedFormat":99},{"version":"4b83e2822d39bafdf3744edf8c9ff0517b660bb786b3703cbdd74a5c71c566cd","impliedFormat":99},{"version":"aa5d645ea3ff7c41a3ffc327c6d85c7de11c281a5199426d79d7d9a23fcb7a83","impliedFormat":99},{"version":"73e040e9bf68c04a4d8ed505b66b0fc3736ce4e2c3eff0c70ba714b6d7ecdbbe","impliedFormat":99},{"version":"77d3851103a2fb69733773e35bf3e2006604c3909436791921fdcec7d8e7266b","impliedFormat":99},{"version":"d09933dd700b5fd595aa9921c48bd3a00ff8bf73b5b6a55935aa260282581706","impliedFormat":99},{"version":"5c834ed67b61fdd842a8f3e0fc92901d4f35474bc305d97380144ce2f607ed7a","impliedFormat":99},{"version":"da6f03bec40cc4be1a77ced505133e27442076f5c4873a5e01eb935fe1fb569a","impliedFormat":99},{"version":"15e582cc34c41201f053ad6a63269c13093141b8146ceb219290509fac585332","impliedFormat":99},{"version":"78e458eab6763a558f7f02df847f63fdb01ee3cef4919e76514228a6048870da","impliedFormat":99},{"version":"5a36d974ba70c571928fe8343254501b903c38590983df4d5e1a6e6e3d1d1cda","impliedFormat":99},{"version":"53eaebb4ff9eeb4b93499decc874f630f844612dee2cf7b44c4ae09a1b7cf64f","impliedFormat":99},{"version":"f262f10ff10bf39f760b5f56ed941b496082f840cb34f4ea765aaac84e3cebed","impliedFormat":99},{"version":"f5b262f0fe03e6514c5566b3f714b2a013801725583950c7284f0493bd2e2e91","impliedFormat":99},{"version":"4aa24ae79c1523df6c5e7660b3b41c75cf9f82908faf65d66c86c3cab4390d9a","impliedFormat":99},{"version":"4da8dbdd37fb1953481ff091d5af23a5b0956452a0e49781e957d1b33ff10f66","impliedFormat":99},{"version":"3786b7eefaf62129935c1268a30f5e1946b06d67586db003f13feda086f63269","impliedFormat":99},{"version":"e99d3af9aae3be20ead69859da9b19fd06b1da58faa2b3319e7c8eccbf130525","impliedFormat":99},{"version":"ffe74a08e03eca3460a47733db41b98d74cdeacfcb781f71bc5fcad97300ba9b","impliedFormat":99},{"version":"9d71a05a06f08b2f2ab08b66ca9dac1ca23fc697f34c258fca57cd89d93c961e","impliedFormat":99},{"version":"26301b0b384ea59d5429128dda4bbc586960b084799264dbf798e3d9e5d3a3f1","impliedFormat":99},{"version":"3efde945725457e42b3a4810cb90d04564b1fa44a1158fa88cb0594f0f1246a4","impliedFormat":99},{"version":"d841fac98fe80364d79d256678cf1082d6a6690f0cc8c91899005b575fe76eff","impliedFormat":99},{"version":"ec273e29d916d26c4231c3a9b8efb3ddb4ef448243e0bc8919081ed8f057023e","impliedFormat":99},{"version":"5ca92a8e1445d95869725101cd28e3b6a343beee53fca72f0d718e31288bd11f","impliedFormat":99},{"version":"8b41b5afbafe7b6c6b43ef8466da025ee3745b2ba3ce69bbb58a34794deb811c","impliedFormat":99},{"version":"60be140db9c3229468de970734037ad5a4ab2f4297c3e0a3486084943bf161d7","impliedFormat":99},{"version":"a1150a8796da8ce8dfc6defc6a7e6fef612e0a6713fbd5eff9e2a47d823838f0","impliedFormat":99},{"version":"45326b8f539942d683547becbf4b6189edf0c8291541f14feb958d59214e78cb","impliedFormat":99},{"version":"46bba6412696454f65b7dbaa75eea9dd12cce24de32b208c3aef5faabf91f3d3","impliedFormat":99},{"version":"bcc7494f86855366ced0fab58c5be2f48633519957320158bd97834f520ff477","impliedFormat":99},{"version":"e0ac5ac97e881b7dea0bd259c9c824abb1a25fe13f5e15e98eeba9cb88bd5b55","impliedFormat":99},{"version":"f2ec7c52bd4fc835d880524898f1eee0f81d46adaa2e7f99246ab17698b257d3","impliedFormat":99},{"version":"d6d918c5cda2429e4530e89b0832e1e2c465dd74a7371e9251f54092e0356d7d","impliedFormat":99},{"version":"0ac26b0761d9ab21bda5687100dda02ac873f04fc2e63dd5096ddc761ae3ac74","impliedFormat":99},{"version":"c8ff0b63346afa7496829d8d8c1e9cdfee6b367ab3e59fd55be7e9e735085280","impliedFormat":99},{"version":"c4bdc832eb5b68bac94c1194582c87a404f0c63db803c334e0f5cbdc569d0e2a","impliedFormat":99},{"version":"83b52889496f48360a5e578fd0f28c3e25b53d74b61debbb97ff9a355cec11c9","impliedFormat":99},{"version":"b675e40da933477838d2388ca57d9ca725870ce3b998593ad51fb1f4f65b1731","impliedFormat":99},{"version":"c66e5e7001cb59aa2f893389cd8c22e4f583e71d83d7baf3e6208061e49fc8bb","impliedFormat":99},{"version":"c54892665f8908a0ece28bce8645ce17cff887650a234c83748eb15d211b03fc","impliedFormat":99},{"version":"ee48aaea4959ec44f919041922880252ca2a6fbdd0126d66f896b652d1c31bda","impliedFormat":99},{"version":"eac98bf1f90e1a3ebb278bec416cbed397b12c02125ee0ff71bc4fab2a1908e6","impliedFormat":99},{"version":"fdb2af00500688a4d7043bf7c2d434388a6f79ff02c94912f3905e9b53756280","impliedFormat":99},{"version":"97cdfac4cb84dfff48652285f3dc17ef218b9c86392da6e609a8a926cc80381c","impliedFormat":99},{"version":"960ba74b3287cc4cc052635b5d55f1bf0c8ed2e5099960aacf80276530f7a23c","impliedFormat":99},{"version":"923e87bb7963af6c076afd0133a8cf509ebb198564e509b3a82465e8f9e9b31b","impliedFormat":99},{"version":"26378fde892f5c5c01f72bdf2374bc3f802c6ae5839d67af8ddc821d90d2f987","impliedFormat":99},{"version":"eacef4a482e552c59d1e849ae8dcb6faddba65fbd2b202d669d0710cc624b21c","impliedFormat":99},{"version":"6c045250c732fae826a7d2e08313a95631b9605246caf42cf1e3cfeac9860a6f","impliedFormat":99},{"version":"0f9e4a6a6ee409b4fe4974d3bda8aa78aecfb0ab82b54f6634942b5989b78112","impliedFormat":99},{"version":"3a45f71d69f810f5907eb96862ef9312bd8d2d8237a12c0b44ccb539d3ff57e2","impliedFormat":99},{"version":"328fcc5e2446d4a6a72178bb4232d3e670c12772b8a61c70201c9e1332f0392c","impliedFormat":99},{"version":"1f7f7c2bb12ad319a15ea28196837c2b99070f54b24accc72134d3712fcc7aeb","impliedFormat":99},{"version":"71ef86ebfaafa56bb3a51f38e11e99dae5eb8b20b9eaac8cdea06f9948511a84","impliedFormat":99},{"version":"4fdaff2afffe91a8e17a6426f38bc3363b061491b3e3ee4fe27fe1f63bfcbb51","impliedFormat":99},{"version":"08ee30a6ab526d5aa117a2a7de97ad0bff71a22d290da0d35c26d9738274b17a","impliedFormat":99},{"version":"0ccf5694dd47e2e22840be052be14810059746c01393a5e8c3191aa55062a6ee","impliedFormat":99},{"version":"9ff3e7bcf6c3757c0b91060868497b52efef1132d2b92aa72069fa8a866cda4b","impliedFormat":99},{"version":"a1f749ca2ac06e8cb51118a6b907df90f90c0cd80f46d604089407abeb932119","impliedFormat":99},{"version":"30cd48abc95a4b93efc154e756c0ad95f009bc623181bd667c34cd4a0c53b18b","impliedFormat":99},{"version":"1afd5c409520d9cfc7ba0090e724194b0f96406e79c42ebd56b62d5d8792571b","impliedFormat":99},{"version":"190fba113074ba015ed94391cf5a4af926cbd6ae61ec35eee70841071b3f1b85","impliedFormat":99},{"version":"de493ac034bf0419341839724ea2dd16aef2f7dd9aa5b409dc04048226e896c5","impliedFormat":99},{"version":"15fea98c30c1616f81fd64e0e30a88b5defb1cce87546b4b3a7dc6f585e21fe7","impliedFormat":99},{"version":"2e9996a8cbb27215f0eb63f91fb98a786d8883b7a55487a0c645169f60902fb9","impliedFormat":99},{"version":"69ac911cad5852ece5c4e7430bf024595cc23463e94a88c9ab391e8d68816967","impliedFormat":99},{"version":"fa33aa1ee39efc0d964b226d1f6e48717a5a157398783490ba04245bf53ac551","impliedFormat":99},{"version":"53e2856f8644978742fae88b3c7f570ab509dc4d13288b3912a4446993fa3bc7","impliedFormat":99},{"version":"7cf786964e26f0e2c3a904f93f6e31609e2636723df8c1ce248d39b55055c89f","impliedFormat":99},{"version":"6bff8bea27f0dedad4d7fe0357c0ee76f1d247e4c96ea3fec0c35cb5770bb9e5","impliedFormat":99},{"version":"eee6890b29f2bfef558721888b26a722b70937b65253dff66a48a3a9f542cc70","impliedFormat":99},{"version":"9f9a94c956302e773ae41b64e3ab1ffcb3a49be9ef06c73cf7b0d292e68a7e72","impliedFormat":99},{"version":"313ec9122ba198c2b5e244ac21a7ace6e2e666ab219b72cded594fec04c97d26","impliedFormat":99},{"version":"62951cac61f6e22aa74700dac7dfab171beb4d12f97f70e5db9be888ff0e5ed6","impliedFormat":99},{"version":"99484c7a277c488a16c49ac1affe465e4fbb5e4d57b8c2190092c5d7b4fe6fca","impliedFormat":99},{"version":"8b3f0012a7e5d117922f89928113b901b80dc344295597bc9b66fad4fd346a28","impliedFormat":99},{"version":"2f2dfea24dd48624f71de12000ea7e1d1d6d950b02b6d887d68f3a0749ad2866","impliedFormat":99},{"version":"50914a9162d152c14337a597d41e56929e18c1f2eb6a139355530bb2821e96fa","impliedFormat":99},{"version":"0f65f9b61383ffcfa1a409da90c35741cd81ece1a2dc6f2ebd094d81599bc5f6","impliedFormat":99},{"version":"884f8073c4687a2058be4f15a8f3d8ad613864a4f2d637bf8523fa52b32cf93f","impliedFormat":99},{"version":"693c4ea033e1d8cb4968972024b972aed022d155a338d67425381446dcea5491","impliedFormat":99},{"version":"5d5303992a1d04c953dbc3d7bc9fcb3266f2917fc3ff9f9aa8c95f9294b37345","impliedFormat":99},{"version":"b6024c6222886b95cb29ab236155a98f8e5dc41151233781815e81a83debf67b","impliedFormat":99},{"version":"94dab3752006a2cd2726462342f1775ef18ff4986404d016d317fe79a9d0a14c","impliedFormat":99},{"version":"727b3a462015bbed74b520861445761ebaecf94e09d95bbf59dfcf22afaccae9","impliedFormat":99},{"version":"2c0300921d8d04b21353c94a8f50a2b6c902feccd1303b6f136bedbb2cec5ed1","impliedFormat":99},{"version":"d496217c7f38f218fc162e8f3e6ed611343aa65615f730f82c494dee6c892bc0","impliedFormat":99},{"version":"282ed4ab5b5c4759d5c917c51a5b2f03ca1df4072275b6bccb936cf60078e973","impliedFormat":99},{"version":"2c96813e14e7edcd8e846f009b24fb1bd842b90e2dcd85481136e52588de7982","impliedFormat":99},{"version":"aa70da8072bb8b6e8fae35c7d394d543be8e5c946dad666225a3475010fd2bf0","impliedFormat":99},{"version":"d2c35cb9836cae1899ae9e7e114410dc128bcff4a79cc26318db285699e0223a","impliedFormat":99},{"version":"f89fbb50fd3736e09b418a2e66b98ff9a04820259856afe54bc67977e1acd05b","impliedFormat":99},{"version":"4c76aceec7002f299d9a57ec8e6623f3573bea208b1ea51cc5ea03bf140adad4","impliedFormat":99},{"version":"a0f217b01453d43058cea514325ac8bd3ac3a184265314429eec8059c62824b6","impliedFormat":99},{"version":"e06bc5a68917139f31f323293f575cf1eb75231ac23ac1b95341079364ef1873","impliedFormat":99},{"version":"31a4b6d0c23346d5fb30b52bd3a8f83113fc928ee6474338d5571361943d58ea","impliedFormat":99},{"version":"aecd83ca7059d21a33fb7ed01dfa06a36c545698dbe0017073dba45532a8487d","impliedFormat":99},{"version":"7fb874c17f3c769961d1b07b6bb0ef07b3ca3d49da344726d8b69608997ef190","impliedFormat":99},{"version":"979e969f86456425e505f6054f5d299f848223d70770a5283fa7c405020b47e1","impliedFormat":99},{"version":"2ad6c5849a68263e12b9f246ffd09b4713cef96d617618076adbe2f7907f3d12","impliedFormat":99},{"version":"acd7f9268858029bcec5eba752515b9351d4435b21f1956461242c706dcc0cf9","impliedFormat":99},{"version":"ea2b6112bfd326f1075896bf76c9108dfd08ccbae2482ba31f68ca43f0b59ca5","impliedFormat":99},{"version":"3f9368aa15d0cc227a3af7af3e3df431dadf0f7cd9897fcc54507f7eb68761cc","impliedFormat":99},{"version":"0f2d4be859066fc3ea8d04b583cd0774e1f9dce7f60b9890bcc0a10efb9fac33","impliedFormat":99},{"version":"ac09b9131c553c189311d9e94d3853b7942d0097925304fe043220a893701ce9","impliedFormat":99},{"version":"f1b34ea3d64f73fc79ce1f312589134db27aa78ef9e156a8f14f89f768e800ac","impliedFormat":99},{"version":"873da6c837a1ee62b5f9b286845be06dc887290a75c553bed7f431107d25a3b6","impliedFormat":99},{"version":"b2abee3c001c024d4e552c4a3319bf3fcc94a1f48bb0d21f5d300d9b4920bde9","impliedFormat":99},{"version":"f9740d044306830442cac761b593538117f46c5ea57a8dc6d61f0bee12e971b6","impliedFormat":99},{"version":"41c6aff52e4289763ea30f0849b712437aaeb420c8448aeb8047ee2eca4549f4","impliedFormat":99},{"version":"f5db101f7d90f614627bcab5f8d06d9ccd144a1735b475637940c54097786b67","impliedFormat":99},{"version":"8c575a8e1b6032e576577f28d74066f73aefa7a35d741d0015be36956bbc30aa","impliedFormat":99},{"version":"1989cb4fb2174c56b15f8b10d18ecb0c053e7b39f94582581d69767d7bfb9b32","impliedFormat":99},{"version":"4e32d557115e12d4d6f4efa3ae616143cfef39d32115e472a2134b5871ed9f40","impliedFormat":99},{"version":"47921880701610e8d8a5930d0c9ea03ee9c13773e6665f4ffc8378d5f8c8c168","impliedFormat":99},{"version":"41cbf6c58f2f4e1e5ee95a829b3f193f83952385fa303062f648040a314f939b","impliedFormat":99},{"version":"bb11cd0d046d21d4ae4a28fc4b0eb5d9336a728f9bd489807a6a313142903bc1","impliedFormat":99},{"version":"a96d6463ab2a5a4cf31b01946f1b0929dc3f8be9f28c7c43da29a9e6b7649db1","impliedFormat":99},{"version":"ec43d6b21fd1ed5a1afeb779ceba99e80fe010458bb0a67d9ef301426b1929e5","impliedFormat":99},{"version":"87b5287d316dc32aa408e3f98d3df0aaf72f1f33ef6d5bc1b6cc0b1e16838756","impliedFormat":99},{"version":"79ffce57ab318282b29bceb505812c490957124a3a96c7d280a342488b0859bf","impliedFormat":99},{"version":"c0d0005f448e886b3ce4f79749bb3bb01b030134c82106b0f564ced50a5728b8","impliedFormat":99},{"version":"c0dde896477af7420467456ee55e8ce9497bfd724306fc767df03aff584a1bf8","impliedFormat":99},{"version":"e12d269aa86b614a245ba3647e3858ed11eeaed1127355df17f0024097251291","impliedFormat":99},{"version":"5d8a9000bbbd72cbecbe92aef031548c7a79f07db99c909d6d80e7e97ae564dc","impliedFormat":99},{"version":"67070025bf1e4fb98f0c342614d4d1c9a62f80e66bb59f5fa5de5f149d9e8730","impliedFormat":99},{"version":"23bfc0bcfc61f5c90eb75940956ed13eba0a0d01b2e09ea87df4c2f5a8ffba25","impliedFormat":99},{"version":"2985ac10580fc18e9af90499e98df3bb2a2c57ecb81f177000961fd79dfaf7f5","impliedFormat":99},{"version":"848fe82ffb97a4714de0a5e71b5595915208cec3f7c54c9e4d3d880f1fd6d16f","impliedFormat":99},{"version":"d01a00191e9bc6876014e4f87c825e7d389405be9bf2919402adc4344b1d5307","impliedFormat":99},{"version":"577cd3fceddf4891e9a369a7f59ce576024c7d859ac961060296a1cbfa00c6e3","impliedFormat":99},{"version":"c0cb067049695bde19be2985ad914471cc2c2df64019a1899254546696d23aa1","impliedFormat":99},{"version":"3fcd1fad56c7b90a8ce8a5e81ff288c81bd7bf5402a3bf4efcea44cf324ddd1d","impliedFormat":99},{"version":"8f47a2e6bd2914f74471a693fc3389f243a97367d8bdd920f27198b6018872ad","impliedFormat":99},{"version":"d6e125557820886c2add872cfb3e9502d4113fd1dd22a1f76ded1f439837f119","impliedFormat":99},{"version":"6e688e8aeba98c268b195f80355a8d163d87ac135ad03c708ceda608e6e269b2","impliedFormat":99},{"version":"802a6978c1b38822934ce43a3505e13b555584848c50bc5db9deb2e896c0940e","impliedFormat":99},{"version":"f502c7d829f5774109007ec2262c23efc941dd1ce42acc140f293a7c5ccfd25b","impliedFormat":99},{"version":"af3444bd00030bae3bef81569f8703ecddc2e569cb6b728ec045f0d73d47572b","impliedFormat":99},{"version":"53102281f8a153bb051e0223a8dc51ff9c4cf92da127d91e3f60e74b4e8f41ca","impliedFormat":99},{"version":"e402e111fadcd36fa26ea1ad74f3defd6ef478f6d278a69c547e664b57770392","impliedFormat":99},{"version":"bf8f4b3b372e92a4e4942ce7f872b2b1e1bd1d3f8698af21627db2dee0dda813","impliedFormat":99},{"version":"0ff08be8d55c47d19f3d6bd79110a2ac67c6c72858250710ba2b689a74149ee2","impliedFormat":99},{"version":"77676a7a58c79c467b6afdb39bed7261a8d3ba510e9fd9b4dbb84a71dd947df3","impliedFormat":99},{"version":"dad5c38d723d08fc0134279b90fac87441ee99b71b0d30814b86954e0111d504","impliedFormat":99},{"version":"dd7510a9a4d30db5ac6418ef1d5381202c6b42c550efeb5fb24dd663eac3f6a2","impliedFormat":99},{"version":"cef653b7f2115c8e2a9b6558bf9a083dbcc37ce8fb6bae0e48cde3b92fdaacb2","impliedFormat":99},{"version":"2c87178f8b940592781cea818e840a825ad9cf5168593ff36469c5edb82c8ee2","impliedFormat":99},{"version":"34e0a7e03021f1f29f109cee7054216f94a6a769aa965070b3d00cf4648a8ce4","impliedFormat":99},{"version":"c85f04a8ff65051d2cffc664baa83b70583bd72b9811a50c77f880968c1188ea","impliedFormat":99},{"version":"ad48586787d5e217f4fcc229e3c3d8de8aa12979fdf1f186134e3684d56577ac","impliedFormat":99},{"version":"229d6bca5145c86846793cb3166c83abb256cfdb5c425f25ada8eee49c993e54","impliedFormat":99},{"version":"b8562e5aefa86c069ec1c61dff56ef0492e9fbd731cbcdd4d7fce28a8644e9f6","impliedFormat":99},{"version":"7b3749cff64a3e801c9c324338abf939c3bfdd96803cf4af87280497626d8a51","impliedFormat":99},{"version":"dd6c7d6abb025e7494d02fa9f118af4a5ab0217e03ae54dd836f1160cb7a9201","impliedFormat":99},{"version":"b8ecf3aa6da346b8dcf36e93c4dd9232bbf3a413fae23f5bcc950eaa62d0139d","impliedFormat":99},{"version":"440c9aba92c41b63d718656bd3758f8f98619dbe827448e47601faa51e7a42fa","impliedFormat":99},{"version":"e158b62ea32452d2348fcc677503f890127f3efe3daca5dcbdfe4ca96ce268f5","impliedFormat":99},{"version":"d9cf429fa9667112f53e9bb67bb7b32eeb3697f524d01b9781b65247f1733da4","impliedFormat":99},{"version":"d12caf569803d56c5f827e4d90b00da9e631e8dfc088fa836256c647c0ac21d3","impliedFormat":99},{"version":"ea7b50e95a07d4958009daa7820eeda23f7d215bed0d516d5c98271f5466645f","impliedFormat":99},{"version":"4e549cbc811726ceeb47b55c3a68ec89b7d4413710f03eda57fd43b85b73d8af","impliedFormat":99},{"version":"21c180c753baa409e924458db18bbe02c838c9b8a37605e042c3701488ecc561","impliedFormat":99},{"version":"2fcb9b13c206fa4f6e88a2c090e4d591e4a963f8fc53b70ddc67507a976b7dcf","impliedFormat":99},{"version":"a90cd2ec48f9216a2abeb96fb5256de64b71d9e10979b7073dcb9d76f8addb49","impliedFormat":99},{"version":"e67fbc9a974d14cab74cb47b4bed04205886bf534c7e2f17ecb8f7789d297b1c","impliedFormat":99},{"version":"82d76af0a89cd5eb4338771a2a5b27f3cbc689b22be0b840de75be4cfc61f864","impliedFormat":99},{"version":"a5866d75f24b41f3e88db8b580f0e892ea87a357be865ced4bce8bead6cd7a12","impliedFormat":99},{"version":"fe395a24df9ffd344cb825575d4b35c1cf69275208c0f99517c715bd7d08ff79","impliedFormat":99},{"version":"39e8edcbd5ac35c6cfdf2b1a794a9693a461a54efb2a475ab7fc08ab13504e26","impliedFormat":99},{"version":"ba3154f365b4217a0a46fce9efedfa70a155cebd3e85167243e6c29c72128ec6","impliedFormat":99},{"version":"b71e7f69e72d51d44ad171e6e93aedc2c33c339dab5fa2656e7b1ee5ba19b2ad","impliedFormat":99},{"version":"eb8a258495db43e8e4641def32bbbee1b73ecdc680407f948543bd9950668293","impliedFormat":99},{"version":"08fb78352391389bd98aedf175a40bdf4072ee1f73a1c9ccbbe93e7a8f1297bb","impliedFormat":99},{"version":"d17f54b297c4a0ba7be1621b4d696ef657764e3acddcc8380e9bfc66eeb324a3","impliedFormat":99},{"version":"451cdb6c6501f0afe810206659257a5b5d9c8625260c8950ad7309a40c500c3b","impliedFormat":99},{"version":"a715a2786c285a9e27ea2bbaa2ed249d3017e7139782f5ebb8eeedb777b26926","impliedFormat":99},{"version":"2dffb65044b6a28dcba73284ac6c274985b03a6ce4a3b33967d783df18f8b48c","impliedFormat":1},{"version":"f7e187abe606adf3c1e319e080d4301ba98cb9927fd851eded5bcac226b35fd1","impliedFormat":1},{"version":"335084b62e38b8882a84580945a03f5c887255ac9ba999af5df8b50275f3d94f","impliedFormat":1},{"version":"5d874fb879ab8601c02549817dceb2d0a30729cb7e161625dd6f819bbff1ec0b","impliedFormat":1},{"version":"ace68d700c2960e2d013598730888cde6d8825c54065c9f5077aaf3b2e55e3ad","impliedFormat":1},{"version":"86de522a6c6f7854738c1a88f3639e472e1778dff42ffd9f296476099cf170e6","impliedFormat":1},{"version":"4d7d964609a07368d076ce943b07106c5ebee8138c307d3273ba1cf3a0c3c751","impliedFormat":99},{"version":"0e48c1354203ba2ca366b62a0f22fec9e10c251d9d6420c6d435da1d079e6126","impliedFormat":99},{"version":"0662a451f0584bb3026340c3661c3a89774182976cd373eca502a1d3b5c7b580","impliedFormat":99},{"version":"c02203ae7f03fd2dd9c0da1a08a886734c54aae25fdf8543b1125589f20f0b52","impliedFormat":99},{"version":"409d9b2dffd896e5589be900b59d81149fd48dd811a6fca9311407e03b331e80","impliedFormat":1},{"version":"2bb615af134fe1c15f0d9f7694081d004640d38f95cb8216469116020d1e219c","impliedFormat":1},{"version":"2260604e0aa7d468ed3b9f2812a414eb70b680c45b3a691aca6c88a85babece7","impliedFormat":1},{"version":"6ef7ccbff794f08fe318744acdcccf356d5a00ddb74685a95bf8d9156d401ed8","impliedFormat":1},{"version":"3456acb6ff0d0a202eec1307f2e8b2d1cbba68dace120c47b7e38d7343da19f2","impliedFormat":1},{"version":"7a429fa77d22d12f8febc7ebbb00fa45c75c60b47ce840f92f03b05e9d16648d","impliedFormat":1},{"version":"4852930d1e33da62f75e66ae71bf7b6646d0e0aba7704ff3d1bdda15656dd7f7","impliedFormat":1},{"version":"9dc3f2a0efa278d6255bcd95b42ce28f8e14f177f6701bd6668999a34356f1c7","impliedFormat":1},{"version":"5483233566b27fecdef8a3f40420d60db822ffbdb0cf20073ac8fd0157fd2290","impliedFormat":1},{"version":"b42bc4e718dbeba955b71adc452e5023b8dda17aa57bb9050ec8c542a8e7e626","impliedFormat":99},{"version":"2091e884437c2fac7ef5b4c37a55a1d0291f3d9e774ca484054adf9088a49788","impliedFormat":1},{"version":"c2762b064c3f241efdcbfce2a3fb4fe926b9c705cbea1da8f2ee92a90bc44e27","impliedFormat":1},{"version":"6b33b56ce86bed582039802da1de9ff7f9c60946b710fb5a7a00ee8a089dc1a2","impliedFormat":1},{"version":"b4fbfaa34aacd768965b0135a0c4e7dbaa055a8a4d6ffe7bedf1786d3dc614de","impliedFormat":1},{"version":"be3daf180476b92514b9003e9bd1583a2a71ad80c9342f627ca325b863ca55d4","impliedFormat":1},{"version":"8ab9b0dd5ad04b64911bbf9ae853690d047c1e12651940bd08da5b6c8fae8b04","impliedFormat":1},{"version":"6fcb9ff90e597db84de7e94537a661dca09dc3c384e1414496d76d31f91232a3","impliedFormat":1},{"version":"ad68aac2dffb24c0330e5bcfe57aa0f2e829650c8dfe63d7329d58af7277990e","impliedFormat":1},{"version":"df0627eabd39ed947e03aedef8c677eb9ad91b733f8d6c7cdc48fc012a41ed8a","impliedFormat":1},{"version":"2164ae0de9e076bf50b097cc192d6600a7b3eb07a0e1cd3281f7f5d19d4f4638","impliedFormat":1},{"version":"e9759993d816a63028cb9a42120223941b0835c6b27aa8af69cc650a18c1bf91","impliedFormat":1},{"version":"f964f0ebc9cad8ce4873f24e82241b8eb609d304cbc1662a739443b24ef11c9e","impliedFormat":1},{"version":"f0f65a61b70d5ddb3d7f07a6e3f9d73a5da863172c815a3559c8bbb5c18bcc23","impliedFormat":1},{"version":"639c15ef2ce567ec3a62d9c51a43b65f1a8eabfdc88dc5ed57f1f23cc213189f","impliedFormat":1},{"version":"b6d80e669780b6591b159637ad0e8cf678cf6929fa0643be7d16aff7ca499bd6","impliedFormat":1},{"version":"d4e6925460a27b532a99e38bb0e579ed74b5f6422d70a210aeca9da358526f89","impliedFormat":1},{"version":"8a9d6ffa232e5599cebac02c653c01afa9480875139bab7d70654d1a557c7582","impliedFormat":99},{"version":"9ee450d9e0fbae0c5d862b03ae90d3690b725b4bd084c5daec5206aefa27c3f1","impliedFormat":99},{"version":"e2e459aac2973963ed39ec89eaba3f31ede317a089085bf551cc3a3e8d205bb4","impliedFormat":99},{"version":"bd3a31455afb2f7b1e291394d42434383b6078c848a9a3da80c46b3fa1da17d5","impliedFormat":99},{"version":"51053ea0f7669f2fe8fc894dcea5f28a811b4fefdbaa12c7a33ed6b39f23190b","impliedFormat":99},{"version":"5f1caf6596b088bd67d5c166a1b6b3cd487c95e795d41b928898553daf90db8d","impliedFormat":99},{"version":"eaeaddb037a447787e3ee09f7141d694231f2ac7378939f1a4f8b450e2f8f21f","impliedFormat":99},{"version":"7c76a8f04c519d13690b57d28a1efe81541d00f090a9e35dca43cde055fed31b","impliedFormat":99},{"version":"17c976add56f90dd5aad81236898bad57901d6bdac0bd16f3941514d42c6fcc7","impliedFormat":99},{"version":"0d793c82f81d7c076f8f137fa0d3e7e9b6a705b9f12e39a35c715097c55520c9","impliedFormat":99},{"version":"7c6fd782f657caea1bfc97a0ad6485b3ad6e46037505d18f21b4839483a66a1c","impliedFormat":99},{"version":"4281390dad9412423b5cc3afccf677278d262a8952991e1dfaa032055c6b13fb","impliedFormat":99},{"version":"02565e437972f3c420157d88ae89e8f3e033c2962e010483321c54792bce620a","impliedFormat":99},{"version":"1623082417056ce69446be4cf7d83f812640f9e9c5f1be99d6bc0fad0df081ab","impliedFormat":99},{"version":"0c1f67774332e01286cdd5e57386028dd3255576c8676723c10bd002948c1077","impliedFormat":99},{"version":"232c6c58a21eb801d382fb79af792c0ec4b2226a4c9e4cf64a52246538488468","impliedFormat":99},{"version":"196ce15505ddb7df64fa2b9525ec99ec348d66b021e76130220a9ac37840a04a","impliedFormat":99},{"version":"899a2d983c33f9c00808bf53720d3d74a4c04a06305049c5da8c9e694c0c0c74","impliedFormat":99},{"version":"942719a6fafe1205a3c07cecc1ea0c5d888ff5701a7fbbd75d2917070b2b7114","impliedFormat":99},{"version":"7ad9c5c8ca6f45cf8cc029f1e789177360ef8a1ac2d2e05e3157f943e70f1fa3","impliedFormat":99},{"version":"e9204156d21f5dd62fa4676de6299768b8826bb02708a6e96043989288c782c7","impliedFormat":99},{"version":"b892c877d4b18faad42fd174f057154101518281f961a402281b21225bf86e2f","impliedFormat":99},{"version":"755e75ad8e93039274b454954c1c9bb74a58ac9cef9ff37f18c6f1e866842e2e","impliedFormat":99},{"version":"53e7a7fa0388634e99cf1e1be2c9760c7c656c0358c520f7ec4302bd1c5e2c65","impliedFormat":99},{"version":"f81b440b0a50aa0e34f33160e2b8346127dbf01380631f4fc20e1d37f407bef9","impliedFormat":99},{"version":"0791871b50f78d061f72d2a285c9bfac78dba0e08f0445373ad10850c26a6401","impliedFormat":99},{"version":"d45d1d173b8db71a469df3c97a680ed979d91df737aa4462964d1770d3f5da1b","impliedFormat":99},{"version":"e616ad1ce297bf53c4606ffdd162a38b30648a5ab8c54c469451288c1537f92e","impliedFormat":99},{"version":"8b456d248bb6bc211daf1aae5dcb14194084df458872680161596600f29acb8d","impliedFormat":99},{"version":"1a0baa8f0e35f7006707a9515fe9a633773d01216c3753cea81cf5c1f9549cbd","impliedFormat":99},{"version":"7fa79c7135ff5a0214597bf99b21d695f434e403d2932a3acad582b6cd3fffef","impliedFormat":99},{"version":"fb6f6c173c151260d7a007e36aa39256dd0f5a429e0223ec1c4af5b67cc50633","impliedFormat":99},{"version":"eebfa1b87f6a8f272ff6e9e7c6c0f5922482c04420cde435ec8962bc6b959406","impliedFormat":99},{"version":"ab16001e8a01821a0156cf6257951282b20a627ee812a64f95af03f039560420","impliedFormat":99},{"version":"f77b14c72bd27c8eea6fffc7212846b35d80d0db90422e48cd8400aafb019699","impliedFormat":99},{"version":"53c00919cc1a2ce6301b2a10422694ab6f9b70a46444ba415e26c6f1c3767b33","impliedFormat":99},{"version":"5a11ae96bfae3fb5a044f0f39e8a042015fb9a2d0b9addc0a00f50bd8c2cc697","impliedFormat":99},{"version":"59259f74c18b507edb829e52dd326842368eaef51255685b789385cd3468938f","impliedFormat":99},{"version":"30015e41e877d8349b41c381e38c9f28244990d3185e245db72f78dfba3bbb41","impliedFormat":99},{"version":"52e70acadb4a0f20b191a3582a6b0c16dd7e47489703baf2e7437063f6b4295a","impliedFormat":99},{"version":"15b7ac867a17a97c9ce9c763b4ccf4d56f813f48ea8730f19d7e9b59b0ed6402","impliedFormat":99},{"version":"fb4a64655583aafcb7754f174d396b9895c4198242671b60116eecca387f058d","impliedFormat":99},{"version":"23dae33db692c3d1e399d5f19a127ae79324fee2047564f02c372e02dbca272d","impliedFormat":99},{"version":"4c8da58ebee817a2bac64f2e45fc629dc1c53454525477340d379b79319fff29","impliedFormat":99},{"version":"50e6a35405aea9033f9fded180627f04acf95f62b5a17abc12c7401e487f643f","impliedFormat":99},{"version":"c1a3ca43ec723364c687d352502bec1b4ffece71fc109fbbbb7d5fca0bef48f1","impliedFormat":99},{"version":"e88f169d46b117f67f428eca17e09b9e3832d934b265c16ac723c9bf7d580378","impliedFormat":99},{"version":"c138a966cc2e5e48f6f3a1def9736043bb94a25e2a25e4b14aed43bff6926734","impliedFormat":99},{"version":"b9f9097d9563c78f18b8fb3aa0639a5508f9983d9a1b8ce790cbabcb2067374b","impliedFormat":99},{"version":"925ad2351a435a3d88e1493065726bdaf03016b9e36fe1660278d3280a146daf","impliedFormat":99},{"version":"100e076338a86bc8990cbe20eb7771f594b60ecc3bfc28b87eb9f4ab5148c116","impliedFormat":99},{"version":"d2edbba429d4952d3cf5962dbfbe754aa9f7abcfcbdda800191f37e07ec3181b","impliedFormat":99},{"version":"8107fdc5308223459d7558b0a9fa9582fa2c662bd68d498c43dd9ab764856bc7","impliedFormat":99},{"version":"a35a8a48ad5d4aad45a79f6743f2308bdaea287c857c06402c98f9c3522a7420","impliedFormat":99},{"version":"e4aa88040fd946f04fe412197e1004fb760968ac3bd90d1a20bfb8b048f80ce0","impliedFormat":99},{"version":"f16df903c7a06f3edd65f6292fef3698d31445eaca70f11020201f8295c069b5","impliedFormat":99},{"version":"d889a5532ecd42d61637e65fac81ea545289b5366f33be030e3505a5056ee48a","impliedFormat":99},{"version":"6d8762dd63ee9f93277e47bf727276d6b8bdd1f44eb149cfa55923d65b9e36bc","impliedFormat":99},{"version":"bf7eebda1ab67091ac899798c1f0b002b46f3c52e20cccb1e7f345121fc7c6c2","impliedFormat":99},{"version":"9a3983d073297027d04edec69b54287c1fbbd13bbe767576fdab4ce379edc1df","impliedFormat":99},{"version":"8f42567aa98c36a58b8efb414a62c6ad458510a9de1217eee363fbf96dfd0222","impliedFormat":99},{"version":"8593dde7e7ffe705b00abf961c875baef32261d5a08102bc3890034ae381c135","impliedFormat":99},{"version":"53cf4e012067ce875983083131c028e5900ce481bc3d0f51128225681e59341b","impliedFormat":99},{"version":"6090fc47646aa054bb73eb0c660809dc73fb5b8447a8d59e6c1053d994bf006e","impliedFormat":99},{"version":"b6a9bf548a5f0fe46a6d6e81e695d367f5d02ce1674c3bc61fe0c987f7b2944f","impliedFormat":99},{"version":"d77fa89fff74a40f5182369cc667c9dcc370af7a86874f00d4486f15bdf2a282","impliedFormat":99},{"version":"0c10513a95961a9447a1919ba22a09297b1194908a465be72e3b86ab6c2094cc","impliedFormat":99},{"version":"acfce7df88ff405d37dc0166dca87298df88d91561113724fdcb7ad5e114a6ba","impliedFormat":99},{"version":"2fb0e1fc9762f55d9dbd2d61bbc990b90212e3891a0a5ce51129ed45e83f33ee","impliedFormat":99},{"version":"7be15512c38fdbed827641166c788b276bcfa67eda3a752469863dbc7de09634","impliedFormat":99},{"version":"cbba36c244682bbfaa3e078e1fb9a696227d227d1d6fc0c9b90f0a381a91f435","impliedFormat":99},{"version":"ec893d1310e425750d4d36eb09185d6e63d37a8860309158244ea84adb3a41b8","impliedFormat":99},{"version":"0d350b4b9b4fea30b1dbac257c0fc6ff01e53c56563f9f4691458d88de5e6f71","impliedFormat":99},{"version":"4642959656940773e3a15db30ed35e262d13d16864c79ded8f46fb2a94ed4c72","impliedFormat":99},{"version":"a2341c64daa3762ce6aefdefc92e4e0e9bf5b39458be47d732979fb64021fb4f","impliedFormat":99},{"version":"5640ea5f7dfd6871ab4684a4e731d48a54102fd42ea7de143626496e57071704","impliedFormat":99},{"version":"7f6170c966bbd9c55fd3e6bcc324b35f5ca27d70e509972f4b6b1c62b96c08ff","impliedFormat":99},{"version":"62cb7efe6e2beecb46e0530858383f27e59d302eb0a6161f66e4d6a98ae30ff5","impliedFormat":99},{"version":"a67ae9840f867db93aca8ec9300c0c927116d2543ecc0d5af8b7ab706cdda5ad","impliedFormat":99},{"version":"658b8dbb0eef3dcfbcaf37e90b69b1686ba45716d3b9fb6e14bb6f6f9ef52154","impliedFormat":99},{"version":"1e62ffb0b2bc05b7b04a354710596e60ac005cab6e12face413855c409239e9b","impliedFormat":99},{"version":"c92349bad69a4e56ac867121cda04887a79789adb418b4ee78948a477f0c4586","impliedFormat":99},{"version":"d49420a87cc4608acbd4e8ce774920f593891047d91c6b153f0da3df3349b9be","impliedFormat":99},{"version":"44376b040b0712ffe875ad014bb8c9f84d7648487cdf36e8bbe8f4888f860a03","impliedFormat":99},{"version":"4c704b137991192a3d2f9e23a3ded54bdb44f53ea5884c611c48637064e8c6cb","impliedFormat":99},{"version":"917af11888db0ac87046f9b31f8ccb081d2da9ba650d6aab9636a018f2d86259","impliedFormat":99},{"version":"d6c196e038cb164428f2f92feb0191de8a95d60aad8eb65bc703d3499d7ff888","impliedFormat":99},{"version":"b27723af585d0cf2e5f6a253b2989d084ba5c7ffe24130ab33d3c01f60f8f7c8","impliedFormat":99},{"version":"37f271a1de9b674667cffbd616832f4127c0a364d502b2b33e3e9c6b16fde1b8","impliedFormat":99},{"version":"0c796f53945fee54a07b295dbd1f1303c7a73cdd2c629e66fbfa5e29df16de9e","impliedFormat":99},{"version":"2b3045052668b317d06947a6ab1187755b2ad4885dd6640b6a8fe174e139ec5e","impliedFormat":99},{"version":"44ee21f3f866b5517804aadc860c89da792cca2d3ad7431d5742c147be7deb82","impliedFormat":99},{"version":"57bc6a334f498834fe779ea68e92a06c569e3b6757b608a092119589c34b7242","impliedFormat":99},{"version":"ccc8793b3493c8cf50af8e181da08e4e7ff327535724dfde8bf56249a385954f","impliedFormat":99},{"version":"c48b220c9a10db0df2d791b93d332575bb57033797da241c124f87c2171159ea","impliedFormat":99},{"version":"d1509856fe7e38720ef11b8e449d4ada04879e5ecfd2d09b41c2e4a07b3d8dd1","impliedFormat":99},{"version":"3883734e7cba8ceb7a314ca68c97ac3f69031a2fde7830e5b2e2339f10520497","impliedFormat":99},{"version":"54396051cf9f736287426d1f3c9ec0f8afad30a4d3e607f65ffd6205ec90bdce","impliedFormat":99},{"version":"4c5ed0d7c2b8dc59f2bcc2141a9479bc1ae8309d271145329b8074337507575d","impliedFormat":99},{"version":"2bdc0310704fe6b970799ee5214540c2d2ff57e029b4775db3687fbe9325a1e4","impliedFormat":99},{"version":"d9c92e20ad3c537e99a035c20021a79c66670da1c4946e1b66468ca0159e7afd","impliedFormat":99},{"version":"b62f1c33a042e7eb17ac850e53eb9ee1e7a7adbfa4aacf0d54ea9c692b64fc07","impliedFormat":99},{"version":"c5f8b0b4351f0883983eb2a2aaa98556cc56ed30547f447ea705dbfbe751c979","impliedFormat":99},{"version":"6a643b9e7a1a477674578ba8e7eed20b106adbef86dabe0faf7c2ba73dc5b263","impliedFormat":99},{"version":"6e434425d09e4a222f64090febcbbfbb8fb19b39cec68a36263a8e3231dab7ad","impliedFormat":99},{"version":"58afdddfd9bc4529afe96203e2001dcc150d6f46603b2930e14843a2adc0bef3","impliedFormat":99},{"version":"faa121086350e966ec3c19a86b64748221146b47b946745c6b6402d7ecf449d4","impliedFormat":99},{"version":"a9286d1583b12fd76bf08bcd1d8dad0c5e3c0618367fe3fe49326386fee528bd","impliedFormat":99},{"version":"141c5152b14aa1044b7411b83a6a9707f63e24298bfc566561a22d61b02177a4","impliedFormat":99},{"version":"dce464247d9d69227307f085606844dc1a6badc1e10d6f8e06f3a72d471e7766","impliedFormat":99},{"version":"26333aa1e58f4c7c6acb6cdb1490ba000c857f7e8a21608019ca9323ad97365e","impliedFormat":99},{"version":"b36269da8b9c370075ad842a17f7d284bae04bc07d743aa25cc396d2bbd922cd","impliedFormat":99},{"version":"1e5afd6a1d7f160c2da8ed1d298efcd5086b5a1bdb10e6d56f3ed9d70840aa5d","impliedFormat":99},{"version":"2e7c3024fa224f85f7c7044eded4dba89bf39c6189c20224fa41207462831e06","impliedFormat":99},{"version":"4ca05a8dfe3b861cf6dc4e763519778fc98b40655e71ddee5e8546390cf42b21","impliedFormat":99},{"version":"f96c214198c797da18198b7c660627faf40303ba4d1ac291ac431046ec018853","impliedFormat":99},{"version":"fa20380686e1f6c7429e3194dea61e9d68b7af55fa5fc6da5f1da8fc2b885c3d","impliedFormat":99},{"version":"d3a480946bced3c94e6b8ab3617330e59bf35c3273a96448d6e81ba354f6c20e","impliedFormat":99},{"version":"ff72b0d58aa1f69f3c7fa6e5a806aa588b5024d8bd81cb8314b6df32759cafdd","impliedFormat":99},{"version":"feccbe0137990c333898ac789870caf62bddf7b7f825cca3f5aac4388d867695","impliedFormat":99},{"version":"5d0b0e10dd5f4857dcf4703a4c86d92fe3e1d82a68ffc6739d777fc2ff6d6902","impliedFormat":99},{"version":"d002e1dad5ff22c6d7b9b4e8b09302b99fe6089f907e4e00310b1eea88d24a01","impliedFormat":99},{"version":"0497b91aa0292f7cafe54202e69cb467242426a414623aac0febc931c92b10f2","impliedFormat":99},{"version":"faf1f29f98e2a8db3737827234c5de88d2bf1546471c05b136578190ed647eb9","impliedFormat":99},{"version":"80634ab7f8f65c7b4663e807f8d961c683eaea3b0e58818524c847abb657b795","impliedFormat":99},{"version":"85e852e090c97b25243fb6c986cad3d2b48d0bb83cd1c369f6ff1cf9743ab490","impliedFormat":99},{"version":"12e856f6193309e09fbab3ce89f70e622c19b52cbeaad07b14d47ef19063e4dc","impliedFormat":99},{"version":"d3f4fda002f6200565ef1a5f6bcad4e28e150c209e95716e101d6c689ae11503","impliedFormat":99},{"version":"497a791143290119136bfcde6cd402e3b7d211df944188d1a4a511b8df5a9b13","impliedFormat":99},{"version":"1cb9dab41d415a2a401d52c6bede4ad5aa14a732b2914c01c16cc8b0fc69cf88","impliedFormat":99},{"version":"617108f6e6514fbfa7bf226cf99c33c8872a28517f5b7e855c657d4132afeb3d","impliedFormat":99},{"version":"194823a242a97327f6ac0af92f3d37fc078d4773149724fbb5176093eb7b0617","impliedFormat":99},{"version":"085f9e9b8f27c4833a6cf9228b1ae26d383bf7eb4e0677b5321029564336deff","impliedFormat":99},{"version":"34b81ae7140be9b70a7dfded8acebc06d62c5508617b196739e578595949724d","impliedFormat":99},{"version":"c7631702b00fbbac3682deeeaeaac4bfc0694bec74dda8db4afae1098310e18c","impliedFormat":99},{"version":"b0c04f92ff4c9da466ba563170892afe043ecd0f088deb3d3dc482a747d75bf0","impliedFormat":99},{"version":"c4d6664fa99f28b210a65e5feccc41723bf77d89e5f00afdbdaf25726a9ea4c3","impliedFormat":99},{"version":"f4940ce6889056747592fc93a331d7e33db8889d48e401397cfa15fa27ac4000","impliedFormat":99},{"version":"2e3ae7d41b13b4ebfdf76eb20d4282b72b4eafb9b75b0f850177d03e92f59d7b","impliedFormat":99},{"version":"e37392287850bebf777be5e4b573ef447b3437bf46f85969f9d9b4b37b7a8629","impliedFormat":99},{"version":"68771841743fe93f5732c94a93447cfc2ebce7de956330fcb704e82725f218be","impliedFormat":99},{"version":"6e58d2b1619cb5b2312a57fb1a0071f693ac0c7547f12d4e38c2b49629f71b9f","impliedFormat":99},{"version":"8363077b4b4520e9cfff74d0ae1d034b84f7429d35265e9e77daedeb428297f2","impliedFormat":99},{"version":"541cfa49f8c37ea962d96f4e591487524af58bfbf4faf45e904a4e1b25b7a7aa","impliedFormat":99},{"version":"ebb09c62607092b0aa7dbc658b186ee8cc39621de7f3ccf8acbd829f2418d976","impliedFormat":99},{"version":"f797dc6c71867b6da17755cfdbd06ef5ed5062e1b6fd354a07929a56546d4f4d","impliedFormat":99},{"version":"686bd9db685be2e1f812cf82d476c7702986ad177374dad64337635af24a0b9f","impliedFormat":99},{"version":"cc8520ff04dae6933f1eec93629b76197fb4a40a3a00da87c44e709cfa4af1ba","impliedFormat":99},{"version":"55880163bc61bc2478772370acce81a947301156cdce0d8459015f0e5a3f3f9c","impliedFormat":99},{"version":"d7591af9e3eee9e3406129e0dacb69eb2ac02f8d7ceb62767a6489cb280ca997","impliedFormat":99},{"version":"522356a026eb12397c71931ff85ce86065980138e2c8bce3fefc05559153eb80","impliedFormat":99},{"version":"1b998abad2ae5be415392d268ba04d9331e1b63d4e19fa97f97fe71ba6751665","impliedFormat":99},{"version":"81af071877c96ddb63dcf4827ecdd2da83ee458377d3a0cb18e404df4b5f6aa0","impliedFormat":99},{"version":"d087a17b172f43ff030d5a3ede4624c750b7ca59289e8af36bc49adb27c187af","impliedFormat":99},{"version":"e1cc224d0c75c8166ae984f68bfcdcd5d0e9c203fe7b8899c197e6012089694c","impliedFormat":99},{"version":"1025296be4b9c0cbc74466aab29dcd813eb78b57c4bef49a336a1b862d24cab0","impliedFormat":99},{"version":"18c8cf7b6d86f7250a7b723a066f3e3bf44fd39d2cb135eaffe2746e9e29cc01","impliedFormat":99},{"version":"c77cd0bddb5bec3652ff2e5dd412854a6c57eaa5b65cbf0b6a47aae37341eca9","impliedFormat":99},{"version":"e4a2ca50c6ded65a6829639f098560c60f5a11bc27f6d6d22c548fe3ec80894d","impliedFormat":99},{"version":"e989badc045124ca9516f28f49f670b8aeee1fb2150f6aefd87bb9df3175b052","impliedFormat":99},{"version":"d274cf19b989b9deff1304e4e874bc742816fca7aae3998c7feec0a1224079c7","impliedFormat":99},{"version":"0aefb67a9c212a540e2dedb089c4bbe274d32e5a179864d11c4eea7dc3644666","impliedFormat":99},{"version":"2767af8f266375ebd57c74932f35ce7231e16179d3066e87bcb67da9b2365245","impliedFormat":99},{"version":"34a1c0d17046ac6b326ed8fbe6e5a0b94aeef9e50119e78461b3f0e0c3a4618a","impliedFormat":99},{"version":"6fd58a158e4a9c661d506c053e10c7321edaa42b930e73b7a6d34eb81f2a71e8","impliedFormat":99},{"version":"60e18895fc4bff9e2f6fb58b74fcf83191386553e8ab0acc54660d65564e996c","impliedFormat":99},{"version":"41d624e8c6522001554fdddef30fed443b4c250ec8ddbb553bbe89e7f7daf2f4","impliedFormat":99},{"version":"b3034ec5a961ab98a41bc59c781bf950bb710834f1f99bf4b07bfbba77e2f04a","impliedFormat":99},{"version":"2115776fcd8001f094066e24d80b7473bbc2443a5488684f9f3a94a3842daadb","impliedFormat":99},{"version":"55e49ce04550294b3a40dcd9146d5611cfcd4fa317eb2dcb2c19dd28dea09f58","impliedFormat":99},{"version":"96149ea111d0a0017b95606821a16d4a1cf2470f1460549ba65ec63bf9224b5d","impliedFormat":99},{"version":"5b290d80e30d0858b30aab7ccff4dbfa68195f7a38f732a59cfe341764932910","impliedFormat":99},{"version":"a85ee477d4e97c2bfae6716b0faaaacef6b4f3de64e0b449c0347322e92a594e","impliedFormat":99},{"version":"8c11d3a3eac4c18abf364d20dde653c8b4d3c3ad85bb55da285209140dae256c","impliedFormat":99},{"version":"262fcc12bd0cb2fe7ce2115093ae2b083cf425329b7966d8857af78e1e33814d","impliedFormat":99},{"version":"24f4daf278786772d9cee29876e85f5f6712c65b741b997a900b1d942c8f217e","impliedFormat":99},{"version":"a2be1e277d805c54f038fee25fd291b5fdd76990be855454bd48e336b315fb8b","impliedFormat":99},{"version":"dce9350553d244fa5ad6cff4e9aea3664d918113ddff74ef84210b0481b79f74","impliedFormat":99},{"version":"8802c923b63c304b8e014600ff58fb9542323e842701aba9e69df60c7c979df5","impliedFormat":99},{"version":"b5a14e52ffa8efd7e31e7856bbf36a7bce32446283a9b51e0a819b04a94f2ce4","impliedFormat":99},{"version":"9cc999adecb60f81915c635cc91acdb0b79904370653acc283b97656b5b2cfa8","impliedFormat":99},{"version":"80249dc33a16d10faf6ec20ea50d4c72b0d92e55070bba0327de428e1d0979e7","impliedFormat":99},{"version":"7367f5f54504a630ff69d0445d4aecf9f8c22286f375842a9a4324de1b35066f","impliedFormat":99},{"version":"0b86afbb8d60fd89e3033c89d6410844d6cb6a11d87e85a3ef6f75f4f1bae8a8","impliedFormat":99},{"version":"9cfb95029f27b79f6c849bbb7d36a4318d8acf1c7b7d3618936c219ad5cddab7","impliedFormat":99},{"version":"2a4181e00cfe58bdce671461642f96301f1f8921d0f05bd1cc7750bbf25dd54a","impliedFormat":99},{"version":"24e33e2ece5223951e52df17904dcc52a4022be3eb639ab388e673903608eb37","impliedFormat":99},{"version":"506eaf48e9f57567649da05e18ddd5e43e4ad46d0227127d67f07152e4415f29","impliedFormat":99},{"version":"9e5247c2cdf36b8c44d22caa499decd252577b8b5f718b498f7a8b813d81a210","impliedFormat":99},{"version":"69abcf790968f38d1e58bccff7691aa2553d14daada9f96dcc5fe2b1f43762c3","impliedFormat":99},{"version":"5e88a51477d77e8ec02675edf32e7d1fccdc2af60972d530c3e961bd15730788","impliedFormat":99},{"version":"0620fa1ded997cd0cdc1340e9b34d3fe5e84f46ba109b4a69176df548e76081c","impliedFormat":99},{"version":"8508ed314834f8865469a0628cc8d6c31bf5ea2905f8a87f336a2168e66f91f4","impliedFormat":99},{"version":"9757602b417a9364a599c07507e8c9a4e567f78829eeb03a7c64b79ffb16caf9","impliedFormat":99},{"version":"e0bfc7204238bd5b19f0b9f3cd8aa9e31979835772102d2f4fa0e4728140bdbf","impliedFormat":99},{"version":"070ff67371e23b620cbf776e08881a3d1ff6cdf06c1cf6a753fb89b870c6f310","impliedFormat":99},{"version":"d2e8a7070ff0c6815be4ccca5071fe90d7923702e6348fa83275b452768f701a","impliedFormat":99},{"version":"63c057f6b98e622b13aa24a973bbdf0fef58d44e142a1c67753e981185465603","impliedFormat":99},{"version":"2b857bdc485905b1be1cee2e47f60fc50e4113f4f7c2c7301cdc0f14c013278e","impliedFormat":99},{"version":"4abccbf2fc4841cf06c0ff49f6178d8f190f2645acda5d365e61a48877b8b03e","impliedFormat":99},{"version":"b4ababf5c8f64e398617d5f683ad6c8694f19f589485580623a927121cfab64b","impliedFormat":99},{"version":"f856d3559afde2a5e3f0e4e877d0397fe673eea71ac3683abb7c6cef429c192d","impliedFormat":99},{"version":"8148fe494a3556aec26a46b0deba7a85d78883b285e408ebf69ff1cfd1531c00","impliedFormat":99},{"version":"0942f7d40c91c30a5936d896de2194238ad65a45e7540bab7f7f588b70242bb8","impliedFormat":99},{"version":"b808dbc3d555d643bd6410da582c2d7512b39dc8331acef7d4752fff0f390b5f","impliedFormat":99},{"version":"65971cd38702bdce2440a7322eccccf978a37e481b44e22dd0b34aee30e0b6dd","impliedFormat":99},{"version":"c6f038949f364df4f690cebfe93324f54d53c9c50aec6c8e5508b7f6a6ea4df7","impliedFormat":99},{"version":"58a0bdd8fa7be3a362ce850e4af11c7a4f82abcbfad36201463f7b28ebf53e7e","impliedFormat":99},{"version":"cc9f07af7679c686e5e68c3933a4430af6ea651ed0c1cfcf0db7c60576d05ccc","impliedFormat":99},{"version":"d45698ab81cc9a9722ec492e7442de1136be3c2a5c830b7c700c3cae020bbf70","impliedFormat":99},{"version":"18441c1a35fed75775881c3b918c3ea4a630f02e43c8179225a268055907b140","impliedFormat":99},{"version":"bbe0ac66e24ba0c5d30dfc8f0579e3c660f8e1f3b8f234c7cbdd9fd2db9ed22f","impliedFormat":99},{"version":"63e65622cd147ea99f39f8833c65d7c2b7a0595c86ce71e92e04b07d1f38d3ad","impliedFormat":99},{"version":"6a840e9604c761dd515f8c76ea08c648beed01129b75133e0d54e24372802302","impliedFormat":99},{"version":"7b853ab7e6a660ca2dfdc36eff9d3cb5215b3e10acbe65a09ed6d9be52c38d9b","impliedFormat":99},{"version":"cb1f24cd504d21fe92ea004fab2b3e496248b4230c3133c239fbc37413a872b7","impliedFormat":99},{"version":"d7ec8da78b951af56a738ab0586815263a433ef3517c4e3ea6aad5dfd65c4a04","impliedFormat":99},{"version":"6adb1517628439ae88aeb0419f4fa89eacda98f89791fcd05fa92ad2cdc389af","impliedFormat":99},{"version":"87e256c8149c5487ef2c47297770c4e0e622271ac1c8902dc0b31795062a1410","impliedFormat":99},{"version":"99c98d7abbf313f8978c0df4fae66f5caf05b1e7075a2a3f0e8cd28c5abb56d2","impliedFormat":99},{"version":"3d7c052002e317d7ff01dbe4c6cf82aa20b6ef751101139c38c547636d872ffe","impliedFormat":99},{"version":"353fd6acf4bc2232c850bcf24fa6512a85517623f84dabe4dc4a22fcd0a69f00","impliedFormat":99},{"version":"f9c4bdf33b97ce2f7c4fa422c32ce85f8f4cafa4421e02172279ee5ebd097804","impliedFormat":99},{"version":"1f098514ce3fb820e89bde510a34b939f281581a7c1e9d39527ec90cec46f7c8","impliedFormat":99},{"version":"54b21f4fe217619f1b1dc43b92f86b741c55400b5f35bfd42f8ea51b2f6248a1","impliedFormat":99},{"version":"48d9c8e386b3ba47dd187ee4b118c49d658cdac580879984b1dc364cf5a994ca","impliedFormat":99},{"version":"b69cecaec600733bb42800ac1f4be532036f3e8c88e681f692b4654475275261","impliedFormat":99},{"version":"bb8e4982de3a8add33577b084a2a0a3c3e9ebf5a1ec17ddfe6677130ec19b97d","impliedFormat":99},{"version":"5a8aa1adc0a8d6cf8a106fd8cc422e28ca130292d452b75d17678d24ab31626b","impliedFormat":99},{"version":"f4d331bd8e86deaaeedc9d69d872696f9d263bcb8b8980212181171a70bf2b03","impliedFormat":99},{"version":"c4717c87eecbb4f01c31838d859b0ac5487c1538767bba9b77a76232fa3f942e","impliedFormat":99},{"version":"90a8959154cd1c2605ac324459da3c9a02317b26e456bb838bd4f294135e2935","impliedFormat":99},{"version":"5a68e0660309b9afb858087f281a88775d4c21f0c953c5ec477a49bb92baa6ec","impliedFormat":99},{"version":"38e6bb4a7fc25d355def36664faf0ecfed49948b86492b3996f54b4fd9e6531e","impliedFormat":99},{"version":"a8826523bac19611e6266fe72adcc0a4b1ebc509531688608be17f55cba5bb19","impliedFormat":99},{"version":"4dc964991e81d75b24363d787fefbae1ee6289d5d9cc9d29c9cec756ffed282b","impliedFormat":99},{"version":"e42a756747bc0dbc1b182fe3e129bfa90e8fb388eee2b15e97547e02c377c5ef","impliedFormat":99},{"version":"8b5b2e11343212230768bc59c8be400d4523849953a21f47812e60c0c88184b3","impliedFormat":99},{"version":"d96b4e9f736167c37d33c40d1caae8b26806cdd435c1d71a3a3c747365c4163c","impliedFormat":99},{"version":"363b0e97b95b3bcc1c27eb587ae16dfa60a6d1369994b6da849c3f10f263fd04","impliedFormat":99},{"version":"6c7278e2386b1993c5d9dfa7381c617dc2d206653b324559f7ef0595a024a3da","impliedFormat":99},{"version":"f5d731a9084db49b8ffd42bc60aecb28f90966e489261d7ec5f00c853efc3865","impliedFormat":99},{"version":"4dcc76850d97256f83a7d45b40327725db3aa7ee02dee3b1e860ca81ce591694","impliedFormat":99},{"version":"70fa22a23b35e04482f13ab7f697a057506503e21ced87d933359e3224c92ed5","impliedFormat":99},{"version":"709622bea0f7188c66bcee996bd4f24221c69d67e1d04797a11ebdd1311096cd","impliedFormat":99},{"version":"e8ad189c7d2932a01feadccefca9c873bee40d202fb53f708f1e7b1efce4ffef","impliedFormat":99},{"version":"ed3dbe543bbf46c4365e3eb5faa3fa87f0fe0c3db4b2476b8f430838432e2b8c","impliedFormat":99},{"version":"1ad2f20d17cad8ed17df10daf3f9050161fd42a86d5b7afd0a1dacac216e9c14","impliedFormat":99},{"version":"4e6502d4dc180cdff48d77f6ee04007167bef42f7b5488dbadedb0ddb1e9cdf1","impliedFormat":99},{"version":"e41e03387b7c74aae146473ff507c26b07699cfcd953f79dd174bfd624bcb5d0","impliedFormat":99},{"version":"ff671a3c1efcc1a96ca6f418c7a9616ae4a4c6110ece811fc1ec8013a3a24e6b","impliedFormat":99},{"version":"a105278208759f167642ea5b37b78661edf4b0350824ad2f961a329e5976b9b6","impliedFormat":99},{"version":"6f9a389203f44e1c344e5e5d8c0ddad05f0f2e033d0657297894cd8e6ca4747f","impliedFormat":99},{"version":"636ddb4225f892b1033182ae24af259fe30d5209a2b9e69d7374c3268818b9d3","impliedFormat":99},{"version":"c00c3b2b915c5cd789a78f86c98c211c78646872ed84ddc478994e97c6560a0a","impliedFormat":99},{"version":"592640ac835589f476f9cefbffdfeef79dc327bb9b25c0a3f92549fcd8e8c514","impliedFormat":99},{"version":"24033c6280d58689e7cdb5af09e2766c6b44a3747dbb0d844f155bd0621024f0","impliedFormat":99},{"version":"1914db9d25d18ff046611a41a8129ad01c829d5f9565f16660c7d09c66f776c6","impliedFormat":99},{"version":"054c4bef46bc70b9fbb18481f501bac861cd54af683fe5942e5c7e7d3b0c1fb5","impliedFormat":99},{"version":"d6ce9fe8c2849756dae3c9e11de07966bb58b6638a462098a3a1b23d78b56ef0","impliedFormat":99},{"version":"0f149ffde075123eb05b9aefdd405d5dc1acd729f94b3dedaf9f48d9fbbe2348","impliedFormat":99},{"version":"193a5fc1bfbc703c3772e05dfffb1c821ef30bb2d787f906fc26c38718bb35bb","impliedFormat":99},{"version":"dfdc408e78629b12771eca9a58edbeeb2f4783e79841368a069b8eb65ce447ce","impliedFormat":99},{"version":"513601842e2f161c0e7c3bc35c433f793f338b5d7d0465423d071486f43b65e4","impliedFormat":99},{"version":"5270479971ab757c197fa22d4eb07bf7bfc886440a76da240e095d5ffb2e95bc","impliedFormat":99},{"version":"8f5d63fde9f0ace19cfcec1a2bc4bc0efec47b89465216817204448dc6dfd5a2","impliedFormat":99},{"version":"65323bbeb0b10634c92484812f6a0020d3ca38a888c2a536962b425cb77d8e77","impliedFormat":1},{"version":"767183261649b963ccc7daa3d2ae38cc604ce60fc3a453a15a8afa9a4daba71f","impliedFormat":1},{"version":"5fb2b92475a3963e7b4ee8152cc6c3ae066081364b4abaeea695a5001db32e63","impliedFormat":1},{"version":"890d6c959fe26e8bd017bbb9b25623c227368fa1983a8966055c960b14de1452","impliedFormat":1},{"version":"4b5ed80412f64641dc5caf5af1c98d8083315bcf5f4d9bceea7b6aac4a1b865b","impliedFormat":1},{"version":"81957f051f71d2f4b0b20fbe8bfc40cbaa4d9a441ee3af3ec82646a96076429d","impliedFormat":1},{"version":"e4630dcc04c04cfed62e267a2233cae1367a7366d5cadcf0d2c0d367fd43e8d4","impliedFormat":1},{"version":"f7f13164c6c9b9e638ac98ffd06041a334cb20564d24d37185e29408d00cea8f","impliedFormat":1},{"version":"eec0d8defb7ed885473e742b9298a2f253f2113688787c2495b4f8228bc22590","impliedFormat":1},{"version":"de2cddc05d2aff0460f1bb27f796e9134b049e4fab33716b4d658628e0976105","impliedFormat":1},{"version":"4bd3e56fca57ce532152c64036a2153d61f2c1acfc27b4d679b1f4829988b9f4","impliedFormat":1},{"version":"7640a64392d0920c04d091373eb8ca038d6e80cc5b202bddcb0ea0937f90def4","impliedFormat":1},{"version":"ec817057681d50c1c0d2a3c805aee50e6df7c51c60484fdf590c81b9a5001931","impliedFormat":1},{"version":"bf6c2b7d7ef94e5d5add264d87aa2321e2e1d875d74e2ff1a5870b3fd0fa4506","impliedFormat":99},{"version":"da85d4bf5436447eea22ed6404226fa97f44ae375559ac97b5d3d5d86c1d5b72","impliedFormat":99},{"version":"e86e6db08b9106c95115542563d5a49d20447cf08cd2994dbd86c1896c49dc08","impliedFormat":99},{"version":"c3bbaa7348f9e5ca7e7c67c18aa0db9cfbfb1485ab4c13b73e8e0a15766b99de","impliedFormat":99},{"version":"338d21e6e39eac5d7df7fbad9179a489c4689471775cedc24a4eacd2b4acfc97","impliedFormat":1},{"version":"71c894f7dbb289f6b9907e4d70f0ccaa746be732a7d65354e6bcd23405fcc1e6","impliedFormat":1},{"version":"0cb45071af866142b4198636d458bd6d2f564b7d79896907a75b01d66c135625","impliedFormat":1},{"version":"e151f7178771544d572824da291a8e2c45325c0cc2dbfe513de06c9d3cf771fc","impliedFormat":1},{"version":"16d707a765a9a3114e9911c1a57634fb3c90d678539c2d6d793c30cc87e759f3","impliedFormat":1},{"version":"4ce2e4991a21c8e6a98905d0dc3a9efaf75e8e8812a2b930f77ed8aa4435784d","impliedFormat":1},{"version":"4b86cb06a21c36b5ff47731a046e0109cb41d540e17215b8f95829e30da1bb94","impliedFormat":1},{"version":"7cc83c9b21c59ab3b08196adbeb13d999e16c56a5bbf89864d6e01cc1a6e6204","impliedFormat":1},{"version":"102334bccff335c3ef1c556fabac2c2f12bf93ce1a5cd8ce826ed188707496ed","impliedFormat":1},{"version":"c9144f4f50f868501918f526697deb558eb9d82bcad179b3807609246ba6b32b","impliedFormat":1},{"version":"8bb219fc6b96eb8fee00d73aa6e570b01885a01be42f2b85d93a1fa102f52ccd","impliedFormat":1},{"version":"fcc36716f4a5bb4ac1babbd30a3c55483def152357c0d17c570ecc406ef8f159","impliedFormat":1},{"version":"66c695ccbaa50b938c0e058b28b3a004fc8954e7e0f7f01177bae4bb8e92cc0f","impliedFormat":1},{"version":"6e01462f84beeb73382f987fae1bc554f0ed6d9f70056106f417a9f6088bdbc5","impliedFormat":1},{"version":"1b46f9a444f79e8aaa88e9c7ccff9f131ab101015b8933ea3a8fc7cc2021adc9","impliedFormat":1},{"version":"7749ee7c2eb72db8f09271082b925580321c546d8b2aef68960f3f4bf483d454","impliedFormat":1},{"version":"3d77e968a4a37fe3857daf2227ccaa7efb978830a6873de10d6a887daabda9cb","impliedFormat":1},{"version":"0ee14e6d06ffdcc74c5fc496224c15e6275bda1c413ffc86b0ad19d1452898a6","impliedFormat":1},{"version":"b10364cad5f3ba55bb99c69d21eb4a0df657c7a36027a2618f8739ed69142570","impliedFormat":1},{"version":"c7c4c05e6788ee40a4f1e374ab1355d3a8dcd1c947afadc8ac1dfdd0bb0ea41b","impliedFormat":1},{"version":"0a5e955193cb8aea98e00bf54042651f8c8b9b00c87337ff3c0ce8960345b5ba","impliedFormat":1},{"version":"5ad71db5434af4e0d796a387bb7f4b7c1837199b866723921e5bd67fb01c2f0f","impliedFormat":1},{"version":"212318bbf00acfc4451a1eec1f9f6f91918427d7dc71717f7dadcb84b6ad2190","impliedFormat":99},{"version":"b1a02c272b834972bef5cb8d9c79acb0352966ed5ae3a37482cec39da5e51276","impliedFormat":1},{"version":"25197fdcec1f0b168131c901881f9689b950c546a8d5d3620a9028765e9c91d8","impliedFormat":1},{"version":"c2a5d0ee3f7dd09d0741ba10eb9d07ccc714ee5f7fad3e550fe8ad99eedda1a5","impliedFormat":1},{"version":"81af227428e65ccfec74d0e439a810fcc2f33f3fa0e74730d486edf14ad2e367","impliedFormat":1},{"version":"2e6b2ac20f09b0351d256155e9b8d8854434ed9a01ba7e55a87a5d13e4365f63","impliedFormat":1},{"version":"3b0b108ad2bfedd6aba6c50b5b6aa969a75644935e40a749ecc2d28de9d9e788","impliedFormat":1},{"version":"221e3b82ae572a418be0a8e112681c64aae84166f2c25f4fd39297d0a6958b92","impliedFormat":1},{"version":"8a5fea1b0a68c64d9d830e878ea4e81efac6be802b4af1aa29cdfaad9be210f0","impliedFormat":1},{"version":"367fd06f031fee62713fa846885d31c8cfa8101b7e3ab129f1d89d9d5e719124","impliedFormat":1},{"version":"7163a9b5ad66c4e388aaeb18acf502e7c5afdbc52cb163bac5faf5d140abedfe","impliedFormat":1},{"version":"a9347756f992e52cd1ad3a5a7f35f3176e05795f44f4299f2809f5458699981a","impliedFormat":1},{"version":"853bece6815b265980b443f83d4ed245ffcccce293aa60dc1bce18aeaec827c8","impliedFormat":99},{"version":"dd6585c64a7e2247adc774fe92a3c5bebac28af2c1bc06bbdafeb58a2813d725","impliedFormat":1},{"version":"e0feff26b376e6eda473fea2273a6e96c5b380276a9ad9d3730cb607a0bcf1ce","impliedFormat":1},{"version":"4a286cb32756749c240e70cdb3e751b676fd0305f9d35928e3d3976e0d3c39b1","impliedFormat":1},{"version":"5b9716db2e3ca48d084e8baff9e2db5b2824ac7f7413e001dc33976e9f8e9636","impliedFormat":1},{"version":"a678ccb35281041ff3ed9179fdbbedac94d8642b3efdff5dfd8e1d803ad1f193","impliedFormat":99},{"version":"dc62e0d530ec9d6b960e09c39f3eb0e1f0384511facc30f07e441b0abef2c5c0","impliedFormat":1},{"version":"9da9c5a6b9c0020c1e8f2d087168d2ea5d43ad70fec8d8b31be7db2e2296ef55","impliedFormat":1},{"version":"690bc2bd40e8d87f033168d99e4cde82607b8e0a181163350e7de07ccc98f5b1","impliedFormat":1},{"version":"4619bbac2522271def9ec6d67b1b421a8fe4b85a90bc2f92ddd8f4b7a08f728e","impliedFormat":1},{"version":"9019d34b102c683cf2810e38477cd5e8964e46a15870abcd27c108c31d90970d","impliedFormat":1},{"version":"dd0b8ff0d6d5922e247969e6b3df41cae2d7294d000b056f9f93eda3e5bc31f9","impliedFormat":1},{"version":"b53e04ce667e2497d2e1e5826eb739840b6d83e73abeba7d267416990cf7c900","impliedFormat":99},{"version":"466d30b0f75773a2677ad69bc7d94facb224e061e0276c18b22a50d922e7a6be","impliedFormat":1},{"version":"858520cadc012c1c8ff47ddc61686f50f4ee52c9b87a7c10b8fb84b60ababc32","impliedFormat":1},{"version":"09e286c715f875d3772a8c196677934495eb7cc0b0222ddbf6756f4f3c57830d","impliedFormat":1},{"version":"f45c90fb3bc0f1bc18aabaeaf52747c633152994792d6c119ddd7d29e9d53414","impliedFormat":1},{"version":"29b553ef6920613307fa4edbd656a105bf159c7db2438fd84fe624a4ef6fc491","impliedFormat":1},{"version":"a69b64cc44b49bdadaa0de322b4b347b16fcb9c7fc08029a0372a082cb0f4467","impliedFormat":1},{"version":"7596bc71c0939bf0b534c1ead88b0c13c6ce7a8ffed9e47fd176036b3a464062","impliedFormat":1},{"version":"51cafc266445e20b92529192d8eb0ff3385ac1bc44fe125e84561563f338ec80","impliedFormat":1},{"version":"86a9434282d3ac8a6438ad0d6bec7f9e6463106edb2dc63c26a9dc63a6050d24","impliedFormat":1},{"version":"c16cffd6aa4a2c0701bd16332f4dfe6517a17f770f00218867d1fd4b13617fe2","impliedFormat":1},{"version":"ff1e570657ad6fb9247c2d7160d8c318796b88ab5db739336515fb04547a2d20","impliedFormat":1},{"version":"2ef29f5b7766615f2dc6b2fad24f5ce9e64204f6bdc035f3c9f90ade189196b5","impliedFormat":1},{"version":"ff4a940841cc11f423a911011edef12b47541e48c02cd5be4e8aa0addb0cf3f7","impliedFormat":1},{"version":"2ce39f6923be247a53eb5ea78ee1b5df3be8086253b8dd70be2584f5d8c2537a","impliedFormat":1},{"version":"bac47ef1b5d6cbf8c3e80f672e8f9ecf1cbab10da5fd25b7f228702306fceff8","impliedFormat":1},{"version":"3ef21503ad78f542c2efbd785f22a8c77e3798a2462be8a25a806937d4d85a3a","impliedFormat":1},{"version":"bd1ff4e0676496bf4f98f4f3ee31765bb49339aafa8b076952ec27cb041db0c7","impliedFormat":1},{"version":"5b89a6e06ccb15548326fac4c3ccb65892d8b10cf52fccb2867d0eb9a0b27bfd","impliedFormat":1},{"version":"2aba54f9c5acaf97b2f54e15dd52b88a26069c04e40118c5c1b4e1c7d0b13704","impliedFormat":1},{"version":"22b47c263603277f4caae17f9b5aa564f600a9b770f05920e68bee09394e2178","impliedFormat":1},{"version":"bdb92c931b192ef315b53cd48aa02e4398c251a8ea8800492cf0f43cb038ba28","impliedFormat":1},{"version":"eb37622408d5a60a38a9141acc5ce584f031df61fa67eeba98d495704fa14ddd","impliedFormat":1},{"version":"d787f15bf7abaa3a0d38c657e4281b13f86cc38b8845094a6977d583a9347ea2","impliedFormat":1},{"version":"8cb8894f63c1636f90fb7730fe50e421cdf56c779d0ba298010f0be89022cd39","impliedFormat":1},{"version":"749fb78249cdfc1fbb9ef8cef948a13f85f9942ca5489f1468736922500d78e1","impliedFormat":1},{"version":"30fd5d3577a7e58f873b83049dfbd2f173c350851c17b1e9a4b0878020626b97","impliedFormat":1},{"version":"66231c5bc015e15786504a220d622ddc6aac651b2a49f9cbf3fb945e27e733cd","impliedFormat":1},{"version":"819175b71a0809ed8bd0e76470a5e1deac5e02897862d4b633c17238ffc22b97","impliedFormat":1},{"version":"5426089e9fcec830597afd777d68bfe372de694dea4a8e7e68e3ca28acc8a6db","impliedFormat":1},{"version":"8e302e6fa5c43ca2384fe54b39fbdf0c320224a6919d71da5efc423366551314","impliedFormat":1},{"version":"fdc1bebcfdb5da0d3db8b11a94e68e0f40aff9f126ba06512c74e83cbab03a03","impliedFormat":1},{"version":"9139c1f3d72a1419734da74c4cbed997d073dafdb8fba63f9088a6fce6f23c99","impliedFormat":1},{"version":"79314b827217deb6d8518be67e201505f4da047bfd8fee11457f997403e0e7e9","impliedFormat":1},{"version":"5e788a039b7435497ef94c30ceff9f92ae097522e53ee75652407f1fba79579d","impliedFormat":1},{"version":"8782f99016b5b587eeb2e57c913a0a9470200941afda788224ce960fae47eeb4","impliedFormat":1},{"version":"c471dc722410fa62a4ff2c7f033cc15814087f5b445b5e9fbda596cd4c228a2e","impliedFormat":1},{"version":"0548857ee66b6fad6f26fdfaa76ee25334fa62454997c3a954726c166deb6a5a","impliedFormat":1},{"version":"a1ffd087cb5a5f76ff56226148d0acf8d223a9474eaf9d97dbd45fa6a19c1e58","impliedFormat":1},{"version":"cc5f3ec646bf93a7f13e27a9bb72f42b2a094a551a015296361cfe7f0d4350d2","impliedFormat":1},{"version":"f9e8a5ef3b0cbc104b6e66b936e5e76119630186ede7d3bef2cf53df506ca5a6","impliedFormat":1},{"version":"3644cfe268c1fe7de7b18619b385f8fdae10531ebd0ea4193ca6ab8bc8175e72","impliedFormat":1},{"version":"a05cfa018e37d5f3a5f39773145e5e77d18f32819ba3e115cd49b468f3ac139e","impliedFormat":1},{"version":"e2ecb11f739a7f3556659fee61d144d3ca1d715436ceb727f5701cd12461a65b","impliedFormat":1},{"version":"6ec1463df8c2070371669bdaee719272607903467a19f9883348166b50af8d54","impliedFormat":1},{"version":"cc08bd4e50ec465e694826816b4797e6f6a4a5211e98bb76bb05342439c7ce38","impliedFormat":1},{"version":"96cfa668e8ad2f88bf255184086129046467ff400f678de888c2cddf82b999ec","impliedFormat":1},{"version":"8d27a16268750bef7f8f2816fdcb28a9500fb9e6ba5a1e5981a053d35b416c3d","impliedFormat":1},{"version":"d90ff671df07b5dc26709a9ff6688a96fbf467e6835bee3ad8e96af26871d42c","impliedFormat":1},{"version":"7a0555e1186c549e113b9603b37994dbdb9b0aea18c1ebaccbade9fba289d260","impliedFormat":1},{"version":"ad1eab49ed8d2c7027c7d5b8333217688ef1bf628c6b68ca7674329c262433c5","impliedFormat":1},{"version":"c8d412a9b07756667bf4779a960226b71418a858cb6801188992f4e9ed023839","impliedFormat":1},{"version":"7801e1a8f4396ec3a8eb0fae480baf1fe9ea036a5d68868337a7bcc50bf769e4","impliedFormat":1},{"version":"9dfbe649c60c743bf0cbf473639551cf743a1acdead36e3d66a8e3feee648879","impliedFormat":1},{"version":"c214b33fb74b0ea35c672b1923e51ab30a1e3e8f876a09e94148a35f3cd2f5db","impliedFormat":1},{"version":"e3846aa20e866fce307a39d7efc4e90eef08ea0884b956738458fe724684e591","impliedFormat":1},{"version":"c19feddfc23f04fd9cda6b24568894eb79852a26b3f9733cc0472b91bfc1c0a1","impliedFormat":1},{"version":"9ac8b88f902bd4c2212ae16b11d26421e50669f0a0643586083281176f9d9132","impliedFormat":1},{"version":"5180e5bae39bbb8baf8aeba9100814e4f4d017d41638a4e609ca5c3ce83993ea","impliedFormat":1},{"version":"b69e0431f9b7f6e6c5f0754e8a3dad3f263684ed4c7406d4be7649eeb7d9af27","impliedFormat":1},{"version":"a10e2f2466f0ed484ef74a385bfb5e63f2b202d51dbf1bb4c51c294a70ba92ca","impliedFormat":1},{"version":"5347737b57f1c1cce11c140228c4e4068eca4c2435b1e4beb4d46e60c5d5e55e","impliedFormat":1},{"version":"631b3d9fcc0fd5e08affcdb01b76f5d34e1f1c607031d03a6d621cf2aa63b2e8","impliedFormat":1},{"version":"ef7ee4e86977bf10f68dc2e1a3378bbebb4e97dc476bac72ca9315cc7e89e3e2","impliedFormat":1},{"version":"3a21d83e527b6d812d75c719134026ffc18efe0f01c76e6441b29d77add09e26","impliedFormat":1},{"version":"91406250d53804ad5f3a42af40a5e17f1ea3e54c493076f6f931e77efa6db566","impliedFormat":1},{"version":"1fb51788ac6acb1e6cba5cf7e99b03d07ca8b4120550defd561b331dfa8e816d","impliedFormat":1},{"version":"3cc15f1ebcd824e7752f390dab07e92b15e02514f2c9ceb1737ee42d4e3164e3","impliedFormat":1},{"version":"830c34482ca4bce8c4fa2f14cff1197fce2017471752441e95b25112827ceef3","impliedFormat":1},{"version":"f00b89d69f241f3e74269c2de5d3cd564fea760fd4d2a403820ed5b077819724","impliedFormat":1},{"version":"d2e41732e6551589732bb50507b48762982fbe68fcb739f7a4fdacf7a2eb6bb1","impliedFormat":1},{"version":"b62750f035b864e25b966d2a5bd32a716d8a0f5e9befaa3638603ec8df578b37","impliedFormat":1},{"version":"8933e7bf77f729d2ae382fe434a1038fa304caf15c71a4c16c90c19e9ca7626f","impliedFormat":1},{"version":"20463dff6b7f9ab3573ceb503f0674d34c3571328bec2152db193e732a29bb7a","impliedFormat":1},{"version":"528e1e94b95de11acf4545f8b930b460e18ef044579a24a8b1b2d40c068fa89e","impliedFormat":1},{"version":"fc8a3cf4a55f7d1ae3f2efdda84bbeaeea605a92e535ac52b99deed6366917d5","impliedFormat":99},{"version":"4d0d2708fe857d7a1a936da40fb357b2f67f22b0e0c4994211ee6a6ccbd48a33","impliedFormat":1},{"version":"21a572262a50e7b603382800b727abae5b7d52ccd71ae163f8dc4cac379f7274","impliedFormat":1},{"version":"e674342d40884888334a6cf55ac4276abd77f36f51687f56a47d5910fd9ea033","impliedFormat":1},{"version":"ac04b4535689f4fd637d97c9811d5fafe4d2209d497c0eae539c3e99d81978fc","impliedFormat":1},{"version":"c3a31b99b4de2d53784cf340ee9b36907f2b859dcb34dd75c08425248e9e3525","impliedFormat":1},{"version":"f03893fc4406737e85fd952654fd0a81c6a787b4537427b80570fea3a6e4e8b6","impliedFormat":1},{"version":"518ee71252a0acf9fce679a78f13630ab81d24a9b4ee0b780e418a4859cc5e9f","impliedFormat":1},{"version":"3946840c77ebba396a071303e6e4993eaa15f341af507a04b8b305558410f41e","impliedFormat":1},{"version":"2fba8367edfbc4db7237afc46fd04f11a5cc68a5ff60a374f8f478fcc65aa940","impliedFormat":1},{"version":"8d6e54930ac061493fa08de0f2fd7af5a1292de5e468400c4df116fd104585a2","impliedFormat":1},{"version":"38c6778d12f0d327d11057ef49c9b66e80afb98e540274c9d10e5c126345c91d","impliedFormat":1},{"version":"2ac9c98f2e92d80b404e6c1a4a3d6b73e9dc7a265c76921c00bbcc74d6aa6a19","impliedFormat":1},{"version":"8464225b861e79722bf523bb5f9f650b5c4d92a0b0ede063cc0f3cf7a8ddd14a","impliedFormat":1},{"version":"266fb71b46300d4651ff34b6f088ac26730097d9b30d346b632128a2c481a380","impliedFormat":1},{"version":"e747335bc7db47d79474deaa7a7285bf1688359763351705379d49efcddc6d75","impliedFormat":1},{"version":"20f99f0f0fdf0c71d336110b7f28f11f86e632cf4cf0145a76b37926ffaa5e67","impliedFormat":1},{"version":"148e0a838139933abaeee7afc116198e20b5a3091c5e63f9d6460744f9ad61a0","impliedFormat":1},{"version":"72c0d33dd598971c1caa9638e46d561489e9db6f0c215ced7431d1d2630e26d3","impliedFormat":1},{"version":"611f0ccef4b1eebe00271c7e303d79309d94141b6d937c9c27b627a6c5b9837f","impliedFormat":1},{"version":"e2d98375b375d8baa7402848dca7c6cd764da6abf65ecfaa05450a81a488157f","impliedFormat":1},{"version":"b6254476d1ab4ce8525ae5f0f7e31a74d43f79eecd1503c4de3c861ee3040927","impliedFormat":1},{"version":"65f702c9b0643dc0d37be10d70da8f8bbd6a50c65c83f989f48674afb3703d06","impliedFormat":1},{"version":"5734aa7e99741993aa742bf779c109ced2d70952401efe91a56f87ed7c212d1b","impliedFormat":1},{"version":"96f46fdc3e6b3f94cd2e68eca6fd069453f96c3dea92a23e9fcf4e4e5ba6ecdb","impliedFormat":1},{"version":"bde86caf9810f742affde41641c953a5448855f03635bf3677edf863107d2beb","impliedFormat":1},{"version":"6df9dfe35560157af609b111a548dc48381c249043f68bcdf9cf7709851ac693","impliedFormat":1},{"version":"9ba8d6c8359e51801a4722ce0cbf24f259115114a339524bb1fdb533e9d179da","impliedFormat":1},{"version":"8b1f2a75b36d4a5b52771e1bfd94706b1ec9cd03b0825d4b3c7bcf45e5759eab","impliedFormat":1},{"version":"97d50788c0ec99494913915997ab16e03fb25db0d11f7d1d7395275fa0255b66","impliedFormat":1},{"version":"aea313472885609bd9f7cd0efdc6bc17112f8734699b743e7fbd873d272ca147","impliedFormat":1},{"version":"116f362c8b60668e7a99f19a46108ceac87b970e98678a83ae5b2a18382db181","impliedFormat":1},{"version":"b4fbfaa34aacd768965b0135a0c4e7dbaa055a8a4d6ffe7bedf1786d3dc614de","impliedFormat":1},{"version":"87b9b8fd9faf5298d4054bfa6bf6a159571afa41dfdbd3a23ea2a3d0fab723bd","impliedFormat":1},{"version":"cde5f66590c3a1af8b32b89444c7e975de93a3f4b7fc878087abf4187c7949fc","impliedFormat":1},{"version":"31ad2c3e09a73713d4c52f325e0fa0cf920ea3ea6bccb1fc4b271d9313183883","impliedFormat":1},{"version":"5906db268438b1a7a124f8690a92031288a8e42e6aea0f525158031b324427d7","impliedFormat":1},"9d0212c2cc9a1861a04945317484a3840186a591c580ba7d865195e09f676fed",{"version":"ac309244296f378db62f70d2dbeaf859340db6380ceac650e3e21713760abb8c","impliedFormat":99},{"version":"82738d9afed59be7ee7b5f1602747adfb22136ff31af4d4a2cc8651ef77eaf19","impliedFormat":1},{"version":"aae374b21c7c3fe8a312b0ea6cfa3bd1376401fe6fa0de4da7506c2ed594aef4","impliedFormat":1},{"version":"2813548f7105435705b6a5c6c8459dadde0476ab2ebae6b2644cf2259960dc6d","impliedFormat":99},{"version":"e0f4c3a6747fac775e2d740f92e60a6da762e4f34d0a2057e22784fb5204181a","impliedFormat":1},{"version":"da107b61f72658beedd678c0c8fd0cedb3a02f679bbcea9d7bdea8e814dcadce","impliedFormat":99},{"version":"75ec6a6e61de058d8d450b229d54504ef1a47328b7e61d9cdc49e283559f3687","impliedFormat":1},{"version":"a469460e21a0286fb87a7df9539ff99e6c831ee11e1f929ce6ad68b8aaca7e3d","impliedFormat":1},{"version":"1b8e0cff7e05b290d2581f93d0b9f9b1d17971034825617b55ad3f398a2870f4","impliedFormat":1},{"version":"d23b8c70c6565fef9286c65bd6ff34ae3ad7084e0ec5e177f125a42d2a7c1886","impliedFormat":1},{"version":"4759dfcd0778dd0b9449affcc374781a863536a25dcfaa7c71d74317f8448b1a","impliedFormat":1},{"version":"aab65cc378cd64bd82cf63fbe1f6d5804c1594a4fc328468b405093d0c6aa727","impliedFormat":1},{"version":"681abfae63f06f15e42cd6f4c6f8a185da32c002e53af81652c59caa84370172","impliedFormat":1},{"version":"14021cbd3905a3e48bb4f45f51e813d6c3acefc6a3b3613658252ed402a62104","impliedFormat":1},{"version":"546dccc430d25c23cd0e7d1e2121c4a5321a77ae743846c57add1b2b20df2fc1","impliedFormat":99},"6b5264d129bb6e3f65b5553b7005d5b1811d3204f4a6dab7218d79850a7ff71f","00baf8d71fc2e708420ac2ab77ccf2f8d499bd4da2bab54725f0acfaae2da9fe","2aa379d2d3e650bca8757a980cb7877e9847239f7e0f9287727450b66f38f5f8","b99fbb7e9c3c63652f31683b2a3213332b0fb147fff430995069a389170e6beb","06e8240f7c91eee0683c46e9aa652c30b7afeaec10a3cd7bb3b8c1d70b839676","a4476955c8deb7fce80a6494b08a332460863fcc4dd3b7d02005c74fe0919af5","1996b32940bc356f4e46aad705f46a7bc930809e6e319ecf7100097622796fb8","df62fa4978b479fe2a1bd9b70e6a7ca53682ede9c1e986dfd279dbb574c2ec17","be909b597f540f13f699368601ef1f80d2c6a0eb13b7c25d77c16a81b7bccbaf","3108d959beb0384494ff15005f80c73c9091e9c2eef7e7d2d404da02689c869d","9ad916059bc206162efec6963e770c5e21a9963ca80ddcb68686c79bef407789","0a23ad11c6d4f2127dafdbafbd5ba52e826993645db43b9e929bdad60062c6a5","62f0a53d41e919f83951036dd16274f9d57a24f6c0248f8503c473f4ecbe1b83","cb4d24ddb0a4d39a942367741be416ba592616238c2b11cb6afdfe8697fee763","619f25d306951d24563a0af1e64e9f4d7ee12fc22986c692f57cc813a032a421","8721e8f87b1838e37c65a70ea25792f9433be3537e02a118aff6fcbb07d705a9","aa3686489dd5bee2c7c2c0670f146548dbaf0ac8584445183e626519c61df4b4","2a5626899c9ef081497ad60e3816de98eced594fbb5c1bde2d841f73576790d7","fad8e3f975a05b5ff655b6afe0663a379e7ae1f996a7f1d3dcef786f029cd380","6d57cba2d54bc283b1997cdb28fcae2e6db823c019fb1654b071b18841925242","e4342d2d10d61aa1910c7c31bb1f41e994c647f917797f7967bcdd7aded4aa8b","e96c884d377b37bf05828920bf61ccb4fcbfcb304e5f10c71d50f8c89dbb0050","6982e1258ca4ce7e1377e434cd26a8d0da24f1eb3a77bc98db1ccc4cf2834956","6950b36869822d70ccd3edbbf6edab74f71e08580e9da93952d5b0315fc2f427","d2b0473ba1daf7fcec89bf501f69cd51b1ab586e3cf1655c9577a3f249227afd","9f8096010dab34a0ad50919b7332ba8655d37deb3eb909ef701a8b68f5f0ba1b","a0dd80d4c2d18c084615f38faa30fed67d7324a790db5bbd2793939e81b8c65c","51a37b5053b38b181df53419e4e82249997c5f0a2e375d881c67fcc109dfc2ea","6fb90e0ea8bf3ca665f201c85c5205eb054e1535dc3822cce3831c1ede6bd0f7","cbeca205171b66b37b05bbb0cd49c23e6164323a5c4b8bb306d6edd7d8661d20","20dad0ab55de1778c0c8165c5a2c2694f54c8808d5f96d629623557b385b3368","6a996e09fb64a1cb344d222df0d082ea4511f9e5d0dce7bc670fd8871bfd6d51","00f318e52a267fbd2d313988155c38799c7ef09cd9c159f79c7627fbcac7fef9","4543a6d3775864807f18676f73591dcfcb798062b8651b329f85cf8826b1f0e4","ec77af20618b71127c6a70b25672273e47dd1ba26e6dc86514e24a741c2b8e80","dc23950fa8350317997f3fcb6d6caf978be6d7efb3d71193b13d09c7e087236e","a24861793569f99770cb85ac262bde7d07e095803ddd5393980f847ee371864a","da6e695ccee5bcfaddd295cfd99ff99e78ca353719a9a900dc76a3d87e8e3337","9f06910f20a06c30d4488c2d161ca1afa4eb64776f12fb464126ff879b100228","19bd918518b8f6c7440dc4cd1ec2698b2432bd2a690f811c1f1db81da640bf1c","20d6480ecc09d57d74996a12ed0787cbf78c665fb40b32e7581561a6e6d631e7","d4890cba7f810fd878e2439a52545ce618ee38f263a35f50d9fbf9793585db4c","35856f17225ca7f900231f2872e3cc5826c2ddade4f553cc72c4364463365c6e","05072be76233d02857b54b5a8160a4255b9d43ef7e00bc52e654c1ede07af8f3","26ddea48c1d7ea3f1056f7f2b757feeb9db7bf5c39876df7dd1fc10ed18f0f30","b9b06fda6577108f9474748520fbd1ce333c8b56c5ba76052686aec4890695f2","2552b3922a39273e20356f962d90a87c7af143b9750a934b2bd2c60d3b8edb40","ac892c3bcd6f2110b536aa92e388eca8b232f98a6ccd8b55ed434f0968a672ef","1227522d73480ed7f1d7cfca60305715aca21918bcd4acf36e7c3b4c93e077ba","53726e6d62fc1f7ca1ab4f1d46c45c0f622c607cac2e2be2e0c65b3684434d65","48bc9febfd0b20cd4fde3a4a09247dfd575f9518604a19b2d771d7f5a0c0cd3b","2e7d3f9645e11cb09fc1ad06c1b9204fdb0a994f5b5069965cc3a526fe6dbcb5","c01465d4591d20fb7df15c141344943909c580cfbe5ac8185d941093382f6ea1",{"version":"090cde3dad7dd7c319957176fd61360b1fee094ec00f0f05643ca9a8c936f44b","signature":"9734bbf4d6aa65a4c80a7cdcd3e286683ca1b5a7f5ddd00045d4a07c529bffee"},"7c0bf882d6ee38f1dd4101968b974e5fc4988c4f054fa591f88af17551725817","610cfdb2fdb1254cc7cc8a402c0552c95219eab61715624564e735a040017101","eaa81dc97b34c5a525761a156c63e330c45b413d1877ed8fc6114e0c454dc67a","41ed8ba5ea11f5abdb3d4c08ac1ce6779807b2e91cfd790dd7b72977411017d7","0ec1bfed07a6d24818f831b74f17831514a069a34fdb477492154ce78c0a7db6","087531ff23756247371028767094105223e8f01a3142ae266e751b83c65beb60","60c33be4d1b6260fd0ae951f238fa669aa2f496174d241ac9ecede8e19d88648","b7e1a789632119015f97dd582336dacbc8da3c002fa720cbc5a56b2262a10088","5ee61de8125ecdaafa2ac402eb267b973659265cefbffbee2bba51946379263f","1e515aa2c8f22365dc95d9c43d460a5e736d405255520565ebfe9e2f93513d87","e96c0d8b6d463bcaf75d6867ea81087522291285d77cdcfd22f45f649e468211","f227a5804e49c01c5799817d79e4bda78dc6df1505a59fe475e6f3c1a3adc703","99ad0de867b13c566c6057d5b718f3189668caa843725156a6d882c36efb4f45","2317d75e2a0a5c034279ef0f977d00037d253645a21de50e74f286d36a9cf10b","b024076d7f6548631cecbb00322d143b03d16303e379911a13732f849959fa07","0c2d54efbb0378781eda5ea905ed24e831437f40b2b05f060aa14e8bccb9555d","1ca87070089afd8bea3fc2f475444d8f61b79ea6c226f522f262935d051c3ce1","bbe51a0918f60a2c3cf48e07279b0dc8164dc5e7dc169aaa36c92f77aaa3d594","0900eadd947c39726925ad51707f1ef739971afff30dc6ef3547c514ff40484f","d973b07acb5359197d4ca81141c9ced85e2d162d9f86063e4dac992d4af0fd62","49285b21e7b59fbb1d0d6ff2779ad9413c450da6fc23ca2ec661fdcce8a6ad4a","d1986184a09a52db8228cb2bb2a61a8c05c9354e5b93cec8e2628d8579c892d7",{"version":"f31c4f2e95ea48a5359b8b12d88e7f9df3e84c55297384c7ba6321fee2bca54c","affectsGlobalScope":true},"4638acacbde71b13a7dfc70bb2262b56fc4594e40232f87f3a6faedb760b109a","d1986184a09a52db8228cb2bb2a61a8c05c9354e5b93cec8e2628d8579c892d7","26a6caeefda9c5179718f70e14e8f6e1f550e86c3d18537cf637b07275b8d21c",{"version":"0e298df8752b8bdcafdf4c8e8560df048c3c5688fa683f14a827490e0fe0cf0f","impliedFormat":1},{"version":"035a5df183489c2e22f3cf59fc1ed2b043d27f357eecc0eb8d8e840059d44245","impliedFormat":1},{"version":"a4809f4d92317535e6b22b01019437030077a76fec1d93b9881c9ed4738fcc54","impliedFormat":1},{"version":"5f53fa0bd22096d2a78533f94e02c899143b8f0f9891a46965294ee8b91a9434","impliedFormat":1},{"version":"d934a06d62d87a7e2d75a3586b5f9fb2d94d5fe4725ff07252d5f4651485100f","impliedFormat":1},{"version":"0d14fa22c41fdc7277e6f71473b20ebc07f40f00e38875142335d5b63cdfc9d2","impliedFormat":1},{"version":"b104e2da53231a529373174880dc0abfbc80184bb473b6bf2a9a0746bebb663d","impliedFormat":99},{"version":"3d4bb4d84af5f0b348f01c85537da1c7afabc174e48806c8b20901377c57b8e4","impliedFormat":99},{"version":"a2500b15294325d9784a342145d16ef13d9efb1c3c6cb4d89934b2c0d521b4ab","impliedFormat":99},{"version":"79d5c409e84764fabdd276976a31928576dcf9aea37be3b5a81f74943f01f3ff","impliedFormat":99},{"version":"8ea020ea63ecc981b9318fc532323e31270c911a7ade4ba74ab902fcf8281c45","impliedFormat":99},{"version":"c81e1a9b03e4de1225b33ac84aaf50a876837057828e0806d025daf919bf2d51","impliedFormat":99},{"version":"bb7264d8bd6152524f2ef5dae5c260ae60d459bf406202258bd0ce57c79e5a6d","impliedFormat":99},{"version":"fb66165c4976bc21a4fde14101e36c43d46f907489b7b6a5f2a2679108335d4a","impliedFormat":99},{"version":"628c2e0a0b61be3e44f296083e6af9b5a9b6881037dd43e7685ee473930a4404","impliedFormat":99},{"version":"4776f1e810184f538d55c5da92da77f491999054a1a1ee69a2d995ab2e8d1bc0","impliedFormat":99},{"version":"11544c4e626eab113df9432e97a371693c98c17ae4291d2ad425af5ef00e580b","impliedFormat":99},{"version":"e1847b81166d25f29213d37115253c5b82ec9ee78f19037592aa173e017636d5","impliedFormat":99},{"version":"fe0bd60f36509711c4a69c0e00c0111f5ecdc685e6c1a2ae99bd4d56c76c07fc","impliedFormat":99},{"version":"b8f3f4ee9aae88a9cec9797d166209eb2a7e4beb8a15e0fc3c8b90c9682c337d","impliedFormat":99},{"version":"ea3c4f5121fe2e86101c155ebe60b435c729027ae50025b2a4e1d12a476002ae","impliedFormat":99},{"version":"372db10bea0dbe1f8588f82b339152b11847e6a4535d57310292660c8a9acfc5","impliedFormat":99},{"version":"6f9fba6349c16eed21d139d5562295e8d5aafa5abe6e8ebcde43615a80c69ac1","impliedFormat":99},{"version":"1474533e27d0e3e45a417ea153d4612f0adbff055f244a29606a1fae6db56cda","impliedFormat":99},{"version":"c7fd8a79d0495955d55bfea34bbdb85235b0f27b417a81afc395655ef43d091d","impliedFormat":99},{"version":"987405949bfafbb1c93d976c3352fe33bfb85303a79fc5d9588b681e4af6c3b3","impliedFormat":99},{"version":"867bc1f5a168fd86d12d828dfafd77c557f13b4326588615b19e301f6856f70c","impliedFormat":99},{"version":"6beddab08d635b4c16409a748dcd8de38a8e444a501b8e79d89f458ae88579d1","impliedFormat":99},{"version":"1dea5c7bf28569228ffcc83e69e1c759e7f0133c232708e09cfa4d7ed3ec7079","impliedFormat":99},{"version":"6114545678bb75e581982c990597ca3ba7eeef185256a14c906edfc949db2cd1","impliedFormat":99},{"version":"5c8625f8dbbd94ab6ca171d621049c810cce4fce6ec1fd1c24c331d9858dce17","impliedFormat":99},{"version":"af36e5f207299ba2013f981dffacd4a04cdce2dd4bd255fff084e7257bf8b947","impliedFormat":99},{"version":"c69c720b733cdaa3b4542f4c1206d9f0fcf3696f87a6e88adb15db6882fbcd69","impliedFormat":99},{"version":"9c37e66916cbbe7d96301934b665ec712679c3cb99081ccaae4034b987533a59","impliedFormat":99},{"version":"2e1a163ab5b5c2640d7f5a100446bbcaeda953a06439c901b2ae307f7088dc30","impliedFormat":99},{"version":"f0b3406d2bc2c262f218c42a125832e026997278a890ef3549fa49e62177ce86","impliedFormat":99},{"version":"756cf223ca25eb36c413b2a286fa108f19a5ac39dc6d65f2c590dc118f6150df","impliedFormat":99},{"version":"70ce03da8740ca786a1a78b8a61394ecf812dd1acf2564d0ce6be5caf29e58d9","impliedFormat":99},{"version":"e0f5707d91bb950edb6338e83dd31b6902b6620018f6aa5fd0f504c2b0ea61f5","impliedFormat":99},{"version":"0dc7ae20eab8097b0c7a48b5833f6329e976f88af26055cdae6337141ff2c12e","impliedFormat":99},{"version":"76b6db79c0f5b326ff98b15829505efd25d36ce436b47fe59781ac9aec0d7f1b","impliedFormat":99},{"version":"786f3f186af874ea3e34c2aeef56a0beab90926350f3375781c0a3aa844cd76e","impliedFormat":99},{"version":"63dbc8fa1dcbfb8af6c48f004a1d31988f42af171596c5cca57e4c9d5000d291","impliedFormat":99},{"version":"aa235b26568b02c10d74007f577e0fa21a266745029f912e4fba2c38705b3abe","impliedFormat":99},{"version":"3d6d570b5f36cf08d9ad8d93db7ddc90fa7ccc0c177de2e9948bb23cde805d32","impliedFormat":99},{"version":"9a60faaa0d582db70f85a94a3439bd83720a9468928b76b4db561a1a0137fa90","impliedFormat":99},{"version":"627e2ac450dcd71bdd8c1614b5d3a02b214ad92a1621ebeb2642dffb9be93715","impliedFormat":99},{"version":"813514ef625cb8fc3befeec97afddfb3b80b80ced859959339d99f3ad538d8fe","impliedFormat":99},{"version":"624f8a7a76f26b9b0af9524e6b7fa50f492655ab7489c3f5f0ddd2de5461b0c3","impliedFormat":99},{"version":"d6b6fa535b18062680e96b2f9336e301312a2f7bdaeb47c4a5b3114c3de0c08b","impliedFormat":99},{"version":"818e8f95d3851073e92bcad7815367dd8337863aaf50d79e703ac479cca0b6a4","impliedFormat":99},{"version":"29b716ff24d0db64060c9a90287f9de2863adf0ef1efef71dbaba33ebc20b390","impliedFormat":99},{"version":"2530c36527a988debd39fed6504d8c51a3e0f356aaf2d270edd492f4223bdeff","impliedFormat":99},{"version":"2553cfd0ec0164f3ea228c5badd1ba78607d034fc2dec96c781026a28095204b","impliedFormat":99},{"version":"6e943693dbc91aa2c6c520e7814316469c8482d5d93df51178d8ded531bb29ee","impliedFormat":99},{"version":"e74e1249b69d9f49a6d9bfa5305f2a9f501e18de6ab0829ab342abf6d55d958b","impliedFormat":99},{"version":"16f60d6924a9e0b4b9961e42b5e586b28ffd57cdfa236ae4408f7bed9855a816","impliedFormat":99},{"version":"493c2d42f1b6cfe3b13358ff3085b90fa9a65d4858ea4d02d43772c0795006ec","impliedFormat":99},{"version":"3702c7cbcd937d7b96e5376fe562fd77b4598fe93c7595ee696ebbfefddac70f","impliedFormat":99},{"version":"848621f6b65b3963f86c51c8b533aea13eadb045da52515e6e1407dea19b8457","impliedFormat":99},{"version":"c15b679c261ce17551e17a40a42934aeba007580357f1a286c79e8e091ee3a76","impliedFormat":99},{"version":"156108cedad653a6277b1cb292b18017195881f5fe837fb7f9678642da8fa8f2","impliedFormat":99},{"version":"0a0bb42c33e9faf63e0b49a429e60533ab392f4f02528732ecbd62cfc2d54c10","impliedFormat":99},{"version":"70fa95cd7cb511e55c9262246de1f35f3966c50e8795a147a93c538db824cdc8","impliedFormat":99},{"version":"bc28d8cec56b5f91c8a2ec131444744b13f63c53ce670cb31d4dffdfc246ba34","impliedFormat":99},{"version":"7bd87c0667376e7d6325ada642ec29bf28e940cb146d21d270cac46b127e5313","impliedFormat":99},{"version":"0318969deede7190dd3567433a24133f709874c5414713aac8b706a5cb0fe347","impliedFormat":99},{"version":"3770586d5263348c664379f748428e6f17e275638f8620a60490548d1fada8b4","impliedFormat":99},{"version":"ff65e6f720ba4bf3da5815ca1c2e0df2ece2911579f307c72f320d692410e03d","impliedFormat":99},{"version":"edb4f17f49580ebcec71e1b7217ad1139a52c575e83f4f126db58438a549b6df","impliedFormat":99},{"version":"353c0cbb6e39e73e12c605f010fddc912c8212158ee0c49a6b2e16ede22cdaab","impliedFormat":99},{"version":"e125fdbea060b339306c30c33597b3c677e00c9e78cd4bf9a15b3fb9474ebb5d","impliedFormat":99},{"version":"ee141f547382d979d56c3b059fc12b01a88b7700d96f085e74268bc79f48c40a","impliedFormat":99},{"version":"1d64132735556e2a1823044b321c929ad4ede45b81f3e04e0e23cf76f4cbf638","impliedFormat":99},{"version":"8b4a3550a3cac035fe928701bc046f5fac76cca32c7851376424b37312f4b4ca","impliedFormat":99},{"version":"5fd7f9b36f48d6308feba95d98817496274be1939a9faa5cd9ed0f8adf3adf3a","impliedFormat":99},{"version":"15a8f79b1557978d752c0be488ee5a70daa389638d79570507a3d4cfc620d49d","impliedFormat":99},{"version":"d4c14ea7d76619ef4244e2c220c2caeec78d10f28e1490eeac89df7d2556b79f","impliedFormat":99},{"version":"8096207a00346207d9baf7bc8f436ef45a20818bf306236a4061d6ccc45b0372","impliedFormat":99},{"version":"040f2531989793c4846be366c100455789834ba420dfd6f36464fe73b68e35b6","impliedFormat":99},{"version":"c5c7020a1d11b7129eb8ddffb7087f59c83161a3792b3560dcd43e7528780ab0","impliedFormat":99},{"version":"d1f97ea020060753089059e9b6de1ab05be4cb73649b595c475e2ec197cbce0f","impliedFormat":99},{"version":"b5ddca6fd676daf45113412aa2b8242b8ee2588e99d68c231ab7cd3d88b392fa","impliedFormat":99},{"version":"77404ec69978995e3278f4a2d42940acbf221da672ae9aba95ffa485d0611859","impliedFormat":99},{"version":"4e6672fb142798b69bcb8d6cd5cc2ec9628dbea9744840ee3599b3dcd7b74b09","impliedFormat":99},{"version":"609653f5b74ef61422271a28dea232207e7ab8ad1446de2d57922e3678160f01","impliedFormat":99},{"version":"9f96251a94fbff4038b464ee2d99614bca48e086e1731ae7a2b5b334826d3a86","impliedFormat":99},{"version":"cacbb7f3e679bdea680c6c609f4403574a5de8b66167b8867967083a40821e2a","impliedFormat":99},{"version":"ee4cf97e8bad27c9e13a17a9f9cbd86b32e9fbc969a5c3f479dafb219209848c","impliedFormat":99},{"version":"3a4e35b6e99ed398e77583ffc17f8774cb4253f8796c0e04ce07c26636fed4a9","impliedFormat":99},{"version":"08d323cb848564baef1ecbe29df14f7ad84e5b2eaf2e02ea8cb422f069dcb2fa","impliedFormat":99},{"version":"a05b53646fa669b87d8b97c1fb7c0183d771680fdd1276b12e68bed4e84cf556","impliedFormat":99},{"version":"c3b9c02a31b36dd3a4067f420316c550f93d463e46b2704391100428e145fd7f","impliedFormat":99},{"version":"b2a4d01fcf005530c3f8689ac0197e5fd6b75eb031e73ca39e5a27d41793a5d8","impliedFormat":99},{"version":"e99d9167596f997dd2da0de0751a9f0e2f4100f07bddf049378719191aee87f6","impliedFormat":99},{"version":"40cc853264e24e0578580194c76e25628acdd1111b54ec8abf59b834c4942839","impliedFormat":99},{"version":"403971c465292dedc8dff308f430c6b69ec5e19ea98d650dae40c70f2399dc14","impliedFormat":99},{"version":"fd3774aa27a30b17935ad360d34570820b26ec70fa5fcfd44c7e884247354d37","impliedFormat":99},{"version":"7b149b38e54fe0149fe500c5d5a049654ce17b1705f6a1f72dd50d84c6a678b9","impliedFormat":99},{"version":"3eb76327823b6288eb4ed4648ebf4e75cf47c6fbc466ed920706b801399f7dc3","impliedFormat":99},{"version":"c6a219d0d39552594a4cc75970768004f99684f28890fc36a42b853af04997b7","impliedFormat":99},{"version":"2110d74b178b022ca8c5ae8dcc46e759c34cf3b7e61cb2f8891fd8d24cb614ef","impliedFormat":99},{"version":"38f5e025404a3108f5bb41e52cead694a86d16ad0005e0ef7718a2a31e959d1e","impliedFormat":99},{"version":"8db133d270ebb1ba3fa8e2c4ab48df2cc79cb03a705d47ca9f959b0756113d3d","impliedFormat":99},{"version":"fc9294185089a62f8287130bc100fa5ab11f3e6af8874127bbdf7600f19913ee","impliedFormat":99},{"version":"f06e5783d10123b74b14e141426a80234b9d6e5ad94bfc4850ea912719f4987c","impliedFormat":99},{"version":"de9466be4b561ad0079ac95ca7445c99fdf45ef115a93af8e2e933194b3cdf4c","impliedFormat":99},{"version":"0c1eed961c15e1242389b0497628709f59d7afd50d5a1955daa10b5bd3b68fc2","impliedFormat":99},{"version":"5e07a9f7f130e5404c202bf7b0625a624c9d266b980576f5d62608ef21d96eab","impliedFormat":99},{"version":"2f97d5063ab69bf32d6417d71765fc154dc6ff7c16700db7c4af5341a965c277","impliedFormat":99},{"version":"a8a9459dd76ef5eeef768da4ce466c5539d73b26334131bd1dd6cbd74ce48fa2","impliedFormat":99},{"version":"123ff203ffba727213e5095b9a59091cdbc9d1d94bae0d6adb98060ef410016c","impliedFormat":99},{"version":"9e4d81dd52d5a8b6c159c0b2f2b5fbe2566f12fcc81f7ba7ebb46ca604657b45","impliedFormat":99},{"version":"9ee245e7c6aa2d81ee0d7f30ff6897334842c469b0e20da24b3cddc6f635cc06","impliedFormat":99},{"version":"e7d5132674ddcd01673b0517eebc44c17f478126284c3eabd0a552514cb992bb","impliedFormat":99},{"version":"a820710a917f66fa88a27564465a033c393e1322a61eb581d1f20e0680b498f1","impliedFormat":99},{"version":"19086752f80202e6a993e2e45c0e7fc7c7fc4315c4805f3464625f54d919fa2e","impliedFormat":99},{"version":"141aebe2ee4fecd417d44cf0dabf6b80592c43164e1fbd9bfaf03a4ec377c18e","impliedFormat":99},{"version":"72c35a5291e2e913387583717521a25d15f1e77d889191440dc855c7e821b451","impliedFormat":99},{"version":"ec1c67b32d477ceeebf18bdeb364646d6572e9dd63bb736f461d7ea8510aca4f","impliedFormat":99},{"version":"fb555843022b96141c2bfaf9adcc3e5e5c2d3f10e2bcbd1b2b666bd701cf9303","impliedFormat":99},{"version":"f851083fc20ecc00ff8aaf91ba9584e924385768940654518705423822de09e8","impliedFormat":99},{"version":"c8d53cdb22eedf9fc0c8e41a1d9a147d7ad8997ed1e306f1216ed4e8daedb6b3","impliedFormat":99},{"version":"6c052f137bab4ba9ed6fd76f88a8d00484df9d5cb921614bb4abe60f51970447","impliedFormat":99},{"version":"d888e70d2e4a05f47573548bf836cab96575aab3b1c264693100f279514ac8ca","impliedFormat":99},{"version":"7d5c2df0c3706f45b77970232aa3a38952561311ccc8fcb7591e1b7a469ad761","impliedFormat":99},{"version":"2c41502b030205006ea3849c83063c4327342fbf925d8ed93b18309428fdd832","impliedFormat":99},{"version":"d12eecede214f8807a719178d7d7e2fc32f227d4705d123c3f45d8a3b5765f38","impliedFormat":99},{"version":"c8893abd114f341b860622b92c9ffc8c9eb9f21f6541bd3cbc9a4aa9b1097e42","impliedFormat":99},{"version":"825674da70d892b7e32c53f844c5dfce5b15ea67ceda4768f752eed2f02d8077","impliedFormat":99},{"version":"2c676d27ef1afbc8f8e514bb46f38550adf177ae9b0102951111116fa7ea2e10","impliedFormat":99},{"version":"a6072f5111ea2058cb4d592a4ee241f88b198498340d9ad036499184f7798ae2","impliedFormat":99},{"version":"ab87c99f96d9b1bf93684b114b27191944fef9a164476f2c6c052b93eaac0a4f","impliedFormat":99},{"version":"13e48eaca1087e1268f172607ae2f39c72c831a482cab597076c6073c97a15e7","impliedFormat":99},{"version":"19597dbe4500c782a4252755510be8324451847354cd8e204079ae81ab8d0ef6","impliedFormat":99},{"version":"f7d487e5f0104f0737951510ea361bc919f5b5f3ebc51807f81ce54934a3556f","impliedFormat":99},{"version":"efa8c5897e0239017e5b53e3f465d106b00d01ee94c9ead378a33284a2998356","impliedFormat":99},{"version":"fe3c53940b26832930246d4c39d6e507c26a86027817882702cf03bff314fa1d","impliedFormat":99},{"version":"53ee33b91d4dc2787eccebdbd396291e063db1405514bb3ab446e1ca3fd81a90","impliedFormat":99},{"version":"c4a97da118b4e6dde7c1daa93c4da17f0c4eedece638fc6dcc84f4eb1d370808","impliedFormat":99},{"version":"71666363fbdb0946bfc38a8056c6010060d1a526c0584145a9560151c6962b4f","impliedFormat":99},{"version":"1326f3630d26716257e09424f33074a945940afd64f2482e2bbc885258fca6bb","impliedFormat":99},{"version":"cc2eb5b23140bbceadf000ef2b71d27ac011d1c325b0fc5ecd42a3221db5fb2e","impliedFormat":99},{"version":"d04f5f3e90755ed40b25ed4c6095b6ad13fc9ce98b34a69c8da5ed38e2dbab5a","impliedFormat":99},{"version":"280b04a2238c0636dad2f25bbbbac18cf7bb933c80e8ec0a44a1d6a9f9d69537","impliedFormat":99},{"version":"0e9a2d784877b62ad97ed31816b1f9992563fdda58380cd696e796022a46bfdf","impliedFormat":99},{"version":"1b1411e7a3729bc632d8c0a4d265de9c6cbba4dc36d679c26dad87507faedee3","impliedFormat":99},{"version":"c478cfb0a2474672343b932ea69da64005bbfc23af5e661b907b0df8eb87bcb7","impliedFormat":99},{"version":"1a7bff494148b6e66642db236832784b8b2c9f5ad9bff82de14bcdb863dadcd9","impliedFormat":99},{"version":"65e6ad2d939dd38d03b157450ba887d2e9c7fd0f8f9d3008c0d1e59a0d8a73b4","impliedFormat":99},{"version":"f72b400dbf8f27adbda4c39a673884cb05daf8e0a1d8152eec2480f5700db36c","impliedFormat":99},{"version":"347f6fe4308288802eb123596ad9caf06755e80cfc7f79bbe56f4141a8ee4c50","impliedFormat":99},{"version":"5f5baa59149d3d6d6cef2c09d46bb4d19beb10d6bee8c05b7850c33535b3c438","impliedFormat":99},{"version":"a8f0c99380c9e91a73ecfc0a8582fbdefde3a1351e748079dc8c0439ea97b6db","impliedFormat":99},{"version":"be02e3c3cb4e187fd252e7ae12f6383f274e82288c8772bb0daf1a4e4af571ad","impliedFormat":99},{"version":"82ca40fb541799273571b011cd9de6ee9b577ef68acc8408135504ae69365b74","impliedFormat":99},{"version":"e671e3fc9b6b2290338352606f6c92e6ecf1a56459c3f885a11080301ca7f8de","impliedFormat":99},{"version":"a2e4b90260194318b1fa1e6b0554d257a0862c10e982c8907d30d1e7f3d463af","impliedFormat":99},{"version":"5559ab4aa1ba9fac7225398231a179d63a4c4dccd982a17f09404b536980dae8","impliedFormat":99},{"version":"2d7b9e1626f44684252d826a8b35770b77ce7c322734a5d3236b629a301efdcf","impliedFormat":99},{"version":"5b8dafbb90924201f655931d429a4eceb055f11c836a6e9cbc7c3aecf735912d","impliedFormat":99},{"version":"0b9be1f90e5e154b61924a28ed2de133fd1115b79c682b1e3988ac810674a5c4","impliedFormat":99},{"version":"7a9477ba5fc17786ee74340780083f39f437904229a0cd57fc9a468fd6567eb8","impliedFormat":99},{"version":"3da1dd252145e279f23d85294399ed2120bf8124ed574d34354a0a313c8554b6","impliedFormat":99},{"version":"e5c4080de46b1a486e25a54ddbb6b859312359f9967a7dc3c9d5cf4676378201","impliedFormat":99},{"version":"cfe1cdf673d2db391fd1a1f123e0e69c7ca06c31d9ac8b35460130c5817c8d29","impliedFormat":99},{"version":"b9701f688042f44529f99fd312c49fea853e66538c19cfcbb9ef024fdb5470cc","impliedFormat":99},{"version":"6daa62c5836cc12561d12220d385a4a243a4a5a89afd6f2e48009a8dd8f0ad83","impliedFormat":99},{"version":"c74550758053cf21f7fea90c7f84fa66c27c5f5ac1eca77ce6c2877dbfdec4d1","impliedFormat":99},{"version":"bd8310114a3a5283faac25bfbfc0d75b685a3a3e0d827ee35d166286bdd4f82e","impliedFormat":99},{"version":"1459ae97d13aeb6e457ccffac1fbb5c5b6d469339729d9ef8aeb8f0355e1e2c9","impliedFormat":99},{"version":"1bf03857edaebf4beba27459edf97f9407467dc5c30195425cb8a5d5a573ea52","impliedFormat":99},{"version":"f6b4833d66c12c9106a3299e520ed46f9a4c443cefc22c993315c4bb97a28db1","impliedFormat":99},{"version":"746c02f8b99bd90c4d135badaab575c6cfce0d030528cf90190c8914b0934ea3","impliedFormat":99},{"version":"a858ba8df5e703977dee467b10af084398919e99c9e42559180e75953a1f6ef6","impliedFormat":99},{"version":"d2dcd6105c195d0409abd475b41363789c63ae633282f04465e291a68a151685","impliedFormat":99},{"version":"0b569ed836f0431c2efaef9b6017e8b700a7fed319866d7667f1189957275045","impliedFormat":99},{"version":"9371612fd8638d7f6a249a14843132e7adb0b5c84edba9ed7905e835b644c013","impliedFormat":99},{"version":"0c72189b6ec67331476a36ec70a2b8ce6468dc4db5d3eb52deb9fefbd6981ebb","impliedFormat":99},{"version":"af8dd6bb70bfcb2c6b2de0d42240c2c952b9040af259a287e78eaf883ef1ce0d","impliedFormat":99},{"version":"7e4a27fd17dbb256314c2513784236f2ae2023573e83d0e65ebddfda336701db","impliedFormat":99},{"version":"131ecac1c7c961041df80a1dc353223af4e658d56ba1516317f79bd5400cffeb","impliedFormat":99},{"version":"f3a55347fb874828e442c2916716d56552ac3478204c29c0d47e698c00eb5d28","impliedFormat":99},{"version":"49ebbdfe7427d784ccdc8325bdecc8dda1719a7881086f14751879b4f8d70c21","impliedFormat":99},{"version":"c1692845412646f17177eb62feb9588c8b5d5013602383f02ae9d38f3915020c","impliedFormat":99},{"version":"b1b440e6c973d920935591a3d360d79090b8cf58947c0230259225b02cf98a83","impliedFormat":99},{"version":"defc2ae12099f46649d12aa4872ce23ba43fba275920c00c398487eaf091bbae","impliedFormat":99},{"version":"620390fbef44884902e4911e7473531e9be4db37eeef2da52a34449d456b4617","impliedFormat":99},{"version":"e60440cbd3ec916bc5f25ada3a6c174619745c38bfca58d3554f7d62905dc376","impliedFormat":99},{"version":"86388eda63dcb65b4982786eec9f80c3ef21ca9fb2808ff58634e712f1f39a27","impliedFormat":99},{"version":"022cd098956e78c9644e4b3ad1fe460fac6914ca9349d6213f518386baf7c96b","impliedFormat":99},{"version":"dfc67e73325643e92f71f94276b5fb3be09c59a1eeee022e76c61ae99f3eda4b","impliedFormat":99},{"version":"8c3d6c9abaa0b383f43cac0c227f063dc4018d851a14b6c2142745a78553c426","impliedFormat":99},{"version":"ee551dc83df0963c1ee03dc32ce36d83b3db9793f50b1686dc57ec2bbffc98af","impliedFormat":99},{"version":"968832c4ffd675a0883e3d208b039f205e881ae0489cc13060274cf12e0e4370","impliedFormat":99},{"version":"c593ca754961cfd13820add8b34da35a114cda7215d214e4177a1b0e1a7f3377","impliedFormat":99},{"version":"ed88c51aa3b33bb2b6a8f2434c34f125946ba7b91ed36973169813fdad57f1ec","impliedFormat":99},{"version":"a9ea477d5607129269848510c2af8bcfd8e262ebfbd6cd33a6c451f0cd8f5257","impliedFormat":99},{"version":"772b2865dd86088c6e0cab71e23534ad7254961c1f791bdeaf31a57a2254df43","impliedFormat":1},{"version":"21717957404f5b57e7c66b38d5ea832cc7eb5e81a6152242cf2e21893b1fcc5d","impliedFormat":1},{"version":"539dd525bf1d52094e7a35c2b4270bee757d3a35770462bcb01cd07683b4d489","impliedFormat":1},{"version":"86c0791444b64f452f8e513dd07c697313dfc5842916d73abbd2dabd28930367","impliedFormat":1},{"version":"7a705c800602314ac1e6ac059e2c0842fedace663a44bc240e0dc6bfefa2020b","impliedFormat":1},{"version":"8e42a36680c916db7b8951fea71ec2ce0092b82e44c8a33a436902244f0cc907","impliedFormat":1},{"version":"3e2f739bdfb6b194ae2af13316b4c5bb18b3fe81ac340288675f92ba2061b370","affectsGlobalScope":true,"impliedFormat":1},{"version":"921394bdf2d9f67c9e30d98c4b1c56a899ac06770e5ce3389f95b6b85a58e009","affectsGlobalScope":true,"impliedFormat":1},{"version":"247389ec5593d19a2784587be69ea6349e784578070db0b30ba717bec269db38","impliedFormat":1},{"version":"ab82804a14454734010dcdcd43f564ff7b0389bee4c5692eec76ff5b30d4cf66","impliedFormat":1},{"version":"a1fe8b42e276de4de80e53ea6611cef3d416a9c074c9c590ab09874bd6772eba","affectsGlobalScope":true,"impliedFormat":1},{"version":"420845f2661ac73433cbdc45f36d1f7ca7ea4eca60c3cbd077adf3355387cb63","impliedFormat":99},{"version":"bae8d023ef6b23df7da26f51cea44321f95817c190342a36882e93b80d07a960","impliedFormat":1},{"version":"26a770cec4bd2e7dbba95c6e536390fffe83c6268b78974a93727903b515c4e7","impliedFormat":1}],"root":[[552,558],[560,607],[621,638],641,642,645,1557,[1573,1652]],"options":{"allowJs":true,"allowSyntheticDefaultImports":true,"emitDecoratorMetadata":true,"esModuleInterop":true,"experimentalDecorators":true,"jsx":4,"module":99,"noFallthroughCasesInSwitch":true,"skipLibCheck":true,"strict":true,"strictNullChecks":false,"target":2},"referencedMap":[[1651,1],[552,2],[1652,3],[1648,4],[1649,2],[1650,5],[1638,6],[1642,7],[1643,8],[1631,9],[1632,10],[1633,11],[1634,12],[1639,13],[1640,7],[1641,7],[1644,14],[1645,15],[1635,14],[1636,16],[1637,17],[1646,18],[1647,19],[553,20],[1657,2],[1851,21],[1520,2],[397,2],[1558,2],[1563,2],[1572,22],[1561,2],[1567,2],[1570,2],[1565,23],[1569,2],[1571,24],[1568,25],[1566,2],[1559,2],[1564,26],[1562,27],[1560,2],[1482,28],[1504,2],[1505,2],[1417,29],[1407,30],[1452,31],[1484,32],[1502,2],[1113,33],[1475,31],[1446,28],[1422,34],[1476,35],[1385,36],[1486,28],[1473,33],[1402,28],[1491,37],[1401,31],[1481,33],[1411,31],[1428,38],[1384,39],[1457,40],[1404,28],[1500,28],[1444,41],[1412,29],[1393,29],[1390,29],[1480,42],[1454,32],[1449,38],[1429,43],[1420,44],[1511,32],[1477,28],[1413,29],[1424,45],[1425,32],[1426,32],[1406,46],[1391,31],[1427,33],[1436,47],[1510,30],[1392,33],[1455,48],[1430,38],[1488,33],[1382,29],[1414,29],[1403,29],[1509,33],[1493,38],[1465,33],[1458,33],[1512,33],[1461,49],[1463,50],[1464,33],[1459,33],[1423,31],[1466,32],[1494,38],[1415,29],[1409,28],[1394,31],[1506,30],[1410,28],[1467,33],[1419,29],[1498,28],[1386,33],[1501,51],[1431,52],[1383,39],[1508,28],[1507,28],[1474,37],[1471,33],[1400,31],[1472,33],[1115,33],[1114,33],[1499,40],[1485,33],[1497,38],[1489,29],[1492,33],[1408,31],[1487,28],[1456,53],[1483,54],[1490,33],[1437,30],[1439,55],[1405,33],[1387,56],[1389,57],[1432,38],[1416,29],[1399,58],[1453,38],[1418,40],[1434,59],[1496,60],[1513,45],[1514,61],[1503,51],[1468,45],[1470,33],[1469,2],[1448,38],[1441,2],[1451,31],[1442,38],[1447,30],[1440,51],[1479,62],[1388,63],[1450,38],[1435,45],[1478,2],[1104,30],[1556,64],[1460,51],[1462,45],[1495,45],[1106,38],[1553,65],[1522,66],[1554,67],[1521,37],[1105,68],[1111,52],[1108,30],[1110,30],[1518,69],[1109,70],[1112,31],[1515,38],[1519,69],[1555,71],[1516,38],[1517,72],[1107,2],[1085,30],[1093,73],[1094,74],[1097,75],[1095,76],[1091,77],[1096,78],[1090,79],[1092,80],[1102,81],[1098,82],[1100,83],[1101,84],[1103,85],[1850,86],[1661,87],[1662,88],[1799,87],[1800,89],[1781,90],[1782,91],[1665,92],[1666,93],[1736,94],[1737,95],[1710,87],[1711,96],[1704,87],[1705,97],[1796,98],[1794,99],[1795,2],[1810,100],[1811,101],[1680,102],[1681,103],[1812,104],[1813,105],[1814,106],[1815,107],[1672,108],[1673,109],[1798,110],[1797,111],[1783,87],[1784,112],[1676,113],[1677,114],[1700,2],[1701,115],[1818,116],[1816,117],[1817,118],[1819,119],[1820,120],[1823,121],[1821,122],[1824,99],[1822,123],[1825,124],[1828,125],[1826,126],[1827,127],[1829,128],[1678,108],[1679,129],[1804,130],[1801,131],[1802,132],[1803,2],[1779,133],[1780,134],[1724,135],[1723,136],[1721,137],[1720,138],[1722,139],[1831,140],[1830,141],[1833,142],[1832,143],[1709,144],[1708,87],[1687,145],[1685,146],[1684,92],[1686,147],[1836,148],[1840,149],[1834,150],[1835,151],[1837,148],[1838,148],[1839,148],[1726,152],[1725,92],[1742,153],[1740,154],[1741,99],[1738,155],[1739,156],[1675,157],[1674,87],[1732,158],[1663,87],[1664,159],[1731,160],[1769,161],[1772,162],[1770,163],[1771,164],[1683,165],[1682,87],[1774,166],[1773,92],[1752,167],[1751,87],[1707,168],[1706,87],[1778,169],[1777,170],[1746,171],[1745,172],[1743,173],[1744,174],[1735,175],[1734,176],[1733,177],[1842,178],[1841,179],[1759,180],[1758,181],[1757,182],[1806,183],[1805,2],[1750,184],[1749,185],[1747,186],[1748,187],[1728,188],[1727,92],[1671,189],[1670,190],[1669,191],[1668,192],[1667,193],[1763,194],[1762,195],[1693,196],[1692,92],[1697,197],[1696,198],[1761,199],[1760,87],[1807,2],[1809,200],[1808,2],[1766,201],[1765,202],[1764,203],[1844,204],[1843,205],[1846,206],[1845,207],[1792,208],[1793,209],[1791,210],[1730,211],[1729,2],[1776,212],[1775,213],[1703,214],[1702,87],[1754,215],[1753,87],[1660,216],[1659,2],[1713,217],[1714,218],[1719,219],[1712,220],[1716,221],[1715,222],[1717,223],[1718,224],[1768,225],[1767,92],[1699,226],[1698,92],[1849,227],[1848,228],[1847,229],[1786,230],[1785,87],[1756,231],[1755,87],[1691,232],[1689,233],[1688,92],[1690,234],[1788,235],[1787,87],[1695,236],[1694,87],[1790,237],[1789,87],[1653,2],[1654,2],[1655,238],[1656,239],[1857,240],[609,241],[610,242],[608,243],[611,244],[612,245],[613,246],[614,247],[615,248],[616,249],[617,250],[618,251],[619,252],[620,253],[154,254],[155,254],[156,255],[94,256],[157,257],[158,258],[159,259],[92,2],[160,260],[161,261],[162,262],[163,263],[164,264],[165,265],[166,265],[167,266],[168,267],[169,268],[170,269],[95,2],[93,2],[171,270],[172,271],[173,272],[214,273],[174,274],[175,275],[176,274],[177,276],[178,277],[180,278],[181,279],[182,279],[183,279],[184,280],[185,281],[186,282],[187,283],[188,284],[189,285],[190,285],[191,286],[192,2],[193,2],[194,287],[195,288],[196,287],[197,289],[198,290],[199,291],[200,292],[201,293],[202,294],[203,295],[204,296],[205,297],[206,298],[207,299],[208,300],[209,301],[210,302],[211,303],[96,274],[97,2],[98,304],[99,305],[100,2],[101,306],[102,2],[145,307],[146,308],[147,309],[148,309],[149,310],[150,2],[151,257],[152,311],[153,308],[212,312],[213,313],[1858,2],[643,2],[218,314],[482,30],[219,315],[217,316],[484,317],[483,318],[1859,30],[215,319],[480,2],[216,320],[83,2],[85,321],[479,30],[249,30],[1860,2],[1861,2],[1079,322],[1862,322],[1067,323],[1078,324],[735,325],[669,326],[734,327],[731,328],[737,329],[668,330],[732,331],[733,332],[738,333],[739,334],[740,334],[741,334],[742,333],[743,334],[745,335],[746,336],[747,2],[744,328],[748,336],[713,337],[656,338],[978,339],[882,340],[712,341],[979,337],[646,2],[649,342],[683,343],[980,2],[681,2],[682,2],[794,344],[981,345],[796,346],[650,347],[651,348],[727,2],[730,349],[729,350],[687,351],[982,352],[983,2],[863,2],[864,353],[984,354],[997,2],[998,2],[1068,355],[999,356],[1000,357],[670,358],[671,359],[672,360],[673,361],[985,362],[987,363],[988,364],[989,365],[990,364],[996,366],[986,365],[991,365],[992,364],[993,365],[994,364],[995,365],[1001,345],[1002,345],[1003,345],[1004,367],[970,345],[1006,368],[1007,345],[1008,369],[1020,370],[1009,368],[1010,371],[1011,368],[971,345],[1005,345],[1012,345],[1013,372],[1014,345],[1015,368],[1016,345],[1017,345],[1018,373],[1019,345],[1022,374],[1024,375],[1025,376],[1026,377],[1027,378],[1028,379],[1029,380],[1030,381],[1031,382],[1032,383],[1033,375],[1034,384],[1035,385],[848,386],[884,387],[883,388],[887,389],[685,390],[896,391],[872,392],[899,393],[898,394],[903,386],[890,395],[889,394],[1038,396],[1039,397],[1040,398],[1041,2],[1042,399],[1043,400],[1044,401],[1045,397],[1046,397],[1047,397],[1037,402],[1048,2],[1036,403],[1049,404],[1050,405],[1051,406],[850,407],[851,408],[724,409],[869,410],[852,411],[853,412],[854,413],[855,414],[856,415],[857,416],[858,414],[860,417],[859,414],[861,415],[862,407],[866,418],[865,419],[867,420],[868,407],[967,421],[966,422],[696,356],[678,423],[658,424],[657,425],[659,426],[653,427],[871,428],[1052,429],[663,2],[674,430],[1054,431],[772,2],[648,432],[654,433],[676,434],[652,435],[728,436],[675,437],[660,426],[895,426],[677,438],[647,439],[661,440],[655,441],[664,442],[665,442],[666,442],[667,442],[1053,442],[936,443],[787,444],[788,445],[789,446],[790,447],[791,447],[793,448],[798,449],[799,450],[800,447],[803,451],[805,452],[806,453],[804,454],[807,447],[808,447],[802,447],[809,455],[811,456],[814,457],[815,458],[816,459],[792,460],[817,447],[818,461],[819,462],[820,463],[821,464],[822,465],[823,466],[826,467],[825,468],[751,469],[752,470],[753,465],[754,447],[756,471],[940,472],[757,447],[755,465],[758,447],[760,473],[761,474],[764,475],[939,476],[765,447],[938,477],[759,447],[766,2],[768,478],[769,479],[824,480],[770,2],[912,481],[774,482],[785,483],[775,2],[776,484],[763,447],[778,485],[777,447],[779,447],[767,2],[781,486],[780,465],[782,447],[750,465],[771,447],[773,487],[783,447],[784,488],[749,2],[827,469],[828,489],[829,447],[830,490],[831,491],[832,490],[833,447],[834,492],[835,493],[836,447],[839,494],[840,495],[838,496],[933,497],[934,498],[935,499],[841,500],[842,447],[843,447],[844,447],[845,501],[846,469],[847,447],[879,502],[878,503],[877,504],[880,502],[881,502],[885,505],[886,502],[888,506],[892,507],[893,502],[897,508],[894,509],[849,447],[937,510],[901,511],[900,512],[902,507],[904,513],[875,472],[876,514],[891,515],[905,469],[907,447],[908,447],[906,516],[909,469],[910,469],[911,517],[913,481],[914,518],[915,519],[801,520],[812,447],[916,447],[917,469],[918,470],[919,521],[920,469],[921,447],[922,522],[923,523],[924,524],[925,447],[929,525],[926,526],[927,447],[928,469],[930,447],[931,466],[932,447],[813,527],[786,528],[662,328],[873,529],[684,328],[795,530],[1056,340],[1021,531],[1055,532],[1023,532],[714,533],[1057,531],[726,534],[810,535],[870,536],[1059,537],[1061,538],[977,539],[709,540],[719,541],[951,542],[941,543],[948,544],[947,2],[762,545],[958,546],[949,547],[942,548],[955,2],[874,549],[943,550],[952,2],[976,551],[950,2],[953,552],[680,553],[944,328],[945,554],[946,555],[972,556],[963,557],[969,558],[965,559],[964,560],[975,561],[679,344],[797,562],[956,563],[959,564],[960,565],[974,566],[973,352],[954,567],[968,568],[962,569],[957,570],[961,571],[1069,2],[1070,572],[695,573],[1071,574],[704,575],[705,576],[1072,577],[697,545],[720,578],[721,579],[698,2],[706,580],[1073,581],[701,582],[722,583],[707,584],[700,585],[723,586],[702,2],[703,587],[1074,2],[708,588],[710,589],[1076,590],[699,582],[1075,591],[717,592],[1077,593],[718,594],[692,550],[693,550],[694,595],[1062,357],[1063,596],[1064,596],[688,597],[689,357],[1058,597],[1060,597],[725,597],[686,357],[716,598],[837,357],[690,426],[691,599],[1066,600],[1065,357],[736,545],[711,2],[1863,2],[1864,601],[1550,602],[1531,603],[1529,604],[1530,2],[1549,605],[1528,606],[1532,607],[1535,608],[1533,609],[1525,610],[1527,611],[1534,612],[1526,611],[1524,613],[1523,2],[1547,614],[1546,606],[1536,606],[1548,615],[1545,616],[1551,617],[1537,618],[1538,616],[1544,616],[1543,616],[1542,616],[1539,616],[1541,616],[1540,616],[1552,619],[715,2],[179,2],[1421,51],[1658,2],[559,2],[84,2],[1443,2],[1856,620],[1855,2],[1433,2],[640,621],[639,2],[1853,622],[1854,623],[1395,51],[1396,51],[1398,624],[1397,625],[505,626],[510,627],[517,628],[500,629],[253,2],[261,630],[401,631],[404,632],[376,2],[389,633],[396,634],[278,2],[378,2],[259,2],[375,635],[421,636],[260,2],[251,637],[403,638],[405,639],[406,640],[477,641],[370,642],[323,643],[383,644],[384,645],[382,646],[381,2],[377,647],[402,648],[262,649],[447,2],[448,650],[289,651],[263,652],[290,651],[326,651],[229,651],[399,653],[398,2],[388,654],[495,2],[238,2],[516,655],[455,656],[456,657],[452,658],[534,2],[353,2],[457,659],[453,660],[539,661],[538,662],[533,2],[304,2],[356,663],[355,2],[532,664],[454,30],[309,665],[316,666],[318,667],[308,2],[313,668],[315,669],[317,670],[312,671],[310,2],[314,672],[535,2],[531,2],[537,673],[536,2],[307,674],[526,675],[529,676],[297,677],[296,678],[295,679],[542,30],[294,680],[283,2],[544,2],[545,30],[546,681],[221,2],[385,682],[386,683],[387,684],[225,2],[390,2],[245,685],[220,2],[469,30],[227,686],[468,687],[467,688],[458,2],[459,2],[466,2],[461,2],[464,689],[460,2],[462,690],[465,691],[463,690],[258,2],[255,2],[256,651],[410,2],[415,692],[416,693],[414,694],[412,695],[413,696],[408,2],[475,659],[250,659],[504,697],[511,698],[515,699],[344,700],[343,2],[338,2],[491,701],[499,702],[371,703],[372,704],[450,705],[360,2],[473,706],[348,30],[365,707],[476,708],[361,2],[364,709],[362,2],[474,710],[471,711],[470,2],[472,2],[368,2],[446,712],[233,713],[346,714],[350,715],[366,716],[369,717],[358,718],[351,719],[498,720],[424,721],[342,722],[230,723],[497,724],[226,725],[417,726],[409,2],[418,727],[435,728],[407,2],[434,729],[91,2],[429,730],[254,2],[449,731],[425,2],[239,2],[241,2],[380,2],[433,732],[257,2],[281,733],[367,734],[287,735],[347,2],[432,2],[411,2],[437,736],[438,737],[379,2],[440,738],[442,739],[441,740],[391,2],[431,723],[444,741],[341,742],[430,743],[436,744],[266,2],[270,2],[269,2],[268,2],[273,2],[267,2],[276,2],[275,2],[272,2],[271,2],[274,2],[277,745],[265,2],[333,746],[332,2],[337,747],[334,748],[336,749],[339,747],[335,748],[246,750],[325,751],[494,752],[492,2],[521,753],[523,754],[487,755],[522,756],[234,757],[231,757],[264,2],[248,758],[247,759],[243,760],[244,761],[252,762],[280,762],[291,762],[327,763],[292,763],[236,764],[235,2],[331,765],[330,766],[329,767],[328,768],[237,769],[478,770],[279,771],[486,772],[451,773],[481,774],[485,775],[374,776],[373,777],[354,778],[340,779],[322,780],[324,781],[321,782],[443,783],[345,2],[509,2],[242,784],[445,785],[493,786],[352,2],[282,787],[359,788],[357,789],[284,790],[419,791],[488,2],[285,792],[420,792],[507,2],[506,2],[508,2],[490,2],[489,2],[422,793],[349,2],[319,794],[240,795],[298,2],[224,796],[286,2],[513,30],[223,2],[525,797],[306,30],[519,659],[305,798],[502,799],[303,797],[228,2],[527,800],[301,30],[302,30],[293,2],[222,2],[300,801],[299,802],[288,803],[363,283],[423,283],[439,2],[427,804],[426,2],[311,674],[232,2],[320,30],[496,685],[503,805],[86,30],[89,806],[90,807],[87,30],[88,2],[400,305],[395,808],[394,2],[393,809],[392,2],[501,810],[512,811],[514,812],[518,813],[520,814],[524,815],[528,816],[551,817],[530,818],[540,819],[541,820],[543,821],[547,822],[550,685],[549,2],[548,823],[1852,824],[644,825],[1099,2],[428,826],[1438,2],[1445,51],[1148,51],[1149,51],[1151,827],[1150,51],[1176,828],[1196,829],[1193,829],[1190,830],[1186,2],[1188,830],[1197,830],[1195,829],[1191,830],[1192,2],[1194,829],[1189,51],[1187,830],[1256,831],[1255,51],[1257,832],[1258,2],[1378,51],[1376,51],[1377,51],[1375,51],[1379,51],[1313,51],[1314,51],[1312,51],[1310,51],[1311,51],[1315,51],[1147,51],[1143,51],[1142,51],[1139,51],[1144,51],[1146,51],[1141,51],[1145,51],[1140,51],[1250,51],[1248,51],[1251,51],[1160,51],[1247,833],[1246,51],[1249,51],[1252,51],[1254,834],[1367,51],[1370,51],[1368,51],[1372,51],[1371,51],[1369,51],[1381,835],[1305,51],[1306,51],[1307,51],[1308,836],[1380,2],[1241,837],[1374,51],[1373,2],[1366,838],[1361,839],[1362,51],[1365,840],[1360,51],[1363,840],[1364,839],[1345,51],[1334,51],[1347,51],[1331,51],[1323,51],[1341,51],[1324,51],[1338,51],[1238,51],[1333,51],[1316,51],[1253,51],[1340,51],[1240,841],[1352,842],[1325,843],[1239,51],[1350,51],[1343,51],[1337,51],[1318,51],[1358,51],[1328,51],[1349,51],[1332,51],[1348,51],[1321,51],[1319,844],[1346,845],[1357,51],[1353,51],[1359,51],[1354,51],[1339,51],[1330,51],[1355,51],[1320,51],[1344,51],[1342,51],[1317,51],[1329,51],[1351,51],[1356,51],[1327,51],[1326,846],[1336,51],[1322,51],[1335,51],[1181,51],[1182,51],[1177,51],[1183,2],[1185,51],[1178,51],[1180,51],[1184,847],[1179,2],[1117,51],[1119,51],[1120,51],[1125,51],[1116,51],[1121,51],[1118,51],[1129,51],[1122,51],[1123,2],[1128,51],[1126,848],[1127,844],[1124,2],[1135,51],[1137,51],[1136,51],[1138,51],[1152,51],[1166,51],[1157,51],[1161,849],[1159,51],[1154,850],[1163,51],[1162,851],[1155,850],[1156,51],[1164,51],[1158,51],[1165,850],[1309,51],[1214,852],[1219,853],[1230,854],[1212,852],[1202,852],[1216,852],[1223,855],[1221,852],[1208,856],[1204,857],[1205,852],[1201,858],[1220,852],[1209,852],[1198,51],[1227,852],[1228,852],[1217,852],[1206,852],[1225,852],[1210,852],[1224,859],[1211,852],[1200,860],[1226,861],[1213,852],[1215,852],[1231,852],[1130,51],[1131,51],[1132,51],[1133,51],[1259,862],[1218,862],[1260,863],[1261,862],[1262,2],[1263,862],[1175,51],[1264,2],[1265,51],[1266,51],[1229,862],[1267,862],[1268,2],[1269,862],[1203,2],[1222,51],[1270,51],[1207,2],[1271,2],[1272,51],[1273,2],[1274,862],[1275,51],[1276,2],[1277,862],[1278,2],[1279,2],[1280,2],[1281,51],[1282,2],[1283,2],[1284,51],[1285,2],[1286,2],[1287,2],[1288,862],[1289,51],[1290,51],[1291,51],[1292,2],[1293,51],[1294,2],[1295,2],[1296,2],[1297,51],[1298,51],[1299,2],[1300,862],[1301,2],[1302,2],[1303,51],[1304,2],[1199,51],[1134,2],[1153,2],[1173,51],[1174,51],[1169,51],[1170,51],[1167,51],[1172,51],[1171,51],[1168,51],[1232,837],[1234,864],[1235,51],[1236,51],[1237,51],[1242,865],[1243,837],[1233,51],[1245,866],[1244,867],[81,2],[82,2],[13,2],[14,2],[16,2],[15,2],[2,2],[17,2],[18,2],[19,2],[20,2],[21,2],[22,2],[23,2],[24,2],[3,2],[25,2],[26,2],[4,2],[27,2],[31,2],[28,2],[29,2],[30,2],[32,2],[33,2],[34,2],[5,2],[35,2],[36,2],[37,2],[38,2],[6,2],[42,2],[39,2],[40,2],[41,2],[43,2],[7,2],[44,2],[49,2],[50,2],[45,2],[46,2],[47,2],[48,2],[8,2],[54,2],[51,2],[52,2],[53,2],[55,2],[9,2],[56,2],[57,2],[58,2],[60,2],[59,2],[61,2],[62,2],[10,2],[63,2],[64,2],[65,2],[11,2],[66,2],[67,2],[68,2],[69,2],[70,2],[1,2],[71,2],[72,2],[12,2],[76,2],[74,2],[79,2],[78,2],[73,2],[77,2],[75,2],[80,2],[121,868],[133,869],[118,870],[134,871],[143,872],[109,873],[110,874],[108,875],[142,823],[137,876],[141,877],[112,878],[130,879],[111,880],[140,881],[106,882],[107,876],[113,883],[114,2],[120,884],[117,883],[104,885],[144,886],[135,887],[124,888],[123,883],[125,889],[128,890],[122,891],[126,892],[138,823],[115,893],[116,894],[129,895],[105,871],[132,896],[131,883],[119,894],[127,897],[136,2],[103,2],[139,898],[1080,2],[1083,2],[1084,899],[1081,900],[1082,901],[1088,902],[1087,903],[1089,903],[1086,2],[560,904],[565,905],[566,906],[562,907],[563,908],[564,909],[561,910],[572,911],[569,912],[570,913],[573,914],[571,913],[568,915],[555,915],[556,915],[577,916],[575,917],[576,917],[574,659],[578,918],[567,919],[581,920],[582,921],[580,922],[579,659],[1578,659],[1579,923],[1584,924],[1583,925],[1580,926],[1581,927],[1582,928],[584,929],[585,930],[583,915],[586,931],[1587,932],[1588,933],[1590,934],[1593,935],[1591,936],[1589,659],[1592,937],[1586,938],[588,939],[1585,659],[587,915],[1595,940],[1596,941],[1597,942],[1594,943],[1598,940],[1599,944],[1600,945],[589,915],[591,946],[1601,947],[1603,948],[1604,949],[1602,950],[1605,951],[1606,952],[596,953],[1607,954],[1611,955],[1608,956],[1613,957],[1612,958],[593,659],[592,915],[595,959],[597,960],[594,915],[1610,961],[1614,962],[600,963],[599,964],[601,963],[598,915],[1618,965],[1615,966],[602,967],[590,915],[558,915],[606,968],[603,915],[605,969],[604,915],[607,970],[1616,971],[621,972],[1576,973],[1575,974],[635,975],[622,976],[627,977],[624,915],[629,978],[630,978],[633,979],[626,980],[631,977],[632,981],[628,980],[625,915],[623,915],[634,982],[638,983],[1573,984],[1619,659],[1574,985],[637,986],[636,915],[1577,987],[554,2],[557,14],[1620,988],[1627,989],[1621,990],[1617,991],[1623,992],[1557,993],[1622,994],[1624,995],[1625,996],[1626,997],[1628,659],[1629,659],[1630,998],[1609,999],[641,1000],[642,1001],[645,1002]],"semanticDiagnosticsPerFile":[[626,[{"start":434,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":891,"length":7,"code":2769,"category":1,"messageText":{"messageText":"No overload matches this call.","category":1,"code":2769,"next":[{"messageText":"The last overload gave the following error.","category":1,"code":2770,"next":[{"messageText":"Argument of type 'string | number | symbol' is not assignable to parameter of type 'string | FunctionComponent<{ className: string; title: string; 'aria-label': string; style: { color?: string; fontSize?: FontSize<string | number>; accentColor?: AccentColor; alignContent?: AlignContent; ... 852 more ...; glyphOrientationVertical?: GlyphOrientationVertical; }; ... 273 more ...; \"aria-valuetext\"?: st...'.","category":1,"code":2345,"next":[{"messageText":"Type 'number' is not assignable to type 'string | FunctionComponent<{ className: string; title: string; 'aria-label': string; style: { color?: string; fontSize?: FontSize<string | number>; accentColor?: AccentColor; alignContent?: AlignContent; ... 852 more ...; glyphOrientationVertical?: GlyphOrientationVertical; }; ... 273 more ...; \"aria-valuetext\"?: st...'.","category":1,"code":2322}]}]}]},"relatedInformation":[{"file":"./node_modules/@types/react/index.d.ts","start":16286,"length":13,"messageText":"The last overload is declared here.","category":1,"code":2771}]}]],[632,[{"start":6761,"length":3,"code":2769,"category":1,"messageText":{"messageText":"No overload matches this call.","category":1,"code":2769,"next":[{"messageText":"The last overload gave the following error.","category":1,"code":2770,"next":[{"messageText":"Object literal may only specify known properties, and 'ref' does not exist in type 'Partial<unknown> & Attributes'.","category":1,"code":2353}]}]},"relatedInformation":[{"file":"./node_modules/@types/react/index.d.ts","start":17916,"length":12,"messageText":"The last overload is declared here.","category":1,"code":2771}]}]],[1557,[{"start":1007,"length":39,"messageText":"Cannot find module 'three/examples/jsm/capabilities/WebGL' or its corresponding type declarations.","category":1,"code":2307}]],[1573,[{"start":1714,"length":8,"code":2339,"category":1,"messageText":"Property 'children' does not exist on type 'unknown'."},{"start":1854,"length":4,"code":2339,"category":1,"messageText":"Property 'head' does not exist on type 'unknown'."}]],[1574,[{"start":11536,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":12873,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":13271,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":13372,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":13483,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":14478,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":14568,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":14738,"length":6,"messageText":"Expected 1 arguments, but got 0.","category":1,"code":2554,"relatedInformation":[{"file":"./node_modules/@types/react/index.d.ts","start":64745,"length":15,"messageText":"An argument for 'initialValue' was not provided.","category":3,"code":6210}]},{"start":26578,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":26739,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":28202,"length":7,"code":2769,"category":1,"messageText":{"messageText":"No overload matches this call.","category":1,"code":2769,"next":[{"messageText":"The last overload gave the following error.","category":1,"code":2770,"next":[{"messageText":"Argument of type 'string | number | symbol' is not assignable to parameter of type 'string | FunctionComponent<{ \"aria-hidden\": boolean; className: string; title: string; style?: CSSProperties; children?: ReactNode; draggable?: Booleanish; onClick?: MouseEventHandler<...>; ... 270 more ...; \"aria-valuetext\"?: string; }> | ComponentClass<...>'.","category":1,"code":2345,"next":[{"messageText":"Type 'number' is not assignable to type 'string | FunctionComponent<{ \"aria-hidden\": boolean; className: string; title: string; style?: CSSProperties; children?: ReactNode; draggable?: Booleanish; onClick?: MouseEventHandler<...>; ... 270 more ...; \"aria-valuetext\"?: string; }> | ComponentClass<...>'.","category":1,"code":2322}]}]}]},"relatedInformation":[{"file":"./node_modules/@types/react/index.d.ts","start":16286,"length":13,"messageText":"The last overload is declared here.","category":1,"code":2771}]},{"start":38187,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":39162,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":39200,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":39448,"length":15,"code":2741,"category":1,"messageText":"Property 'index' is missing in type '{ goto: ReactElement<unknown, string | JSXElementConstructor<any>> | ReactPortal; }' but required in type 'FootnoteProps'.","relatedInformation":[{"start":37849,"length":5,"messageText":"'index' is declared here.","category":3,"code":2728}],"canonicalHead":{"code":2322,"messageText":"Type '{ goto: ReactElement<unknown, string | JSXElementConstructor<any>> | ReactPortal; }' is not assignable to type 'FootnoteProps'."}},{"start":39468,"length":11,"messageText":"Spread types may only be created from object types.","category":1,"code":2698},{"start":39573,"length":5,"code":2339,"category":1,"messageText":"Property 'index' does not exist on type 'unknown'."},{"start":39594,"length":9,"code":2741,"category":1,"messageText":"Property 'index' is missing in type '{ is: \"reference\"; inline: true; }' but required in type 'FootnoteProps'.","relatedInformation":[{"start":37849,"length":5,"messageText":"'index' is declared here.","category":3,"code":2728}],"canonicalHead":{"code":2322,"messageText":"Type '{ is: \"reference\"; inline: true; }' is not assignable to type 'FootnoteProps'."}},{"start":39608,"length":11,"messageText":"Spread types may only be created from object types.","category":1,"code":2698},{"start":39823,"length":8,"code":2339,"category":1,"messageText":"Property 'children' does not exist on type 'unknown'."},{"start":39864,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":53653,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":53686,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":53726,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503},{"start":56578,"length":4,"code":2322,"category":1,"messageText":{"messageText":"Type '{ children: Element; icon: Element; intent: any; minimal: true; interactive: true; multiline: true; }' is not assignable to type 'IntrinsicAttributes & TagProps'.","category":1,"code":2322,"next":[{"messageText":"Property 'icon' does not exist on type 'IntrinsicAttributes & TagProps'.","category":1,"code":2339}]}},{"start":59137,"length":3,"messageText":"Cannot find namespace 'JSX'.","category":1,"code":2503}]],[1582,[{"start":744,"length":4,"code":2339,"category":1,"messageText":"Property 'then' does not exist on type 'FileEntry[]'."},{"start":750,"length":7,"messageText":"Parameter 'entries' implicitly has an 'any' type.","category":1,"code":7006}]],[1612,[{"start":5986,"length":4,"code":2339,"category":1,"messageText":"Property 'then' does not exist on type 'FileEntry[]'."},{"start":5992,"length":7,"messageText":"Parameter 'fetched' implicitly has an 'any' type.","category":1,"code":7006}]],[1616,[{"start":1725,"length":4,"code":2322,"category":1,"messageText":"Type 'Element' is not assignable to type 'string'.","relatedInformation":[{"file":"./src/lib/blueprintjs/Button.tsx","start":451,"length":4,"messageText":"The expected type comes from property 'icon' which is declared here on type 'IntrinsicAttributes & ButtonProps'","category":3,"code":6500}]}]],[1620,[{"start":5052,"length":8,"code":2339,"category":1,"messageText":"Property 'children' does not exist on type 'unknown'."}]],[1622,[{"start":504,"length":39,"messageText":"Cannot find module 'three/examples/jsm/capabilities/WebGL' or its corresponding type declarations.","category":1,"code":2307}]],[1624,[{"start":1962,"length":8,"code":2339,"category":1,"messageText":"Property 'children' does not exist on type 'unknown'."}]],[1626,[{"start":13036,"length":9,"code":2339,"category":1,"messageText":"Property 'positions' does not exist on type 'Graph'."},{"start":13079,"length":10,"code":2339,"category":1,"messageText":"Property 'velocities' does not exist on type 'Graph'."},{"start":13116,"length":10,"code":2339,"category":1,"messageText":"Property 'velocities' does not exist on type 'Graph'."},{"start":13224,"length":9,"code":2339,"category":1,"messageText":"Property 'positions' does not exist on type 'Graph'."},{"start":13298,"length":9,"code":2339,"category":1,"messageText":"Property 'positions' does not exist on type 'Graph'."},{"start":13335,"length":10,"code":2339,"category":1,"messageText":"Property 'velocities' does not exist on type 'Graph'."},{"start":21915,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":21920,"length":3,"messageText":"Parameter 'rot' implicitly has an 'any' type.","category":1,"code":7006},{"start":21925,"length":4,"messageText":"Parameter 'tilt' implicitly has an 'any' type.","category":1,"code":7006},{"start":21931,"length":7,"messageText":"Parameter 'camDist' implicitly has an 'any' type.","category":1,"code":7006},{"start":31567,"length":1,"messageText":"Parameter 'p' implicitly has an 'any' type.","category":1,"code":7006},{"start":38866,"length":3,"messageText":"Parameter 'now' implicitly has an 'any' type.","category":1,"code":7006}]],[1628,[{"start":515,"length":2,"messageText":"Parameter 'at' implicitly has an 'any' type.","category":1,"code":7006},{"start":530,"length":2,"code":2339,"category":1,"messageText":"Property 'op' does not exist on type 'Boundary'."},{"start":556,"length":2,"code":2339,"category":1,"messageText":"Property 'at' does not exist on type 'Boundary'."},{"start":574,"length":6,"code":2339,"category":1,"messageText":"Property 'target' does not exist on type 'Boundary'."},{"start":803,"length":9,"messageText":"Parameter 'direction' implicitly has an 'any' type.","category":1,"code":7006},{"start":825,"length":9,"code":2339,"category":1,"messageText":"Property 'direction' does not exist on type 'Ray'."},{"start":905,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":1338,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":1343,"length":8,"messageText":"Parameter 'isCenter' implicitly has an 'any' type.","category":1,"code":7006},{"start":1379,"length":7,"code":2339,"category":1,"messageText":"Property 'gridPos' does not exist on type 'GridNode'."},{"start":1432,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":1460,"length":3,"code":2339,"category":1,"messageText":"Property 'vel' does not exist on type 'GridNode'."},{"start":1493,"length":8,"code":2339,"category":1,"messageText":"Property 'isCenter' does not exist on type 'GridNode'."},{"start":1523,"length":8,"code":2339,"category":1,"messageText":"Property 'isPhoton' does not exist on type 'GridNode'."},{"start":1550,"length":6,"code":2339,"category":1,"messageText":"Property 'weight' does not exist on type 'GridNode'."},{"start":1618,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1696,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1803,"length":2,"messageText":"Parameter 'op' implicitly has an 'any' type.","category":1,"code":7006},{"start":1825,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1836,"length":3,"messageText":"Parameter 'ray' implicitly has an 'any' type.","category":1,"code":7006},{"start":2341,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":3176,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":3185,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":4064,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":4157,"length":6,"messageText":"Parameter 'prefix' implicitly has an 'any[]' type.","category":1,"code":7006},{"start":4560,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":4601,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":4981,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":5025,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":5096,"length":1,"messageText":"Parameter 'c' implicitly has an 'any' type.","category":1,"code":7006},{"start":5165,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":5490,"length":8,"code":2339,"category":1,"messageText":"Property 'isCenter' does not exist on type 'GridNode'."},{"start":5534,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":5543,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":5660,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":5700,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":6137,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6149,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":6152,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":6155,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":6180,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6318,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6386,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6490,"length":13,"messageText":"Object literal's property 'freeQueue' implicitly has an 'any[]' type.","category":1,"code":7018},{"start":7481,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":7486,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":7495,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":7517,"length":1,"messageText":"Parameter 'c' implicitly has an 'any' type.","category":1,"code":7006},{"start":7678,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":8634,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":8656,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":8659,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":8960,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":9000,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":9082,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":9541,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":9652,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":9657,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":9743,"length":6,"messageText":"Parameter 'prefix' implicitly has an 'any[]' type.","category":1,"code":7006},{"start":11417,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":11422,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":11637,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":11705,"length":1,"messageText":"Parameter 'n' implicitly has an 'any' type.","category":1,"code":7006},{"start":11755,"length":1,"messageText":"Binding element 'a' implicitly has an 'any' type.","category":1,"code":7031},{"start":11758,"length":1,"messageText":"Binding element 'b' implicitly has an 'any' type.","category":1,"code":7031},{"start":12187,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":12192,"length":4,"messageText":"Parameter 'keep' implicitly has an 'any' type.","category":1,"code":7006},{"start":12198,"length":4,"messageText":"Parameter 'from' implicitly has an 'any' type.","category":1,"code":7006},{"start":13095,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":13292,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":13297,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":13302,"length":3,"messageText":"Parameter 'dir' implicitly has an 'any' type.","category":1,"code":7006},{"start":13391,"length":8,"code":2339,"category":1,"messageText":"Property 'isPhoton' does not exist on type 'GridNode'."},{"start":13450,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":13488,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":13639,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":13644,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":13649,"length":3,"messageText":"Parameter 'dir' implicitly has an 'any' type.","category":1,"code":7006},{"start":13654,"length":8,"messageText":"Parameter 'reversed' implicitly has an 'any' type.","category":1,"code":7006},{"start":13811,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":13852,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":13892,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":13943,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":13982,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14024,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":14180,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":14578,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":14583,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":14646,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":14712,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":14717,"length":1,"messageText":"Parameter 'a' implicitly has an 'any' type.","category":1,"code":7006},{"start":14720,"length":1,"messageText":"Parameter 'b' implicitly has an 'any' type.","category":1,"code":7006},{"start":14982,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":14985,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":15073,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15109,"length":2,"messageText":"Parameter 'n1' implicitly has an 'any' type.","category":1,"code":7006},{"start":15113,"length":2,"messageText":"Parameter 'n2' implicitly has an 'any' type.","category":1,"code":7006},{"start":15117,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":15141,"length":3,"messageText":"Parameter 'ray' implicitly has an 'any' type.","category":1,"code":7006},{"start":15210,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":15213,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15216,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":15274,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15378,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15381,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":15767,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":15772,"length":1,"messageText":"Parameter 'a' implicitly has an 'any' type.","category":1,"code":7006},{"start":15775,"length":1,"messageText":"Parameter 'b' implicitly has an 'any' type.","category":1,"code":7006},{"start":15894,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15897,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":15964,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16015,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16930,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":16935,"length":8,"messageText":"Parameter 'attacker' implicitly has an 'any' type.","category":1,"code":7006},{"start":16945,"length":6,"messageText":"Parameter 'target' implicitly has an 'any' type.","category":1,"code":7006},{"start":17162,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":17165,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":17260,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":17494,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":17497,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":17500,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":18935,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":18940,"length":2,"messageText":"Parameter 'dt' implicitly has an 'any' type.","category":1,"code":7006},{"start":18944,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":23139,"length":6,"messageText":"Parameter 'prefix' implicitly has an 'any[]' type.","category":1,"code":7006},{"start":23680,"length":1,"messageText":"Parameter 'c' implicitly has an 'any' type.","category":1,"code":7006},{"start":29556,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":29613,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":29616,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":29995,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":30000,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":30005,"length":3,"messageText":"Parameter 'rot' implicitly has an 'any' type.","category":1,"code":7006},{"start":30010,"length":4,"messageText":"Parameter 'tilt' implicitly has an 'any' type.","category":1,"code":7006},{"start":30016,"length":7,"messageText":"Parameter 'camDist' implicitly has an 'any' type.","category":1,"code":7006},{"start":31003,"length":3,"messageText":"Parameter 'ctx' implicitly has an 'any' type.","category":1,"code":7006},{"start":31008,"length":6,"messageText":"Parameter 'canvas' implicitly has an 'any' type.","category":1,"code":7006},{"start":31016,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":31021,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":31026,"length":3,"messageText":"Parameter 'cam' implicitly has an 'any' type.","category":1,"code":7006},{"start":31031,"length":2,"messageText":"Parameter 'dt' implicitly has an 'any' type.","category":1,"code":7006},{"start":34189,"length":1,"messageText":"Parameter 'p' implicitly has an 'any' type.","category":1,"code":7006},{"start":35683,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":35686,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":37084,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":37143,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":37146,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":39638,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":40051,"length":3,"messageText":"Variable 'raf' implicitly has type 'any' in some locations where its type cannot be determined.","category":1,"code":7034},{"start":40814,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":41945,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":42123,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":42266,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":42575,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":42811,"length":3,"messageText":"Parameter 'now' implicitly has an 'any' type.","category":1,"code":7006},{"start":43539,"length":3,"messageText":"Variable 'raf' implicitly has an 'any' type.","category":1,"code":7005},{"start":43940,"length":6,"messageText":"Parameter 'active' implicitly has an 'any' type.","category":1,"code":7006}]],[1629,[{"start":515,"length":2,"messageText":"Parameter 'at' implicitly has an 'any' type.","category":1,"code":7006},{"start":530,"length":2,"code":2339,"category":1,"messageText":"Property 'op' does not exist on type 'Boundary'."},{"start":556,"length":2,"code":2339,"category":1,"messageText":"Property 'at' does not exist on type 'Boundary'."},{"start":574,"length":6,"code":2339,"category":1,"messageText":"Property 'target' does not exist on type 'Boundary'."},{"start":803,"length":9,"messageText":"Parameter 'direction' implicitly has an 'any' type.","category":1,"code":7006},{"start":825,"length":9,"code":2339,"category":1,"messageText":"Property 'direction' does not exist on type 'Ray'."},{"start":905,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":1338,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":1343,"length":8,"messageText":"Parameter 'isCenter' implicitly has an 'any' type.","category":1,"code":7006},{"start":1379,"length":7,"code":2339,"category":1,"messageText":"Property 'gridPos' does not exist on type 'GridNode'."},{"start":1432,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":1460,"length":3,"code":2339,"category":1,"messageText":"Property 'vel' does not exist on type 'GridNode'."},{"start":1493,"length":8,"code":2339,"category":1,"messageText":"Property 'isCenter' does not exist on type 'GridNode'."},{"start":1523,"length":8,"code":2339,"category":1,"messageText":"Property 'isPhoton' does not exist on type 'GridNode'."},{"start":1550,"length":6,"code":2339,"category":1,"messageText":"Property 'weight' does not exist on type 'GridNode'."},{"start":1618,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1696,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1803,"length":2,"messageText":"Parameter 'op' implicitly has an 'any' type.","category":1,"code":7006},{"start":1825,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":1836,"length":3,"messageText":"Parameter 'ray' implicitly has an 'any' type.","category":1,"code":7006},{"start":2341,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":3176,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":3185,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":4185,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":4194,"length":5,"messageText":"Parameter 'scale' implicitly has an 'any' type.","category":1,"code":7006},{"start":4243,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":4370,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":5026,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":5119,"length":6,"messageText":"Parameter 'prefix' implicitly has an 'any[]' type.","category":1,"code":7006},{"start":5522,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":5563,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":5943,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":5987,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":6058,"length":1,"messageText":"Parameter 'c' implicitly has an 'any' type.","category":1,"code":7006},{"start":6127,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6452,"length":8,"code":2339,"category":1,"messageText":"Property 'isCenter' does not exist on type 'GridNode'."},{"start":6496,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":6505,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":6622,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":6662,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":7099,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":7111,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":7114,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":7117,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":7142,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":7280,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":7348,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":7452,"length":13,"messageText":"Object literal's property 'freeQueue' implicitly has an 'any[]' type.","category":1,"code":7018},{"start":8443,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":8448,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":8457,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":8479,"length":1,"messageText":"Parameter 'c' implicitly has an 'any' type.","category":1,"code":7006},{"start":8640,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":9501,"length":3,"code":2339,"category":1,"messageText":"Property 'pos' does not exist on type 'GridNode'."},{"start":9519,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":9522,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":9823,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":9863,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":9945,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":10404,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":10515,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":10520,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":10606,"length":6,"messageText":"Parameter 'prefix' implicitly has an 'any[]' type.","category":1,"code":7006},{"start":12280,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":12285,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":12500,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":12568,"length":1,"messageText":"Parameter 'n' implicitly has an 'any' type.","category":1,"code":7006},{"start":12618,"length":1,"messageText":"Binding element 'a' implicitly has an 'any' type.","category":1,"code":7031},{"start":12621,"length":1,"messageText":"Binding element 'b' implicitly has an 'any' type.","category":1,"code":7031},{"start":13050,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":13055,"length":4,"messageText":"Parameter 'keep' implicitly has an 'any' type.","category":1,"code":7006},{"start":13061,"length":4,"messageText":"Parameter 'from' implicitly has an 'any' type.","category":1,"code":7006},{"start":13958,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":14155,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":14160,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":14165,"length":3,"messageText":"Parameter 'dir' implicitly has an 'any' type.","category":1,"code":7006},{"start":14254,"length":8,"code":2339,"category":1,"messageText":"Property 'isPhoton' does not exist on type 'GridNode'."},{"start":14313,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14351,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":14502,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":14507,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":14512,"length":3,"messageText":"Parameter 'dir' implicitly has an 'any' type.","category":1,"code":7006},{"start":14517,"length":8,"messageText":"Parameter 'reversed' implicitly has an 'any' type.","category":1,"code":7006},{"start":14674,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":14715,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14755,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14806,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14845,"length":10,"code":2339,"category":1,"messageText":"Property 'boundaries' does not exist on type 'Ray'."},{"start":14887,"length":4,"code":2339,"category":1,"messageText":"Property 'rays' does not exist on type 'GridNode'."},{"start":15043,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":15441,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":15446,"length":4,"messageText":"Parameter 'node' implicitly has an 'any' type.","category":1,"code":7006},{"start":15509,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15575,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":15580,"length":1,"messageText":"Parameter 'a' implicitly has an 'any' type.","category":1,"code":7006},{"start":15583,"length":1,"messageText":"Parameter 'b' implicitly has an 'any' type.","category":1,"code":7006},{"start":15845,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15848,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":15936,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":15972,"length":2,"messageText":"Parameter 'n1' implicitly has an 'any' type.","category":1,"code":7006},{"start":15976,"length":2,"messageText":"Parameter 'n2' implicitly has an 'any' type.","category":1,"code":7006},{"start":15980,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":16004,"length":3,"messageText":"Parameter 'ray' implicitly has an 'any' type.","category":1,"code":7006},{"start":16073,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":16076,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16079,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":16137,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16241,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16244,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":16630,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":16635,"length":1,"messageText":"Parameter 'a' implicitly has an 'any' type.","category":1,"code":7006},{"start":16638,"length":1,"messageText":"Parameter 'b' implicitly has an 'any' type.","category":1,"code":7006},{"start":16757,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16760,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":16827,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":16878,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":17793,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":17798,"length":8,"messageText":"Parameter 'attacker' implicitly has an 'any' type.","category":1,"code":7006},{"start":17808,"length":6,"messageText":"Parameter 'target' implicitly has an 'any' type.","category":1,"code":7006},{"start":18025,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":18028,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":18123,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":18357,"length":1,"messageText":"Parameter 's' implicitly has an 'any' type.","category":1,"code":7006},{"start":18360,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":18363,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":29771,"length":4,"messageText":"Parameter 'dims' implicitly has an 'any' type.","category":1,"code":7006},{"start":29788,"length":9,"code":2339,"category":1,"messageText":"Property 'available' does not exist on type 'GPUPhysics'."},{"start":29816,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":29843,"length":10,"code":2339,"category":1,"messageText":"Property 'frameCount' does not exist on type 'GPUPhysics'."},{"start":29868,"length":4,"code":2339,"category":1,"messageText":"Property 'dims' does not exist on type 'GPUPhysics'."},{"start":29890,"length":16,"code":2339,"category":1,"messageText":"Property 'gridCapacityRing' does not exist on type 'GPUPhysics'."},{"start":29921,"length":12,"code":2339,"category":1,"messageText":"Property 'poolCapacity' does not exist on type 'GPUPhysics'."},{"start":29948,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":30467,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":30561,"length":19,"code":2339,"category":1,"messageText":"Property 'usedOffscreenCanvas' does not exist on type 'GPUPhysics'."},{"start":30619,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'getExtension' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'getExtension' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":30690,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":30785,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":30805,"length":6,"code":2339,"category":1,"messageText":"Property 'canvas' does not exist on type 'GPUPhysics'."},{"start":30834,"length":11,"code":2339,"category":1,"messageText":"Property 'gridProgram' does not exist on type 'GPUPhysics'."},{"start":30929,"length":11,"code":2339,"category":1,"messageText":"Property 'gridProgram' does not exist on type 'GPUPhysics'."},{"start":30957,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":30974,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":31057,"length":11,"code":2339,"category":1,"messageText":"Property 'freeProgram' does not exist on type 'GPUPhysics'."},{"start":31147,"length":11,"code":2339,"category":1,"messageText":"Property 'freeProgram' does not exist on type 'GPUPhysics'."},{"start":31175,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":31192,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":31292,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'createBuffer' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'createBuffer' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31317,"length":10,"code":2339,"category":1,"messageText":{"messageText":"Property 'bindBuffer' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'bindBuffer' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31331,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'ARRAY_BUFFER' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'ARRAY_BUFFER' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31361,"length":10,"code":2339,"category":1,"messageText":{"messageText":"Property 'bufferData' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'bufferData' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31375,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'ARRAY_BUFFER' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'ARRAY_BUFFER' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31440,"length":11,"code":2339,"category":1,"messageText":{"messageText":"Property 'STATIC_DRAW' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'STATIC_DRAW' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31465,"length":4,"code":2339,"category":1,"messageText":"Property 'quad' does not exist on type 'GPUPhysics'."},{"start":31490,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":31694,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":31718,"length":18,"code":2339,"category":1,"messageText":{"messageText":"Property 'getUniformLocation' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'getUniformLocation' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31742,"length":11,"code":2339,"category":1,"messageText":"Property 'gridProgram' does not exist on type 'GPUPhysics'."},{"start":31781,"length":8,"code":2339,"category":1,"messageText":"Property 'gridAPos' does not exist on type 'GPUPhysics'."},{"start":31795,"length":17,"code":2339,"category":1,"messageText":{"messageText":"Property 'getAttribLocation' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'getAttribLocation' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":31818,"length":11,"code":2339,"category":1,"messageText":"Property 'gridProgram' does not exist on type 'GPUPhysics'."},{"start":31852,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":32015,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":32039,"length":18,"code":2339,"category":1,"messageText":{"messageText":"Property 'getUniformLocation' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'getUniformLocation' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":32063,"length":11,"code":2339,"category":1,"messageText":"Property 'freeProgram' does not exist on type 'GPUPhysics'."},{"start":32102,"length":8,"code":2339,"category":1,"messageText":"Property 'freeAPos' does not exist on type 'GPUPhysics'."},{"start":32116,"length":17,"code":2339,"category":1,"messageText":{"messageText":"Property 'getAttribLocation' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'getAttribLocation' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":32139,"length":11,"code":2339,"category":1,"messageText":"Property 'freeProgram' does not exist on type 'GPUPhysics'."},{"start":32173,"length":4,"code":2339,"category":1,"messageText":"Property '_fbo' does not exist on type 'GPUPhysics'."},{"start":32183,"length":17,"code":2339,"category":1,"messageText":{"messageText":"Property 'createFramebuffer' does not exist on type 'RenderingContext'.","category":1,"code":2339,"next":[{"messageText":"Property 'createFramebuffer' does not exist on type 'CanvasRenderingContext2D'.","category":1,"code":2339}]}},{"start":32215,"length":9,"code":2339,"category":1,"messageText":"Property 'available' does not exist on type 'GPUPhysics'."},{"start":32262,"length":9,"code":2339,"category":1,"messageText":"Property 'available' does not exist on type 'GPUPhysics'."},{"start":32292,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":32340,"length":7,"code":2339,"category":1,"messageText":"Property 'message' does not exist on type 'unknown'."},{"start":32352,"length":7,"code":2339,"category":1,"messageText":"Property 'message' does not exist on type 'unknown'."},{"start":32401,"length":2,"messageText":"Parameter 'gl' implicitly has an 'any' type.","category":1,"code":7006},{"start":32405,"length":5,"messageText":"Parameter 'vsSrc' implicitly has an 'any' type.","category":1,"code":7006},{"start":32412,"length":5,"messageText":"Parameter 'fsSrc' implicitly has an 'any' type.","category":1,"code":7006},{"start":32442,"length":4,"messageText":"Parameter 'type' implicitly has an 'any' type.","category":1,"code":7006},{"start":32448,"length":3,"messageText":"Parameter 'src' implicitly has an 'any' type.","category":1,"code":7006},{"start":32741,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":33302,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":33407,"length":2,"messageText":"Parameter 'gl' implicitly has an 'any' type.","category":1,"code":7006},{"start":33411,"length":1,"messageText":"Parameter 'w' implicitly has an 'any' type.","category":1,"code":7006},{"start":33414,"length":1,"messageText":"Parameter 'h' implicitly has an 'any' type.","category":1,"code":7006},{"start":34055,"length":10,"messageText":"Parameter 'ringRadius' implicitly has an 'any' type.","category":1,"code":7006},{"start":34067,"length":4,"messageText":"Parameter 'dims' implicitly has an 'any' type.","category":1,"code":7006},{"start":34102,"length":16,"code":2339,"category":1,"messageText":"Property 'gridCapacityRing' does not exist on type 'GPUPhysics'."},{"start":34127,"length":9,"code":2339,"category":1,"messageText":"Property 'sliceSize' does not exist on type 'GPUPhysics'."},{"start":34166,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":34229,"length":16,"code":2339,"category":1,"messageText":"Property 'gridCapacityRing' does not exist on type 'GPUPhysics'."},{"start":34299,"length":9,"code":2339,"category":1,"messageText":"Property 'sliceSize' does not exist on type 'GPUPhysics'."},{"start":34331,"length":10,"code":2339,"category":1,"messageText":"Property 'gridOffset' does not exist on type 'GPUPhysics'."},{"start":34456,"length":6,"code":2339,"category":1,"messageText":"Property 'atlasW' does not exist on type 'GPUPhysics'."},{"start":34482,"length":6,"code":2339,"category":1,"messageText":"Property 'atlasH' does not exist on type 'GPUPhysics'."},{"start":34605,"length":19,"code":7053,"category":1,"messageText":{"messageText":"Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'GPUPhysics'.","category":1,"code":7053,"next":[{"messageText":"No index signature with a parameter of type 'string' was found on type 'GPUPhysics'.","category":1,"code":7054}]}},{"start":34679,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridPos' does not exist on type 'GPUPhysics'."},{"start":34742,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridPos2' does not exist on type 'GPUPhysics'."},{"start":34806,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridVel' does not exist on type 'GPUPhysics'."},{"start":34869,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridVel2' does not exist on type 'GPUPhysics'."},{"start":34933,"length":16,"code":2339,"category":1,"messageText":"Property '_tex_gridRewired' does not exist on type 'GPUPhysics'."},{"start":35001,"length":8,"code":2339,"category":1,"messageText":"Property '_gridBuf' does not exist on type 'GPUPhysics'."},{"start":35454,"length":1,"messageText":"Parameter 'n' implicitly has an 'any' type.","category":1,"code":7006},{"start":35477,"length":12,"code":2339,"category":1,"messageText":"Property 'poolCapacity' does not exist on type 'GPUPhysics'."},{"start":35498,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexW' does not exist on type 'GPUPhysics'."},{"start":35536,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":35666,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexW' does not exist on type 'GPUPhysics'."},{"start":35692,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexH' does not exist on type 'GPUPhysics'."},{"start":35718,"length":12,"code":2339,"category":1,"messageText":"Property 'poolCapacity' does not exist on type 'GPUPhysics'."},{"start":35759,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":35775,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":35797,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":35818,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":35874,"length":8,"code":2339,"category":1,"messageText":"Property '_poolBuf' does not exist on type 'GPUPhysics'."},{"start":35907,"length":12,"code":2339,"category":1,"messageText":"Property 'poolCapacity' does not exist on type 'GPUPhysics'."},{"start":36140,"length":1,"messageText":"Parameter 'n' implicitly has an 'any' type.","category":1,"code":7006},{"start":36163,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":36184,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":36222,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":36377,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":36403,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":36429,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":36579,"length":19,"code":7053,"category":1,"messageText":{"messageText":"Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'GPUPhysics'.","category":1,"code":7053,"next":[{"messageText":"No index signature with a parameter of type 'string' was found on type 'GPUPhysics'.","category":1,"code":7054}]}},{"start":36653,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freePos' does not exist on type 'GPUPhysics'."},{"start":36712,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freePos2' does not exist on type 'GPUPhysics'."},{"start":36772,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freeVel' does not exist on type 'GPUPhysics'."},{"start":36831,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freeVel2' does not exist on type 'GPUPhysics'."},{"start":36891,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredA' does not exist on type 'GPUPhysics'."},{"start":36955,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredB' does not exist on type 'GPUPhysics'."},{"start":37019,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":37065,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37117,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37168,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37219,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37274,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37329,"length":12,"code":2339,"category":1,"messageText":"Property 'freeCapacity' does not exist on type 'GPUPhysics'."},{"start":37369,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":37374,"length":2,"messageText":"Parameter 'dt' implicitly has an 'any' type.","category":1,"code":7006},{"start":37378,"length":4,"messageText":"Parameter 'dims' implicitly has an 'any' type.","category":1,"code":7006},{"start":37529,"length":2,"code":2339,"category":1,"messageText":"Property 'gl' does not exist on type 'GPUPhysics'."},{"start":37870,"length":9,"code":2339,"category":1,"messageText":"Property 'sliceSize' does not exist on type 'GPUPhysics'."},{"start":37895,"length":10,"code":2339,"category":1,"messageText":"Property 'gridOffset' does not exist on type 'GPUPhysics'."},{"start":37921,"length":6,"code":2339,"category":1,"messageText":"Property 'atlasW' does not exist on type 'GPUPhysics'."},{"start":37943,"length":6,"code":2339,"category":1,"messageText":"Property 'atlasH' does not exist on type 'GPUPhysics'."},{"start":37973,"length":8,"code":2339,"category":1,"messageText":"Property '_gridBuf' does not exist on type 'GPUPhysics'."},{"start":38008,"length":8,"code":2339,"category":1,"messageText":"Property '_poolBuf' does not exist on type 'GPUPhysics'."},{"start":38158,"length":7,"messageText":"Parameter 'gridPos' implicitly has an 'any' type.","category":1,"code":7006},{"start":39898,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":42175,"length":3,"messageText":"Parameter 'tex' implicitly has an 'any' type.","category":1,"code":7006},{"start":42180,"length":1,"messageText":"Parameter 'w' implicitly has an 'any' type.","category":1,"code":7006},{"start":42183,"length":1,"messageText":"Parameter 'h' implicitly has an 'any' type.","category":1,"code":7006},{"start":42186,"length":4,"messageText":"Parameter 'data' implicitly has an 'any' type.","category":1,"code":7006},{"start":42343,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridPos' does not exist on type 'GPUPhysics'."},{"start":42402,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridVel' does not exist on type 'GPUPhysics'."},{"start":42461,"length":16,"code":2339,"category":1,"messageText":"Property '_tex_gridRewired' does not exist on type 'GPUPhysics'."},{"start":42528,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":42544,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexW' does not exist on type 'GPUPhysics'."},{"start":42559,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexH' does not exist on type 'GPUPhysics'."},{"start":42597,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freePos' does not exist on type 'GPUPhysics'."},{"start":42616,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":42631,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":42673,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freeVel' does not exist on type 'GPUPhysics'."},{"start":42692,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":42707,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":42749,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredA' does not exist on type 'GPUPhysics'."},{"start":42773,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":42788,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":42829,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredB' does not exist on type 'GPUPhysics'."},{"start":42853,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":42868,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":43038,"length":4,"code":2339,"category":1,"messageText":"Property '_fbo' does not exist on type 'GPUPhysics'."},{"start":43131,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridPos2' does not exist on type 'GPUPhysics'."},{"start":43236,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridVel2' does not exist on type 'GPUPhysics'."},{"start":43413,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":43564,"length":11,"code":2339,"category":1,"messageText":"Property 'gridProgram' does not exist on type 'GPUPhysics'."},{"start":43618,"length":4,"code":2339,"category":1,"messageText":"Property 'quad' does not exist on type 'GPUPhysics'."},{"start":43661,"length":8,"code":2339,"category":1,"messageText":"Property 'gridAPos' does not exist on type 'GPUPhysics'."},{"start":43704,"length":8,"code":2339,"category":1,"messageText":"Property 'gridAPos' does not exist on type 'GPUPhysics'."},{"start":43763,"length":4,"messageText":"Parameter 'unit' implicitly has an 'any' type.","category":1,"code":7006},{"start":43769,"length":3,"messageText":"Parameter 'tex' implicitly has an 'any' type.","category":1,"code":7006},{"start":43774,"length":7,"messageText":"Parameter 'uniform' implicitly has an 'any' type.","category":1,"code":7006},{"start":43898,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":43956,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridPos' does not exist on type 'GPUPhysics'."},{"start":44004,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_gridVel' does not exist on type 'GPUPhysics'."},{"start":44052,"length":16,"code":2339,"category":1,"messageText":"Property '_tex_gridRewired' does not exist on type 'GPUPhysics'."},{"start":44108,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":44154,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44215,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44260,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44335,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44384,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44437,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44496,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44553,"length":12,"code":2339,"category":1,"messageText":"Property 'gridUniforms' does not exist on type 'GPUPhysics'."},{"start":44585,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexW' does not exist on type 'GPUPhysics'."},{"start":44600,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexH' does not exist on type 'GPUPhysics'."},{"start":44790,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":44805,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":44904,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freePos2' does not exist on type 'GPUPhysics'."},{"start":45011,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freeVel2' does not exist on type 'GPUPhysics'."},{"start":45194,"length":9,"code":2339,"category":1,"messageText":"Property 'lastError' does not exist on type 'GPUPhysics'."},{"start":45351,"length":11,"code":2339,"category":1,"messageText":"Property 'freeProgram' does not exist on type 'GPUPhysics'."},{"start":45407,"length":4,"code":2339,"category":1,"messageText":"Property 'quad' does not exist on type 'GPUPhysics'."},{"start":45452,"length":8,"code":2339,"category":1,"messageText":"Property 'freeAPos' does not exist on type 'GPUPhysics'."},{"start":45497,"length":8,"code":2339,"category":1,"messageText":"Property 'freeAPos' does not exist on type 'GPUPhysics'."},{"start":45558,"length":4,"messageText":"Parameter 'unit' implicitly has an 'any' type.","category":1,"code":7006},{"start":45564,"length":3,"messageText":"Parameter 'tex' implicitly has an 'any' type.","category":1,"code":7006},{"start":45569,"length":7,"messageText":"Parameter 'uniform' implicitly has an 'any' type.","category":1,"code":7006},{"start":45699,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":45761,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freePos' does not exist on type 'GPUPhysics'."},{"start":45811,"length":12,"code":2339,"category":1,"messageText":"Property '_tex_freeVel' does not exist on type 'GPUPhysics'."},{"start":45861,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredA' does not exist on type 'GPUPhysics'."},{"start":45921,"length":17,"code":2339,"category":1,"messageText":"Property '_tex_freeRewiredB' does not exist on type 'GPUPhysics'."},{"start":45981,"length":9,"code":2339,"category":1,"messageText":"Property '_tex_pool' does not exist on type 'GPUPhysics'."},{"start":46029,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":46076,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":46127,"length":12,"code":2339,"category":1,"messageText":"Property 'freeUniforms' does not exist on type 'GPUPhysics'."},{"start":46159,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexW' does not exist on type 'GPUPhysics'."},{"start":46174,"length":8,"code":2339,"category":1,"messageText":"Property 'poolTexH' does not exist on type 'GPUPhysics'."},{"start":46318,"length":4,"code":2339,"category":1,"messageText":"Property '_fbo' does not exist on type 'GPUPhysics'."},{"start":46411,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridPos2' does not exist on type 'GPUPhysics'."},{"start":46516,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_gridVel2' does not exist on type 'GPUPhysics'."},{"start":46950,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freePos2' does not exist on type 'GPUPhysics'."},{"start":47057,"length":13,"code":2339,"category":1,"messageText":"Property '_tex_freeVel2' does not exist on type 'GPUPhysics'."},{"start":47218,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":47233,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":47267,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":47359,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexW' does not exist on type 'GPUPhysics'."},{"start":47374,"length":8,"code":2339,"category":1,"messageText":"Property 'freeTexH' does not exist on type 'GPUPhysics'."},{"start":47408,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":48201,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":48365,"length":8,"code":2339,"category":1,"messageText":"Property '_freeBuf' does not exist on type 'GPUPhysics'."},{"start":48471,"length":10,"code":2339,"category":1,"messageText":"Property 'frameCount' does not exist on type 'GPUPhysics'."},{"start":48494,"length":10,"code":2339,"category":1,"messageText":"Property 'lastTiming' does not exist on type 'GPUPhysics'."},{"start":48660,"length":4,"code":2339,"category":1,"messageText":"Property 'texW' does not exist on type 'GPUPhysics'."},{"start":48729,"length":4,"code":2339,"category":1,"messageText":"Property 'texH' does not exist on type 'GPUPhysics'."},{"start":48782,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":48787,"length":2,"messageText":"Parameter 'dt' implicitly has an 'any' type.","category":1,"code":7006},{"start":48791,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":56569,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":56626,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":56629,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":57058,"length":3,"messageText":"Parameter 'pos' implicitly has an 'any' type.","category":1,"code":7006},{"start":57063,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":57068,"length":3,"messageText":"Parameter 'rot' implicitly has an 'any' type.","category":1,"code":7006},{"start":57073,"length":4,"messageText":"Parameter 'tilt' implicitly has an 'any' type.","category":1,"code":7006},{"start":57079,"length":7,"messageText":"Parameter 'camDist' implicitly has an 'any' type.","category":1,"code":7006},{"start":58066,"length":3,"messageText":"Parameter 'ctx' implicitly has an 'any' type.","category":1,"code":7006},{"start":58071,"length":6,"messageText":"Parameter 'canvas' implicitly has an 'any' type.","category":1,"code":7006},{"start":58079,"length":3,"messageText":"Parameter 'sim' implicitly has an 'any' type.","category":1,"code":7006},{"start":58084,"length":3,"messageText":"Parameter 'dim' implicitly has an 'any' type.","category":1,"code":7006},{"start":58089,"length":3,"messageText":"Parameter 'cam' implicitly has an 'any' type.","category":1,"code":7006},{"start":58094,"length":2,"messageText":"Parameter 'dt' implicitly has an 'any' type.","category":1,"code":7006},{"start":58098,"length":13,"messageText":"Parameter 'showGridLines' implicitly has an 'any' type.","category":1,"code":7006},{"start":61267,"length":1,"messageText":"Parameter 'p' implicitly has an 'any' type.","category":1,"code":7006},{"start":62713,"length":7,"messageText":"Variable 'sources' implicitly has type 'any[]' in some locations where its type cannot be determined.","category":1,"code":7034},{"start":64113,"length":1,"messageText":"Parameter 't' implicitly has an 'any' type.","category":1,"code":7006},{"start":64116,"length":5,"messageText":"Parameter 'alpha' implicitly has an 'any' type.","category":1,"code":7006},{"start":64619,"length":7,"messageText":"Variable 'samples' implicitly has type 'any[]' in some locations where its type cannot be determined.","category":1,"code":7034},{"start":64712,"length":4,"messageText":"Parameter 'axis' implicitly has an 'any' type.","category":1,"code":7006},{"start":65371,"length":7,"messageText":"Variable 'sources' implicitly has an 'any[]' type.","category":1,"code":7005},{"start":66139,"length":7,"messageText":"Variable 'samples' implicitly has an 'any[]' type.","category":1,"code":7005},{"start":68310,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":68313,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":69711,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":69770,"length":1,"messageText":"Parameter 'v' implicitly has an 'any' type.","category":1,"code":7006},{"start":69773,"length":1,"messageText":"Parameter 'k' implicitly has an 'any' type.","category":1,"code":7006},{"start":72522,"length":1,"messageText":"Parameter 'd' implicitly has an 'any' type.","category":1,"code":7006},{"start":73102,"length":3,"messageText":"Variable 'raf' implicitly has type 'any' in some locations where its type cannot be determined.","category":1,"code":7034},{"start":73865,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":74996,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":75174,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":75317,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":75626,"length":1,"messageText":"Parameter 'e' implicitly has an 'any' type.","category":1,"code":7006},{"start":75862,"length":3,"messageText":"Parameter 'now' implicitly has an 'any' type.","category":1,"code":7006},{"start":76557,"length":7,"code":2339,"category":1,"messageText":"Property 'stepRaw' does not exist on type '{ step: any; draw: any; }'."},{"start":78193,"length":7,"code":2339,"category":1,"messageText":"Property 'stepRaw' does not exist on type '{ step: any; draw: any; }'."},{"start":78895,"length":3,"messageText":"Variable 'raf' implicitly has an 'any' type.","category":1,"code":7005},{"start":79311,"length":6,"messageText":"Parameter 'active' implicitly has an 'any' type.","category":1,"code":7006}]],[1635,[{"start":307,"length":15,"messageText":"'ProfileRedirect', which lacks return-type annotation, implicitly has an 'any' return type.","category":1,"code":7010}]],[1644,[{"start":197,"length":14,"messageText":"'PapersRedirect', which lacks return-type annotation, implicitly has an 'any' return type.","category":1,"code":7010}]]],"affectedFilesPendingEmit":[1652,1650,1638,1642,1643,1631,1632,1633,1634,1639,1640,1641,1644,1645,1635,1636,1637,1646,1647,560,565,566,562,563,564,561,572,569,570,573,571,568,555,556,577,575,576,574,578,567,581,582,580,579,1578,1579,1584,1583,1580,1581,1582,584,585,583,586,1587,1588,1590,1593,1591,1589,1592,1586,588,1585,587,1595,1596,1597,1594,1598,1599,1600,589,591,1601,1603,1604,1602,1605,1606,596,1607,1611,1608,1613,1612,593,592,595,597,594,1610,1614,600,599,601,598,1618,1615,602,590,558,606,603,605,604,607,1616,621,1576,1575,635,622,627,624,629,630,633,626,631,632,628,625,623,634,638,1573,1619,1574,637,636,1577,557,1620,1627,1621,1617,1623,1557,1622,1624,1625,1626,1628,1629,1630,1609,641,642,645],"version":"5.9.3"}
\ No newline at end of file

From 538755862b7afa565924076bd6fe3da3b6f42025 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Thu, 6 Aug 2026 17:17:24 +0200
Subject: [PATCH 08/47] First attempt at 3D

---
 .../archive/2026.RayCalculiAndPhysics.tsx     | 2828 ++++++++++++++++-
 1 file changed, 2700 insertions(+), 128 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index 6d94acd..ab3c17f 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -42,6 +42,70 @@ type LineSide = {
   moving: 'left' | 'right';
 };
 
+// One source in a space with directions to spare: what it emits, which of
+// those directions it is itself going in, and whether it starts turned the
+// same way round as the other one or the other way.
+//
+// `moving` is a lattice step, not a named side. With twenty-six ways out of a
+// point there is no "left" to mean anything, so a direction has to be said in
+// full — and saying it in full is what lets the two be set going across each
+// other rather than only at each other.
+type MagnetSide = {
+  emits: Polarity;
+  moving?: number[];
+  phase?: number;
+
+  /**
+   * Which way round it is, if it is a magnet rather than a lamp.
+   *
+   * Without this a source puts the same charge out in all twenty-six
+   * directions and turns the lot over together — something that alternates,
+   * but with no sides to it. A magnet has sides: `emits` goes out of the half
+   * pointing along this, its opposite out of the half pointing against, and
+   * the ring exactly across it puts out nothing at all. Turning it over swaps
+   * the two, which is what `spin` was always meant to be doing to something.
+   *
+   * It matters for two magnets facing each other because it decides what
+   * arrives. Both given the same axis, the face of one that looks at the
+   * other is its north and the face looking back is the other's south — so
+   * what crosses the gap is opposite to what it meets, every tick, and
+   * opposite charges meeting is the one event that destroys space.
+   */
+  axis?: number[];
+};
+
+/**
+ * How much harder a source is to move than the charges it emits: a multiple
+ * of the step's own length, paid out of the same one-per-tick everything else
+ * is paid (see the movement half of `tick`). It is mass, arrived at from the
+ * only direction this model offers — the cost of going somewhere.
+ *
+ * A source at mass m covers 1/m cells a tick. Two conditions decide whether a
+ * moving pair can interact at all, and both are arithmetic rather than
+ * judgement:
+ *
+ *  - One step a tick is this model's top speed — a ray moves at most once per
+ *    tick, so nothing goes faster and the field cannot be sped up to keep
+ *    pace. Two sources heading opposite ways separate at 2/m, and their light
+ *    closes at 1, so anything each emits can only ever reach the other while
+ *    2/m < 1. At m = 1 they are outrunning their own field from the first
+ *    tick; at m = 2 the light exactly keeps pace and never gains. It takes
+ *    m > 2 before a pulse can cross from one to the other at all.
+ *
+ *  - And a source can only emit onto a point it is connected to. Once it has
+ *    travelled out of the seeded ball it is in territory `grow` laid down one
+ *    node at a time as it went, with nothing on the far side of its other
+ *    twenty-five directions, so it stops radiating in all but the one it is
+ *    heading in. Over a 60-tick run it moves 60/m, and starting 8 out along x
+ *    it stays inside the absorbing edge at 11 while √(8² + (60/m)²) ≤ 11 —
+ *    which wants m ≥ 8.
+ *
+ * Eight, then. Not a tuned number: it is the smaller mass the two conditions
+ * allow, and below it a moving pair stops interacting partway through for one
+ * of those two reasons rather than for any reason to do with the physics.
+ */
+const MAGNET_MASS = 3;
+
 class Universe {
   static _2D = () => Universe.nD_Expanding(2);
   static _3D = () => Universe.nD_Expanding(3);
@@ -95,6 +159,75 @@ function stepAway(from: number[], to: number[]): number[] {
   );
 }
 
+/**
+ * The direction a lattice offset names, as the shortest step that goes that
+ * way: every component in {-1, 0, 1}.
+ *
+ * (1,0,0) is already one step. (3,0,0) is the same direction, three steps at
+ * a time — which is what a connection looks like once the space it used to
+ * pass through has been annihilated out of it. (2,2,0) is the diagonal
+ * (1,1,0).
+ *
+ * This is what keeps a direction a direction rather than a distance. It is
+ * also what a boundary with no neighbour has to hold: `outward` is a way to
+ * go, and a way to go is one step, however far apart the last two points that
+ * went that way happened to end up.
+ */
+function latticeStep(offset: number[]): number[] | undefined {
+  const norm = Math.max(...offset.map(Math.abs));
+  if (!norm) return undefined;
+
+  return offset.map(v => Math.round(v / norm));
+}
+
+/**
+ * Every way out of a point: all 3^d − 1 non-zero offsets with components in
+ * {-1, 0, 1}. In 2D that is the eight directions of a compass rose; in 3D the
+ * twenty-six ways off a cell — six through a face, twelve through an edge,
+ * eight through a corner.
+ *
+ * This is what "360°" is when space is discrete. Not a circle cut into 360
+ * pieces: a lattice has exactly as many directions as a point has neighbours,
+ * and the honest thing is to take all of them rather than the six that happen
+ * to line up with the axes. A point wired only to its faces cannot be moved
+ * through diagonally, so a wave leaving it can only ever go six ways, and
+ * anything built on that is a cross rather than a sphere.
+ *
+ * The price is that the directions are not the same length — a face step
+ * covers 1, an edge step √2, a corner step √3 — so a pulse emitted into all
+ * of them at once, one step per tick, is a cube shell and not a round one.
+ * That IS the sphere of this space: the set of points one move away.
+ */
+// The subset of those that lie along an axis: the 2d faces of a cell. A
+// lattice wired only with these is the one everything up to here has run on.
+function axes(dims: number): number[][] {
+  const out: number[][] = [];
+
+  for (let axis = 0; axis < dims; axis++)
+    for (const dir of [-1, 1]) {
+      const v = new Array(dims).fill(0);
+      v[axis] = dir;
+      out.push(v);
+    }
+
+  return out;
+}
+
+function directions(dims: number): number[][] {
+  const out: number[][] = [];
+
+  (function build(prefix: number[]) {
+    if (prefix.length === dims) {
+      if (prefix.some(v => v !== 0)) out.push(prefix);
+      return;
+    }
+
+    for (const v of [-1, 0, 1]) build([...prefix, v]);
+  })([]);
+
+  return out;
+}
+
 class Graph {
   buffer: node[] = []
 
@@ -104,14 +237,256 @@ class Graph {
 
   gridPos = new Map<node, number[]>();
 
+  // gridPos read the other way round, so that "what is at this coordinate"
+  // isn't a scan over the whole universe. Positions are real-valued and two
+  // points can briefly share one, so this is last-writer-wins: it is an
+  // index, and `gridPos` above is the truth it indexes.
+  private at = new Map<string, node>();
+
+  private static posKey(pos: number[]): string {
+    return pos.map(v => Math.round(v * 1e6)).join(",");
+  }
+
+  // Every write to a position goes through these, so the index can never
+  // fall behind the thing it indexes.
+  private setPos(nd: node, pos: number[]) {
+    this.unindex(nd);
+    this.gridPos.set(nd, pos);
+    this.at.set(Graph.posKey(pos), nd);
+  }
+
+  private delPos(nd: node) {
+    this.unindex(nd);
+    this.gridPos.delete(nd);
+  }
+
+  private unindex(nd: node) {
+    const was = this.gridPos.get(nd);
+    if (!was) return;
+
+    const key = Graph.posKey(was);
+    if (this.at.get(key) === nd) this.at.delete(key);
+  }
+
   // Lattice dimensionality and the seed's initial radius (used only by the
   // cube→sphere layout morph now).
   dims = 3;
   ringRadius = 0;
 
+  /**
+   * What the camera is for, if it isn't for everything: a radius in grid
+   * coordinates, and everything inside it is the subject.
+   *
+   * A universe that grows has no fixed size to frame, and framing whatever is
+   * currently furthest out means the picture zooms out to chase whichever
+   * charge has got the furthest — so the thing being watched shrinks away in
+   * the middle while nothing much happens at the edges.
+   *
+   * It has to be a region rather than a list of the points that were there at
+   * the start, because those points do not stay. Moving is a swap with space:
+   * every charge that goes anywhere eats a point of the original ball and
+   * leaves a new one behind it. Name the seed's points and within a few ticks
+   * you are framing a handful of survivors; name the seed's extent and you
+   * are framing the same place throughout, whatever is currently in it.
+   */
+  focus?: number;
+
+  inFocus(nd: node): boolean {
+    if (this.focus === undefined) return true;
+
+    const pos = this.gridPos.get(nd);
+
+    return !!pos && Math.hypot(...pos) <= this.focus;
+  }
+
+  /**
+   * How often a ray takes one of the ways its direction is made of, instead
+   * of the direction itself. Nought is movement strictly conserved, which is
+   * what everything before this ran on.
+   *
+   * A direction like (1,1,1) is not one thing: it is three axial steps taken
+   * at once, and a point that can go that way can also go any of the three
+   * separately, or any of them backwards. So at each move a ray either
+   * carries on along the whole diagonal or takes one of the pieces it is
+   * composed of — chosen at random, with the pieces' opposites in the draw
+   * too, so it can give ground on an axis as well as gain it.
+   *
+   * What that buys is the thing a field made of travelling charges needs and
+   * did not have: a path that can curve. Movement conserved exactly means a
+   * ray leaves its source in one of twenty-six directions and is committed to
+   * it forever, so two streams either coincide or never touch, and no line
+   * can go looking for anything. Wandering makes a trajectory a random walk
+   * with a drift down its original direction, which spreads it over the space
+   * between — and since annihilation removes exactly those that find their
+   * opposite, what survives to be seen is selected by what met. The lines
+   * find each other by searching and being culled where they succeed, rather
+   * than by being aimed.
+   *
+   * The drift is what keeps it a field rather than a fog: the whole diagonal
+   * is one option among its pieces, and the pieces' opposites cancel in the
+   * average, so the mean step still points the way it set out.
+   */
+  wander = 0;
+
+  /**
+   * No holes, ever.
+   *
+   * A direction with nothing on the far side of it is a way out of the
+   * lattice. In a line that is exactly right — the end of a line is where you
+   * can walk off it, and growing the structure by moving into nothing is how
+   * these universes expand. In a closed lattice it is a tear, and every rule
+   * that removes a point has been quietly making them: hundreds a tick, tens
+   * of thousands over a run, all of them in the region where the two fields
+   * are trying to reach each other.
+   *
+   * Sealed, a direction is a direction TO something. Take away what it
+   * pointed at and it is not a direction any more — it is dropped, and
+   * whatever else the vanished point joined stays joined (`closeUp`). Nothing
+   * is ever left facing nowhere, so nothing can leak out through a face that
+   * was never there, and the space contracts instead of coming apart.
+   *
+   * Off by default: the line and grid seeds are open worlds with real edges,
+   * and they need to be able to grow.
+   */
+  sealed = false;
+
+  // A direction that is not one any more.
+  private drop(bd: Boundary) {
+    bd.target = undefined;
+    bd.outward = undefined;
+    bd.at.boundaries = bd.at.boundaries.filter(x => x !== bd);
+  }
+
+  // Left pointing at nothing — dropped in a sealed world, kept as a bare way
+  // out in an open one.
+  private loose(bd: Boundary) {
+    if (this.sealed) { this.drop(bd); return; }
+
+    const d = this.bare(bd);
+    bd.target = undefined;
+    bd.outward = d;
+  }
+
+  // Whether the drawn positions are the coordinates, or the structure.
+  //
+  // Off, a point is drawn where its coordinate says it is, and space that has
+  // been annihilated out of the world leaves a hole in the picture. On, the
+  // picture is relaxed against the connections that actually exist, so a
+  // connection that has closed up over destroyed space pulls its two ends
+  // together — which is the whole of what attraction is here.
+  relax = false;
+
   // Monotonic tick counter.
   _tickId = 0;
 
+  /**
+   * What just happened, and where.
+   *
+   * Every interaction in this model is over in the tick it occurs in: two
+   * charges cancel and the points they were are gone, or two turn round and
+   * are indistinguishable a moment later from two that were always going that
+   * way. Drawn only as the state they leave behind, the events themselves are
+   * invisible — the picture shows a field that is quietly a bit smaller than
+   * it was, and never shows the cancelling that made it so.
+   *
+   * So each one is noted as it happens, at the place it happened, and kept
+   * for a tick or two afterwards. Nothing in the dynamics reads this; it is
+   * the record, not the thing.
+   */
+  events: { at: Vec, kind: 'annihilate' | 'turn', tick: number }[] = [];
+
+  /**
+   * A count of what the last tick consisted of.
+   *
+   * A universe of a dozen points can be read off the picture. One of several
+   * thousand cannot: "nothing seems to be happening any more" has half a
+   * dozen quite different causes — the sources have stopped emitting, or
+   * everything has jammed and nothing can move, or things are moving fine and
+   * simply never meeting — and they look identical from outside. These are
+   * the numbers that tell them apart.
+   */
+  stats = { emitted: 0, moved: 0, blocked: 0, annihilated: 0, turned: 0, path: 0, holes: 0 };
+
+  // How far apart the two sources have been, tick by tick.
+  history: number[] = [];
+
+  // And the way between them as it currently runs.
+  route: node[] = [];
+
+  /**
+   * How far it is from one source to the other — in steps through the
+   * structure, not in coordinates.
+   *
+   * This is the measurement the whole thing is for, and it is the only one
+   * that answers the question without argument. Coordinates say nothing: the
+   * sources sit at the coordinates they were seeded at and will do forever,
+   * whether or not anything has happened between them. The picture is
+   * suggestive but it is a solve, and a solve can be stiff, or slow, or
+   * simply drawn small.
+   *
+   * The number of points you have to pass through to get from one to the
+   * other is neither. It starts at whatever the seed made it, and it goes
+   * down when and only when the space between them is annihilated. If two
+   * things gravitate in this model, THIS is what it means, and if it doesn't
+   * fall then nothing else on screen is attraction however much it looks
+   * like it.
+   */
+  shortestPath(): node[] {
+    const sources: node[] = [];
+    for (const nd of this.nodes) if (nd.some(r => r.magnet)) sources.push(nd);
+    if (sources.length < 2) return [];
+
+    const [from, to] = sources;
+    const cameFrom = new Map<node, node>([[from, from]]);
+
+    let frontier = [from];
+
+    while (frontier.length) {
+      const next: node[] = [];
+
+      for (const nd of frontier) {
+        for (const ray of nd) {
+          for (const bd of ray.boundaries) {
+            const other = bd.target?.at.node;
+            if (!other || cameFrom.has(other)) continue;
+
+            cameFrom.set(other, nd);
+
+            if (other === to) {
+              const route = [other];
+              while (route[0] !== from) route.unshift(cameFrom.get(route[0])!);
+
+              return route;
+            }
+
+            next.push(other);
+          }
+        }
+      }
+
+      frontier = next;
+    }
+
+    return []; // no way from one to the other at all
+  }
+
+  private mark(kind: 'annihilate' | 'turn', ...rays: Ray[]) {
+    const at: Vec[] = [];
+
+    for (const ray of rays) {
+      const p = this.relaxed?.at.get(ray.node) ?? this.layoutCache?.get(ray.node);
+      if (p) at.push(p);
+    }
+
+    if (!at.length) return;
+
+    const centre = new Array(at[0].length).fill(0);
+    for (const p of at)
+      for (let k = 0; k < centre.length; k++) centre[k] += p[k] / at.length;
+
+    this.events.push({ at: centre, kind, tick: this._tickId });
+  }
+
   // Something the seed has arranged for the world to go on doing, run at the
   // start of every tick before the rules get their say. Nothing in the rules
   // needs one — it is how a source that is never itself an event gets to be
@@ -160,23 +535,45 @@ class Graph {
         boundary.target = target;
   }
 
-  // Which way a boundary points, as a unit vector in grid space. A bare
-  // direction says so itself; a connection is the step from the point it is
-  // on to the point on the other side.
-  private direction(bd: Boundary): number[] | undefined {
-    if (bd.outward) {
-      const length = Math.hypot(...bd.outward);
-      return length ? bd.outward.map(v => v / length) : undefined;
-    }
+  // How far and which way a boundary reaches, in grid units. A bare direction
+  // says so itself; a connection is the offset from the point it is on to the
+  // point on the other side, which after an annihilation can be several steps
+  // rather than one.
+  private offset(bd: Boundary): number[] | undefined {
+    if (bd.outward) return bd.outward;
 
     const from = this.gridPos.get(bd.at.node);
     const to = bd.target && this.gridPos.get(bd.target.at.node);
     if (!from || !to) return undefined;
 
-    const step = to.map((v, i) => v - from[i]);
-    const length = Math.hypot(...step);
+    return to.map((v, i) => v - from[i]);
+  }
+
+  // Which way a boundary points, as a unit vector — for comparing directions
+  // against each other, where only the way they face matters.
+  private direction(bd: Boundary): number[] | undefined {
+    const offset = this.offset(bd);
+    if (!offset) return undefined;
+
+    const length = Math.hypot(...offset);
+
+    return length ? offset.map(v => v / length) : undefined;
+  }
+
+  /**
+   * The same direction as one step of the lattice — components in {-1, 0, 1}.
+   *
+   * This is what goes into a position (a new point is put down one step over,
+   * not a unit distance over, which off the axes is not the same thing) and
+   * what a boundary with nothing on the far side is left holding. A unit
+   * vector would be neither: in a 360° discrete space the corner directions
+   * have length √3, and normalising them puts new points at coordinates the
+   * lattice doesn't have.
+   */
+  private bare(bd: Boundary): number[] | undefined {
+    const offset = this.offset(bd);
 
-    return length ? step.map(v => v / length) : undefined;
+    return offset && latticeStep(offset);
   }
 
   // The boundary of `ray` pointing most nearly along `dir` (`sign` of -1 for
@@ -232,11 +629,14 @@ class Graph {
   // real-valued (space instantiated between two points lands at their
   // midpoint), so this is a tolerance match rather than a key lookup.
   private nodeAt(pos: number[]): node | undefined {
-    for (const [nd, p] of this.gridPos)
-      if (p.length === pos.length && p.every((v, i) => Math.abs(v - pos[i]) < 1e-6))
-        return nd;
+    const found = this.at.get(Graph.posKey(pos));
+    if (!found) return undefined;
 
-    return undefined;
+    const p = this.gridPos.get(found);
+
+    return p && p.length === pos.length && p.every((v, i) => Math.abs(v - pos[i]) < 1e-6)
+      ? found
+      : undefined;
   }
 
   /**
@@ -296,13 +696,73 @@ class Graph {
     const dirA = this.direction(a), dirB = this.direction(b);
 
     const backA = this.behind(r, dirA, a), backB = this.behind(r2, dirB, b);
-    const homeA = backA?.target?.at, homeB = backB?.target?.at;
+
+    // What was behind each — but never a source. A source is not somewhere
+    // space can be put down; it is the thing space is coming out of. Handing
+    // it what a dying charge was carrying leaves it holding connections to
+    // half the world, which it then radiates down, and every one of those
+    // comes back to leave more. Treated as nothing behind, the structure goes
+    // to the other side, or the two collapse onto each other as they do when
+    // there is nowhere behind either.
+    const behindA = backA?.target?.at;
+    const behindB = backB?.target?.at;
+
+    const homeA = behindA?.magnet ? undefined : behindA;
+    const homeB = behindB?.magnet ? undefined : behindB;
+
+    /**
+     * The connection between the two of them, severed first of all.
+     *
+     * It is the one thing this event actually destroys, and it has to go
+     * before anything else is decided — both of its ends are on points that
+     * are about to stop existing, so any rule that tries to preserve it later
+     * preserves a connection to a corpse. Done here, every branch below is
+     * dealing only with connections that genuinely survive.
+     *
+     * Meeting head-on that is `a` and `b`. Arriving at the same place from
+     * different directions there is no such connection at all — `a` leads to
+     * the point they were both making for, which is somebody else and stays.
+     */
+    for (const bd of [a, b]) {
+      const partner = bd.target;
+      if (!partner || (partner.at !== r && partner.at !== r2)) continue;
+
+      partner.target = undefined;
+      bd.target = undefined;
+    }
 
     if (homeA || homeB) {
-      // Each side's space goes to whatever is behind it — or, for a side with
-      // nothing behind it, to the other's, that being the only way left.
-      this.hand(this.transverse([r], dirA, backA), homeA ?? homeB!);
-      this.hand(this.transverse([r2], dirB, backB), homeB ?? homeA!);
+      /**
+       * Everything each of them held goes to the point behind it.
+       *
+       * Not just what it held across its line of travel — everything, bar the
+       * two that this event is actually about: the connection between the two
+       * of them, which is what they were approaching each other along and is
+       * the one thing here that genuinely ceases to exist, and the connection
+       * to the point behind, which is where all of it is going and so becomes
+       * internal to that.
+       *
+       * Handing only the transverse part is what leaves the rest to be
+       * guessed at, and every version of that guess loses something: a
+       * direction with no readable heading gets dropped, two that lead to the
+       * same neighbour refuse to pair, and the point on the other end of them
+       * quietly loses a connection it never gave up. Measured, that is
+       * hundreds of points falling below three connections and some to none
+       * at all, cut out of the world by an event two cells away.
+       *
+       * Handed wholesale, nothing has to be decided and nothing can be lost.
+       * The point stops existing; what it was holding is held by the place
+       * behind it; and every point that was connected to it is still
+       * connected to exactly as much as it was.
+       */
+      // Everything either of them is still joined to, bar the way back —
+      // which is where all of it is going, and so becomes internal to that.
+      // The approach between them is already severed, so it cannot be here.
+      const inherit = (dying: Ray, back: Boundary | undefined, onto: Ray) =>
+        this.hand(dying.boundaries.filter(bd => bd !== back && bd.target), onto);
+
+      inherit(r, backA, homeA ?? homeB!);
+      inherit(r2, backB, homeB ?? homeA!);
 
       // The line closes up: what was behind one is now directly onto what was
       // behind the other.
@@ -315,10 +775,9 @@ class Graph {
         if (!p) continue;
 
         // Nothing on the far side to close onto, so the direction is all that
-        // is left of what used to be there.
-        const d = this.direction(p);
-        p.target = undefined;
-        p.outward = d;
+        // is left of what used to be there — and in a sealed world, not even
+        // that.
+        this.loose(p);
       }
 
       this.discard(r, homeA ?? homeB!, removed);
@@ -328,8 +787,9 @@ class Graph {
     }
 
     // Nowhere behind either of them: everything the two were carrying ends up
-    // on one point, which is all that is left of both.
-    this.hand(this.transverse([r2], dirB, backB), r);
+    // on one point, which is all that is left of both — and here that one
+    // point is the place behind, there being no other.
+    this.hand(r2.boundaries.filter(bd => bd.target), r);
 
     r.boundaries = r.boundaries.filter(x => x !== a);
     this.discard(r2, r, removed);
@@ -346,20 +806,146 @@ class Graph {
    * direction — the way is still that way, there is just nothing there — and
    * anything still sitting on it goes wherever its structure went.
    */
-  private discard(ray: Ray, onto: Ray, removed: Set<node>) {
-    const nd = ray.node;
+  /**
+   * A point stops being anywhere, and every way through it closes up.
+   *
+   * Whatever was on one side of it and whatever was on the other are now
+   * directly connected — the connection still exists, it is simply shorter
+   * now by the point that is no longer in it. Done for all thirteen axes
+   * through the point rather than only the one something happened to be
+   * travelling along, because a point in a lattice is in the middle of
+   * thirteen lines at once and every one of them has to survive losing it.
+   *
+   * Only a direction with nothing coming the other way is left bare, and that
+   * is a genuine edge of the world rather than a tear in it.
+   */
+  private closeUp(boundaries: Boundary[], of: Ray) {
+    const facing = new Map<string, Boundary>();
+    const waiting: Boundary[] = [];
+
+    const join = (x: Boundary, y: Boundary) => {
+      x.target = y;
+      x.outward = undefined;
+      y.target = x;
+      y.outward = undefined;
+    };
 
-    for (const bd of ray.boundaries) {
+    for (const bd of boundaries) {
       const partner = bd.target;
 
       // Only if it is still pointing back at us: a connection that has
       // already been closed up onto something else is not ours to break.
       if (!partner || partner.target !== bd) continue;
 
-      const d = this.direction(partner);
-      partner.target = undefined;
-      partner.outward = d;
+      const step = this.bare(bd);
+      if (!step) { waiting.push(partner); continue; }
+
+      const key = step.join(",");
+      const opposite = step.map(v => -v).join(",");
+      const back = facing.get(opposite);
+
+      // Straight through: the two that were either side of us are now either
+      // side of nothing, so they are next to each other.
+      if (back && back !== partner && back.at.node !== partner.at.node) {
+        join(back, partner);
+        facing.delete(opposite);
+
+        continue;
+      }
+
+      if (facing.has(key)) waiting.push(partner);
+      else facing.set(key, partner);
+    }
+
+    /**
+     * And whatever had nothing coming the other way is joined up anyway.
+     *
+     * Every one of these was a neighbour of the point that has gone, so they
+     * are all within a step of where it was and so within two of each other:
+     * joining them is contraction, the same as the straight-through case, not
+     * a shortcut between places that were never near. What it is not is a
+     * hole. A direction left pointing at nothing is a way out of the lattice
+     * that was not there before, and thousands of them are what stop a wave
+     * ever crossing the middle — which is measurable, and was the whole of
+     * why two magnets stopped interacting after a dozen ticks.
+     *
+     * A point removed from a line leaves its two ends facing each other. A
+     * point removed from a lattice leaves twenty-six neighbours facing each
+     * other, and all of them staying connected is what "the space contracts"
+     * has to mean when there is more than one way through.
+     */
+    const left = [...facing.values(), ...waiting]
+      .filter(p => p.target?.at === of);
+
+    for (let i = 0; i + 1 < left.length; i += 2)
+      if (left[i].at.node !== left[i + 1].at.node) join(left[i], left[i + 1]);
+
+    // An odd one out: joined to whoever it was just beside, rather than left
+    // facing nowhere.
+    if (left.length % 2) {
+      const last = left[left.length - 1];
+      const mate = left.find(p => p !== last && p.at.node !== last.at.node);
+
+      if (mate) {
+        const spare = new Boundary(mate.at, this);
+        spare.polarity = Polarity.Neutral;
+        mate.at.boundaries.push(spare);
+        join(last, spare);
+      } else this.loose(last);
     }
+  }
+
+  private discard(ray: Ray, onto: Ray, removed: Set<node>) {
+    const nd = ray.node;
+
+    /**
+     * Everything that was connected to us is now connected to where our
+     * structure went.
+     *
+     * This used to leave them holding a bare direction — the way is still
+     * that way, there is just nothing there — which is right for a line and
+     * catastrophic for a lattice. On a line a point has two neighbours, the
+     * two ends get spliced onto each other by the caller, and nothing is left
+     * dangling. Here a point has twenty-six, one of them gets the splice, and
+     * the other twenty-five are left pointing at nowhere.
+     *
+     * That is a hole, and every annihilation punches two dozen of them. They
+     * accumulate exactly where the action is, the lattice between the sources
+     * comes apart into fragments joined by fewer and fewer connections, and
+     * the way from one source to the other has to start going round. Which
+     * is why the distance between them falls for a while and then stops
+     * falling: it is not that they have finished coming together, it is that
+     * the space they were coming together through has been shredded.
+     *
+     * Following the structure instead keeps the lattice whole. The point is
+     * gone and its structure is at `onto`, so its neighbours are neighbours
+     * of `onto` now — which is the same rule the annihilation itself runs on,
+     * applied to every direction rather than only to the one behind.
+     */
+    /**
+     * The space closes up across itself, direction by direction.
+     *
+     * Two earlier versions of this were wrong in opposite ways. Leaving every
+     * neighbour holding a bare direction tears two dozen holes per removal.
+     * Reconnecting them all to wherever the structure went does keep the
+     * lattice joined — but `onto` can be anywhere, so every removal welds a
+     * couple of dozen points to one distant point, and after a few thousand
+     * of them the lattice is a mass of long-range shortcuts. That is
+     * measurable rather than theoretical: the shortest way from one source to
+     * the other ends up running (−8,0,0) → (−9,0,0) → (−1,9,9) → (7,0,0) →
+     * (8,0,0), hopping through a point in the far corner of the world, and it
+     * stops changing at all. Both sources still have their whole
+     * neighbourhood; what has gone is any relation between being connected
+     * and being near, and with it any sense in which the two are approaching.
+     *
+     * What a point actually is, to its neighbours, is the thing between them:
+     * take it away and the two on opposite sides of it are what close up.
+     * That is the same rule the annihilation uses along its own line, applied
+     * to every direction through the point rather than only that one — so the
+     * ways through survive, and none of them reaches anywhere the two ends
+     * were not already either side of.
+     */
+    this.closeUp(ray.boundaries, ray);
 
     ray.boundaries = [];
 
@@ -372,8 +958,12 @@ class Graph {
 
     nd.length = 0;
 
-    this.gridPos.delete(nd);
-    this.nodes = this.nodes.filter(n => n !== nd);
+    this.delPos(nd);
+    // Taken out of the world at the end of the tick rather than here: `nodes`
+    // is scanned by everything, and cutting one point out of it costs a pass
+    // over all of them, which with a few thousand points and a few thousand
+    // of them moving is the whole frame. `removed` is what everything in the
+    // tick actually consults, so the array can be caught up with once.
     removed.add(nd);
   }
 
@@ -390,14 +980,34 @@ class Graph {
 
     let back = this.behind(ray, dir, a);
 
+    // Nothing behind it at all, so the way back is something it has to have —
+    // except in a sealed world, where a direction it hasn't got is not a
+    // direction it may invent. There it comes back along whichever of its own
+    // ways points most nearly backwards, and if it truly has only the one, it
+    // stays where it is rather than tearing a way out to leave by.
     if (!back) {
+      if (this.sealed) {
+        back = this.along(ray, dir, -1, a);
+
+        if (back) ray.moving = back;
+
+        return;
+      }
+
+      const step = this.bare(a);
+
       back = new Boundary(ray, this);
       back.polarity = a.polarity;
-      if (dir) back.outward = dir.map(v => -v);
+      if (step) back.outward = step.map(v => -v);
       ray.boundaries.push(back);
     }
 
     ray.moving = back;
+
+    // It is genuinely going somewhere else now, so the way it was going is
+    // not a detour from anything. Taken up afresh from wherever it now
+    // points.
+    ray.heading = undefined;
   }
 
   /**
@@ -411,21 +1021,43 @@ class Graph {
    * of one point in isolation.
    */
   private canMove(ray: Ray, a: Boundary, blocked: Set<Ray>): boolean {
-    if (!a.target) return true; // an actual boundary of the structure: we make our own way
+    // An actual boundary of the structure: we make our own way — as long as
+    // there is a way to make. A direction we can't name is one we can't grow
+    // into, and setting off into it means putting down the space we are
+    // leaving and then not leaving.
+    if (!a.target) return !!this.bare(a);
 
     const dir = this.direction(a);
 
     for (const other of a.target.at.node) {
-      if (!other.moving) continue; // space: ours to move through
+      // A source is never space, whether or not it happens to be going
+      // anywhere. Without this a charge arriving at a standing magnet reads
+      // it as somewhere to be, walks into it, and finds it can't — having
+      // already put down the space it was leaving, which is space made out of
+      // nothing, every tick, forever.
+      if (other.magnet) return false;
 
-      const d = this.direction(other.moving);
-      if (!d || !dir) return false;
-
-      // Not leaving the way we are going, so it is in the way.
-      if (d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0) < 0.9) return false;
+      if (!other.moving) continue; // space: ours to move through
 
-      // Leaving, but blocked itself, so it isn't leaving after all.
-      if (blocked.has(other)) return false;
+      /**
+       * It is going somewhere, so its place will be free — whichever way it
+       * happens to be going. What it leaves behind is one point of space,
+       * spliced in on its way out, and that point is what we move into.
+       *
+       * Only one of us can have it, and which one is settled by the claim
+       * below rather than by geometry: a point being moved out of typically
+       * has several things coming up behind it at various angles, and if
+       * whoever is actually following has to also be the one lying exactly
+       * opposite the direction of travel, then in a field where directions
+       * change from tick to tick almost nobody qualifies and almost
+       * everything is stuck waiting on a queue that is moving fine.
+       *
+       * So: it is leaving, therefore it can be followed. Whoever claims the
+       * place gets it (`claimed`), and `emitBehind` puts the space it leaves
+       * on that one's connection rather than on whichever happens to be
+       * behind.
+       */
+      if (blocked.has(other)) return false; // not leaving after all
     }
 
     return true;
@@ -442,11 +1074,20 @@ class Graph {
    * and giving it a charge at random would be an event this model didn't
    * have.
    */
-  private emitBehind(ray: Ray, a: Boundary, vacated: Map<node, number[]>) {
+  private emitBehind(ray: Ray, a: Boundary, vacated: Map<node, number[]>, heir?: Ray) {
     const dir = this.direction(a);
+    const step = this.bare(a);
     const here = this.gridPos.get(ray.node);
 
-    let back = this.behind(ray, dir, a);
+    // The space we leave goes to whoever is actually moving into our place,
+    // if anyone is — spliced in on the connection they are coming along, so
+    // that what they find in front of them next is it. Failing that (nobody
+    // following), it goes behind us in the geometric sense, which is where it
+    // would have gone anyway.
+    let back = heir
+      && ray.boundaries.find(bd => bd !== a && bd.target?.at.node === heir.node);
+
+    if (!back) back = this.behind(ray, dir, a);
     const was = back?.target;
     const there = was && this.gridPos.get(was.at.node);
 
@@ -470,14 +1111,22 @@ class Graph {
     back.target = facing;
     facing.target = back;
 
-    // Whatever was behind us is behind the point we just put there.
     const onward = new Boundary(fresh, this);
     onward.polarity = Polarity.Neutral;
 
-    if (was) { onward.target = was; was.target = onward; }
-    else if (dir) onward.outward = dir.map(v => -v);
-
-    fresh.boundaries.push(onward);
+    // Whatever was behind us is behind the point we just put there — and if
+    // there was nothing behind us at all, then the point we put down has
+    // nothing behind it either. In an open world that is a way out, and it
+    // gets one; sealed, it is simply a point with one fewer direction, which
+    // is not a hole because there was never anything there to lose.
+    if (was) {
+      onward.target = was;
+      was.target = onward;
+      fresh.boundaries.push(onward);
+    } else if (!this.sealed) {
+      if (step) onward.outward = step.map(v => -v);
+      fresh.boundaries.push(onward);
+    }
 
     this.nodes.push(nd);
 
@@ -488,9 +1137,9 @@ class Graph {
     // direction between them for anything else to read. So it waits between
     // us and what is behind us, and is put down properly once the moving is
     // over.
-    this.gridPos.set(nd, !here ? []
+    this.setPos(nd, !here ? []
       : there ? here.map((v, i) => (v + there[i]) / 2)
-        : dir ? here.map((v, i) => v - dir[i])
+        : step ? here.map((v, i) => v - step[i])
           : here.slice());
 
     if (here) vacated.set(nd, here.slice());
@@ -524,10 +1173,15 @@ class Graph {
     const nd = ahead.at.node;
     if (nd === ray.node || removed.has(nd)) return;
 
+    // Only space is ever eaten. Anything going somewhere is somebody — and so
+    // is a magnet, which is a somebody that happens to be standing still: it
+    // is the source of everything happening here, and a source that its own
+    // first pulse can swallow is not a source.
     for (const other of nd)
-      if (other.moving) return;
+      if (other.moving || other.magnet) return;
 
     const dir = this.direction(a);
+    const bareA = this.bare(a);
 
     // Where it is going to be, which is not yet where it is if it is space
     // something else has just put down on its way out.
@@ -537,7 +1191,7 @@ class Graph {
     // across. Our own direction of travel is rewired onto that, so the line
     // we are moving along stays a line.
     let onward: Boundary | undefined;
-    let onwardDir: number[] | undefined;
+    let onwardStep: number[] | undefined;
 
     for (const other of nd) {
       for (const bd of other.boundaries) {
@@ -548,7 +1202,7 @@ class Graph {
 
         if (d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0) > 0.9) {
           onward = bd;
-          onwardDir = d;
+          onwardStep = this.bare(bd);
         }
       }
     }
@@ -563,31 +1217,39 @@ class Graph {
       beyond.target = a;
     } else {
       // Nothing beyond it: what we are moving along is a bare direction
-      // again, and growing into it is the next thing we do.
-      a.target = undefined;
-      a.outward = onwardDir ?? dir;
+      // again, and growing into it is the next thing we do. Sealed, there is
+      // no growing into anything, so it simply stops being one of our
+      // directions.
+      if (this.sealed) this.drop(a);
+      else {
+        a.target = undefined;
+        a.outward = onwardStep ?? bareA;
+      }
     }
 
-    // Anything still pointing at it is pointing at nowhere; the direction
-    // survives the point, so it is left as a bare one.
+    // And everything else it was holding is held by us, since we are where it
+    // was. Same rule as annihilation: the point stops existing and the place
+    // behind takes what it had — here the place behind is the mover, which
+    // has just arrived. Anything left out of this is a connection whose far
+    // end is still pointing at a point that no longer exists.
     for (const other of nd) {
-      for (const bd of other.boundaries) {
-        const partner = bd.target;
-        if (!partner || partner === a || partner === beyond) continue;
-
-        const d = this.direction(partner);
-        partner.target = undefined;
-        partner.outward = d;
-      }
+      this.hand(
+        other.boundaries.filter(bd => bd !== ahead && bd !== onward && bd.target !== a),
+        ray,
+      );
 
       other.boundaries = [];
     }
 
     // Its place is our place: we have moved.
-    if (there) this.gridPos.set(ray.node, there.slice());
-
-    this.gridPos.delete(nd);
-    this.nodes = this.nodes.filter(n => n !== nd);
+    if (there) this.setPos(ray.node, there.slice());
+
+    this.delPos(nd);
+    // Taken out of the world at the end of the tick rather than here: `nodes`
+    // is scanned by everything, and cutting one point out of it costs a pass
+    // over all of them, which with a few thousand points and a few thousand
+    // of them moving is the whole frame. `removed` is what everything in the
+    // tick actually consults, so the array can be caught up with once.
     removed.add(nd);
     vacated.delete(nd);
   }
@@ -603,11 +1265,11 @@ class Graph {
    * same tick, which is what moving into nothing amounts to.
    */
   private grow(ray: Ray, a: Boundary) {
-    const dir = this.direction(a);
+    const step = this.bare(a);
     const here = this.gridPos.get(ray.node);
-    if (!dir || !here) return;
+    if (!step || !here) return;
 
-    const pos = here.map((v, i) => v + dir[i]);
+    const pos = here.map((v, i) => v + step[i]);
 
     const nd: node = [];
     const fresh = new Ray(nd, this);
@@ -622,7 +1284,7 @@ class Graph {
     a.target = facing;
 
     this.nodes.push(nd);
-    this.gridPos.set(nd, pos);
+    this.setPos(nd, pos);
 
     // Connected to what we are connected to: one direction for each of ours,
     // a real connection where a point is already there and a bare direction
@@ -630,12 +1292,17 @@ class Graph {
     for (const boundary of ray.boundaries) {
       if (boundary === a) continue;
 
-      const d = this.direction(boundary);
+      const d = this.bare(boundary);
       if (!d) continue;
 
       const neighbour = this.nodeAt(pos.map((v, i) => v + d[i]));
       if (neighbour === ray.node || neighbour === nd) continue; // back at us
 
+      // Nowhere there yet: an open world gets a bare direction so the
+      // frontier can keep going, a sealed one simply doesn't have that
+      // direction.
+      if (!neighbour && this.sealed) continue;
+
       const side = new Boundary(fresh, this);
       side.polarity = Polarity.Neutral;
 
@@ -673,6 +1340,10 @@ class Graph {
   tick() {
     this._tickId++;
 
+    // Zeroed before the sources get their say, so what they emit this tick is
+    // counted against this tick.
+    this.stats = { emitted: 0, moved: 0, blocked: 0, annihilated: 0, turned: 0, path: 0, holes: 0 };
+
     this.onTick?.(this);
 
     // Snapshot the rays first, so structural changes don't disturb iteration.
@@ -681,6 +1352,58 @@ class Graph {
       for (const ray of node)
         rays.push(ray);
 
+    /**
+     * Before anything is read off: whoever is wandering, wanders.
+     *
+     * Done here rather than at the point of moving, because a change of
+     * direction has to be settled before it is asked who is meeting whom —
+     * otherwise a ray is judged to be about to collide on a heading it has
+     * already given up, and half the interactions in the tick are worked out
+     * against a world nobody is in any more.
+     */
+    for (const r of rays) if (r.moving && !r.magnet) r.age = (r.age ?? 0) + 1;
+
+    if (this.wander > 0) {
+      for (const r of rays) {
+        if (!r.moving || r.magnet) continue;
+
+        // Where it is going, remembered — not where it went last time.
+        const head = r.heading ?? this.bare(r.moving);
+        if (!head) continue;
+
+        r.heading = head;
+
+        // The ways this direction is made of. Its own pieces only: a step of
+        // (1,1,1) is (1,0,0) and (0,1,0) and (0,0,1) taken at once, and those
+        // three are the whole of what taking it apart can mean. Their
+        // opposites are not detours down the same road, they are a different
+        // road — a ray that takes them is not going where it was going, and
+        // the direction stops meaning anything.
+        const ways: number[][] = [head];
+
+        for (let axis = 0; axis < head.length; axis++) {
+          if (!head[axis]) continue;
+
+          const one = new Array(head.length).fill(0);
+          one[axis] = head[axis];
+
+          ways.push(one);
+        }
+
+        // Straight on unless it draws otherwise, and always the whole
+        // direction if there is nothing it can be broken into — an axial
+        // heading has no longer way round.
+        const way = ways.length > 2 && Math.random() < this.wander
+          ? ways[1 + Math.floor(Math.random() * (ways.length - 1))]
+          : head;
+
+        const length = Math.hypot(...way) || 1;
+
+        const chosen = this.along(r, way.map(v => v / length), 1);
+        if (chosen) r.moving = chosen;
+      }
+    }
+
     // Which way each ray was headed when the tick began. Read once, so that
     // acting in some order doesn't let the earlier actions decide what the
     // later ones are — head-on is head-on as of the start of the tick.
@@ -691,6 +1414,7 @@ class Graph {
     // tick: turning around, or cancelling, is the whole of what they do in
     // it.
     const collisions: Interaction[] = [];
+    const reflections: { r: Ray, a: Boundary }[] = [];
     const met = new Set<Ray>();
 
     for (const r of rays) {
@@ -699,11 +1423,56 @@ class Graph {
       const a = headed.get(r);
       if (!a) continue;
 
-      const b = a.target;
-      const r2 = b?.at;
+      const ahead = a.target?.at.node;
+      if (!ahead || ahead === r.node) continue;
+
+      // Arriving at a source. It carries no charge, so there is nothing to
+      // cancel with, and it is never space, so there is no moving through it
+      // — which leaves the only other thing anything does here: it turns
+      // around. A source reflects what reaches it, and it does so whether or
+      // not it is itself going anywhere, which is what makes it different
+      // from every other head-on case.
+      if (ahead.some(x => x.magnet)) {
+        met.add(r);
+        reflections.push({ r, a });
+        continue;
+      }
+
+      /**
+       * Whoever over there is coming back at us.
+       *
+       * Not necessarily along the same connection. On a line there is only
+       * one way to be coming the other way, and "head-on" can be checked by
+       * asking whether the far side is moving along this very boundary. With
+       * twenty-six directions two things can be moving into each other
+       * without being anywhere near opposite — one going along an edge, one
+       * through a corner — and by that test neither of them is meeting
+       * anything.
+       *
+       * Which is worse than a missed case: neither can move, because the
+       * other is in the way and isn't leaving, so two fronts that should pass
+       * through each other (cancelling as they go) instead stop dead against
+       * each other and stay there. Nothing happens, and nothing goes on
+       * happening.
+       *
+       * So the test is the thing itself: I am moving into where you are, and
+       * you are moving into where I am.
+       */
+      let r2: Ray | undefined;
+      let b: Boundary | undefined;
+
+      for (const other of ahead) {
+        if (met.has(other)) continue;
+
+        const bd = headed.get(other);
+        if (!bd || bd.target?.at.node !== r.node) continue;
+
+        r2 = other;
+        b = bd;
+        break;
+      }
 
-      // Is the far side coming back at us along this same connection?
-      if (!b || !r2 || r2.node === r.node || headed.get(r2) !== b || b.target !== a) continue;
+      if (!r2 || !b) continue;
 
       met.add(r); met.add(r2);
 
@@ -717,17 +1486,169 @@ class Graph {
       collisions.push({ kind: opposed ? 'annihilate' : 'turn', r, a, r2, b });
     }
 
+    /**
+     * Two charges arriving at the same point.
+     *
+     * Everything above asks whether two things are moving into each other,
+     * which is to say whether they are next to each other and pointed the
+     * opposite way. On a line that is the only way two things can meet, and
+     * it is where this rule came from.
+     *
+     * In three dimensions it is the exceptional way. Two shells sweeping
+     * through each other are made of rays coming in at all angles, and what
+     * those rays overwhelmingly do is converge on the SAME cell from
+     * different directions — never becoming neighbours, never pointed at each
+     * other, both pointed at the same third place. By the test above neither
+     * of them is meeting anything. They are resolved as traffic instead: one
+     * takes the place, the other waits, and two fields pass straight through
+     * one another with nothing to show for it.
+     *
+     * Which is the answer to why the fields overlap and never attract. It was
+     * never that the shells missed each other; it is that arriving together
+     * was not on the list of ways to meet.
+     *
+     * So it is now, and it is the same event: two opposite charges cancel,
+     * their points go, and what was behind each closes onto what was behind
+     * the other — the whole of it exactly as for two that met head-on, since
+     * `annihilate` cares about what is BEHIND the two rather than about how
+     * they came to be in the same place. Alike charges arriving together are
+     * left to traffic, as before: they cannot cancel, and nothing about
+     * wanting the same cell makes them turn around.
+     */
+    const arriving = new Map<node, Ray>();
+
+    for (const r of rays) {
+      if (met.has(r) || r.magnet) continue;
+
+      const a = headed.get(r);
+      const there = a?.target?.at.node;
+      if (!a || !there || there === r.node) continue;
+
+      const other = arriving.get(there);
+
+      if (!other) { arriving.set(there, r); continue; }
+
+      const b = headed.get(other)!;
+
+      const opposed =
+        (a.polarity === Polarity.Positive && b.polarity === Polarity.Negative) ||
+        (a.polarity === Polarity.Negative && b.polarity === Polarity.Positive);
+
+      met.add(r); met.add(other);
+
+      /**
+       * Alike, and both wanting the same place: they turn around.
+       *
+       * This used to be left to traffic — one takes the place, the other
+       * waits — and that is why two sources turning in step do nothing at
+       * all. They emit the same charge on the same tick, so their shells are
+       * the same polarity, so the two that meet in the middle are always
+       * alike. Never opposite, so nothing ever cancelled there; and merely
+       * queued rather than turned, so nothing ever came back either. The
+       * whole interaction between them was one of them waiting a tick.
+       *
+       * Turning is what actually happens: neither can cancel the other and
+       * neither can pass through it, which is the same situation as meeting
+       * head-on and has the same answer. And it is what makes the two spin
+       * cases the same thing in the end — each of them comes back into the
+       * opposite-charged shell following behind it, and cancels against that.
+       * The space between the two still gets eaten; it takes one more step
+       * about it.
+       */
+      if (!opposed) {
+        arriving.delete(there); // both going back the way they came
+
+        collisions.push({ kind: 'turn', r, a, r2: other, b });
+
+        continue;
+      }
+
+      arriving.delete(there); // both gone; the place is free again
+
+      collisions.push({ kind: 'annihilate', r, a, r2: other, b });
+    }
+
     const removed = new Set<node>();
 
+    // Only the last couple of ticks' worth is kept: an event is a thing that
+    // happened, not a thing that is there.
+    this.events = this.events.filter(e => e.tick > this._tickId - 2);
+
+    /**
+     * Whether an interaction worked out at the top of the tick is still an
+     * interaction by the time we get to it.
+     *
+     * They were all found against the world as it was when the tick began,
+     * and then they are carried out one after another — so each one is
+     * carried out against a world the ones before it have been changing.
+     * Annihilating splices two points out and hands what they were carrying
+     * to whatever was behind them, which can pick a ray up off the node it
+     * was on and leave it holding none of the boundaries it had.
+     *
+     * With one interface between two waves there is only ever one of these a
+     * tick and it cannot happen. With a field full of shells there are
+     * hundreds, and the ones that are stale get carried out anyway: rewiring
+     * `target`s across connections that have already been spliced, in exactly
+     * the region where everything is happening. What comes of it is a
+     * knot — points connected to points that no longer exist, rays that can
+     * no longer move, nothing more able to reach anything else — which looks
+     * from outside like the first wave interacting beautifully and every
+     * wave after it doing nothing at all.
+     *
+     * Every other phase of the tick already checks this (see `movers`). This
+     * one didn't.
+     */
+    const alive = (r: Ray, bd: Boundary) =>
+      !removed.has(r.node) && r.boundaries.includes(bd);
+
     for (const it of collisions) {
+      if (!alive(it.r, it.a) || !alive(it.r2, it.b)) continue;
+
+      // Noted before it is carried out — an annihilation removes both of the
+      // points it happened between, and afterwards there is nowhere to say it
+      // happened at.
+      this.mark(it.kind, it.r, it.r2);
+
       if (it.kind === 'annihilate') {
+        this.stats.annihilated++;
         this.annihilate(it.r, it.a, it.r2, it.b, removed);
       } else {
+        this.stats.turned++;
         this.turnAround(it.r, it.a);
         this.turnAround(it.r2, it.b);
       }
     }
 
+    /**
+     * What arrives at a source is taken back into it.
+     *
+     * This used to turn around, on the grounds that a source can neither
+     * cancel a charge nor be moved through, so the only thing left was to
+     * come back the way it came. True as far as it goes, and it silts the
+     * source up: a reflected charge is still a charge, still sitting in one
+     * of the couple of dozen cells its source has to emit into, and free to
+     * wander straight back. A handful of them and the source is walled in by
+     * its own output — emitting nothing, ever again.
+     *
+     * A thing that writes charge onto space can take it off again; a source
+     * is a sink for the same reason it is a source. So the charge is simply
+     * undone — its polarity goes, it stops going anywhere, and it is space
+     * once more. No point is created or destroyed by it, and the source is
+     * left with somewhere to emit next tick, which is the whole condition of
+     * it going on being a source at all.
+     */
+    for (const { r, a } of reflections) {
+      if (!alive(r, a)) continue;
+
+      r.moving = undefined;
+      r.wave = undefined;
+      r.age = 0;
+      r.fanned = false;
+      r.heading = undefined;
+
+      for (const bd of r.boundaries) bd.polarity = Polarity.Neutral;
+    }
+
     // 2. Everything else moves — read off the world as the collisions have
     // left it, so that space that has just closed up behind an annihilation
     // is gone before anything tries to move through it.
@@ -737,14 +1658,81 @@ class Graph {
       && !removed.has(r.node)
       && r.boundaries.includes(r.moving));
 
-    // Who is actually going anywhere. Being behind something that is leaving
-    // is fine; being behind something that turns out not to be leaving after
-    // all is not, so this settles rather than being decided in one pass.
     const blocked = new Set<Ray>();
+
+    /**
+     * A step is a step, whichever way it goes.
+     *
+     * The alternative is to charge a step its own length — a face costs 1, an
+     * edge √2, a corner √3 — which makes every direction advance the same
+     * distance per tick and the front of a pulse perfectly round. It is the
+     * tidier physics and it was what this did.
+     *
+     * But it makes the diagonals worse than useless. A corner connection
+     * exists precisely so that a point can get somewhere without going round
+     * two sides of a square, and charging it for the shortcut takes the
+     * shortcut away again: √3 of distance for √3 of time is the same speed as
+     * the long way round, so nothing is ever reached sooner by going
+     * diagonally and the twenty-six directions collapse back into six with
+     * extra steps.
+     *
+     * A step per tick regardless makes a diagonal a genuine shortcut, which
+     * is what gives a ray somewhere to get to faster than the lattice would
+     * otherwise allow. The price is that a pulse's front is a cube rather
+     * than a sphere — corners running out at 1.73 times the speed of faces —
+     * which is the true shape of "one move a tick" in this space and no
+     * longer worth hiding.
+     *
+     * Every direction in a lattice wired only to its faces costs 1 either
+     * way, so none of the earlier examples can tell the difference.
+     */
+    const cost = new Map<Ray, number>();
+
+    for (const r of movers) {
+      const price = r.mass ?? 1;
+
+      cost.set(r, price);
+      r.credit = (r.credit ?? 0) + 1;
+
+      // Not yet paid for. It is still going where it was going, and anything
+      // queued up behind it is still behind something that isn't leaving —
+      // which is exactly what `blocked` means, so it goes in there and the
+      // settling below carries it back down the queue.
+      if (r.credit + 1e-9 < price) blocked.add(r);
+    }
+
+    /**
+     * Who is actually going anywhere.
+     *
+     * Two conditions, settled together rather than one after the other,
+     * because each can undo the other's answer: something cleared to follow a
+     * mover has to be reconsidered if that mover turns out not to be going
+     * after all, whatever the reason it isn't.
+     *
+     * The first is traffic — being behind something that is leaving is fine,
+     * being behind something that only looked like it was leaving is not.
+     *
+     * The second is that a place can only be taken by one thing. Two points
+     * can both be moving into the same empty cell — on a line they can't, but
+     * with twenty-six directions to come from it is the ordinary case — and
+     * both are clear to go by every other test, since every other test is
+     * about whether the way ahead is clear and for both of them it is. Then
+     * they go: both put down the space they are leaving, the first to arrive
+     * consumes the cell, and the second finds the place it was moving to no
+     * longer exists and stops, having already emitted. One point made out of
+     * nothing, and one charge that has not moved.
+     *
+     * So the place is claimed before anything sets off, and whoever doesn't
+     * get it waits — which is what being behind something else amounts to,
+     * arrived at sideways.
+     */
+    const order = Universe.shuffle(movers);
+    const claimed = new Map<node, Ray>();
+
     for (let pass = 0; pass < movers.length; pass++) {
       let changed = false;
 
-      for (const r of movers) {
+      for (const r of order) {
         if (blocked.has(r)) continue;
         if (this.canMove(r, r.moving!, blocked)) continue;
 
@@ -752,10 +1740,33 @@ class Graph {
         changed = true;
       }
 
+      claimed.clear();
+
+      for (const r of order) {
+        if (blocked.has(r)) continue;
+
+        const there = r.moving!.target?.at.node;
+        if (!there) continue; // making its own way: nowhere yet to be claimed
+
+        const holder = claimed.get(there);
+
+        if (!holder) { claimed.set(there, r); continue; }
+
+        blocked.add(r);
+        changed = true;
+      }
+
       if (!changed) break;
     }
 
-    const going = Universe.shuffle(movers.filter(r => !blocked.has(r)));
+    const going = order.filter(r => !blocked.has(r));
+
+    // Paid on going, not on being ready to: something held up in traffic
+    // keeps what it has saved and leaves the moment the way is clear.
+    for (const r of going) r.credit = (r.credit ?? 0) - (cost.get(r) ?? 1);
+
+    this.stats.moved = going.length;
+    this.stats.blocked = movers.length - going.length;
 
     // Two passes over the same rays. Everything puts down the space it is
     // leaving before anything goes anywhere, because the space one of them
@@ -764,13 +1775,34 @@ class Graph {
     // hasn't left yet.
     const vacated = new Map<node, number[]>();
 
-    for (const r of going) this.emitBehind(r, r.moving!, vacated);
+    // `claimed` says who is taking each place, so for anything leaving it
+    // also says who is coming up behind it — which is who its space goes to.
+    for (const r of going) this.emitBehind(r, r.moving!, vacated, claimed.get(r.node));
     for (const r of going) this.consumeAhead(r, r.moving!, removed, vacated);
 
     // Everything has gone where it was going, so the space left behind can
     // take the places that were left.
     for (const [nd, pos] of vacated)
-      if (!removed.has(nd)) this.gridPos.set(nd, pos);
+      if (!removed.has(nd)) this.setPos(nd, pos);
+
+    // And everything that stopped being anywhere during the tick stops being
+    // in the world, in one pass rather than one pass each.
+    if (removed.size) this.nodes = this.nodes.filter(n => !removed.has(n));
+
+    // Directions with nothing on the far side of them. A handful at the rim
+    // of the world is the world having a rim; a number that climbs tick after
+    // tick is the lattice being torn apart from the inside, which is what a
+    // path that stops shortening usually means.
+    this.stats.holes = 0;
+    for (const nd of this.nodes)
+      for (const ray of nd)
+        for (const bd of ray.boundaries)
+          if (!bd.target) this.stats.holes++;
+
+    this.route = this.shortestPath();
+    this.stats.path = Math.max(this.route.length - 1, 0);
+    this.history.push(this.stats.path);
+    if (this.history.length > 240) this.history.shift();
 
     this.invalidateLayout();
   }
@@ -822,8 +1854,16 @@ class Graph {
 
   /**
    * Lay a patch of points out on a lattice: one point per coordinate, each a
-   * single ray carrying one boundary per orthogonal neighbour present in the
-   * patch, wired to that neighbour's boundary facing back.
+   * single ray carrying one boundary per neighbour present in the patch,
+   * wired to that neighbour's boundary facing back.
+   *
+   * `neighbourhood` is which neighbours those are, and it is the whole of
+   * what "how many ways out of here are there" means. The default is the
+   * axes — the six faces of a cell in 3D — which is all anything moving along
+   * a line ever needs. Passing `directions(dims)` instead gives a point all
+   * 3^d − 1 of them, and that is what a source radiating in every direction
+   * at once requires: it can only emit into directions the space it is
+   * sitting in actually has.
    *
    * Returns everything a caller needs to say which way things move: the
    * points in coordinate order, a lookup by coordinate, and, per point, which
@@ -833,6 +1873,7 @@ class Graph {
     graph: Graph,
     coords: number[][],
     polarity: (coord: number[]) => Polarity,
+    neighbourhood?: number[][],
   ) {
     const key = (c: number[]) => c.join(",");
 
@@ -846,7 +1887,7 @@ class Graph {
       ray.boundaries = []; // drop the constructor's default boundary
 
       graph.nodes.push(nd);
-      graph.gridPos.set(nd, coord);
+      graph.setPos(nd, coord);
 
       nodes.push(nd);
       byCoord.set(key(coord), nd);
@@ -860,18 +1901,16 @@ class Graph {
       const m = new Map<node, Boundary>();
       facing.set(nd, m);
 
-      for (let axis = 0; axis < coord.length; axis++) {
-        for (const dir of [-1, 1]) {
-          const nc = coord.slice();
-          nc[axis] += dir;
-          const neighbour = byCoord.get(key(nc));
-          if (!neighbour) continue;
-
-          const b = new Boundary(ray, graph);
-          b.polarity = polarity(coord);
-          ray.boundaries.push(b);
-          m.set(neighbour, b);
-        }
+      const around = neighbourhood ?? axes(coord.length);
+
+      for (const step of around) {
+        const neighbour = byCoord.get(key(coord.map((v, i) => v + step[i])));
+        if (!neighbour) continue;
+
+        const b = new Boundary(ray, graph);
+        b.polarity = polarity(coord);
+        ray.boundaries.push(b);
+        m.set(neighbour, b);
       }
     }
 
@@ -1094,6 +2133,487 @@ class Graph {
     return graph;
   }
 
+  /**
+   * The same two magnets, in three dimensions, radiating in every direction
+   * there is.
+   *
+   * `emitters` above is a flat experiment: two walls facing each other across
+   * a corridor, each writing a charge onto the one column of space in front
+   * of it. Everything that happens there happens along one axis, which is
+   * exactly why it is legible — and exactly why it can't answer the question
+   * it raises. Two things pulling on each other along the line between them
+   * can only ever move along that line. Nothing can go round anything.
+   *
+   * So: a ball of neutral space wired with all twenty-six directions (see
+   * `directions`), and in it two sources, each of which every `every` ticks
+   * writes its charge onto every point it is connected to and sends each one
+   * outward along the direction it was written in. With `spin` it puts out
+   * the opposite of what it put out last time, so what fills the ball is
+   * alternating shells rather than one thing over and over — and `phase` says
+   * whether the two sources are doing that in step or against each other,
+   * which decides whether the shells meeting in the middle are alike (and
+   * bounce) or opposite (and cancel, taking the space between the two
+   * sources with them).
+   *
+   * A pulse is a shell rather than a beam, and it stays one: see the Huygens
+   * step in `onTick`, without which it is twenty-six bullets that get further
+   * apart the further they go and almost never meet anything.
+   *
+   * Three things had to be decided to make this work at all, and each one is
+   * a claim rather than a convenience:
+   *
+   *  - A direction is one step of the lattice, not a unit of distance. Off
+   *    the axes those differ (`latticeStep`), and using the second is what
+   *    puts points at coordinates the lattice hasn't got.
+   *
+   *  - The body of a magnet is NEUTRAL. A charged one is cancelled by the
+   *    first opposite pulse that reaches it, and two magnets that annihilate
+   *    each other on contact have no chance to orbit anything. Neutral, it
+   *    can't cancel and can't be cancelled: a charge arriving head-on turns
+   *    it round instead, which is the only way anything here is ever pushed.
+   *
+   *  - What is drawn is the structure, not the coordinates (`relax`). Two
+   *    magnets attract in this model by the space between them being
+   *    annihilated and the connection closing up over the gap — which, drawn
+   *    by coordinate, is two bodies sitting exactly where they were with a
+   *    hole between them. Drawn by structure, a connection that now spans
+   *    three cells of nothing pulls its ends together, and attraction is
+   *    something you can watch instead of something you have to be told.
+   *
+   * `a.moving` and `b.moving` are each an initial direction — any of the
+   * twenty-six — and they are the interesting knob: head-on, apart, both the
+   * same way, opposite ways across the line between them. `phase` offsets one
+   * magnet's turning against the other's, so the two are spinning together or
+   * against each other.
+   */
+  static magnets(
+    a: MagnetSide,
+    b: MagnetSide,
+    {
+      // Far enough apart to have somewhere to go.
+      //
+      // Every direction counts as a step here, diagonals included, so two
+      // points `sep` either side of the origin are only 2·sep steps apart
+      // however far that is in coordinates — at four, eight steps, which the
+      // first few pulses eat through before there is anything to watch. What
+      // is left afterwards is two sources sitting next to each other not
+      // moving into one another, which is not them failing to attract, it is
+      // them having finished: neither is space, so neither can be moved
+      // through, and adjacent is as close as adjacent gets.
+      radius = 13,
+      sep = 8,
+      every = 1,
+      spin = true,
+      alone = false,
+      // Half the moves taken as one of the pieces the direction is made of:
+      // enough that a stream genuinely searches the space around it, while
+      // the whole diagonal being one option among its pieces keeps the drift
+      // pointing the way it set out.
+      wander = 0.5,
+
+      /**
+       * How many moves a charge lasts before it is space again.
+       *
+       * Without this the field has no way of losing anything except by
+       * cancelling or by reaching the rim, and both are far too slow: a
+       * source puts fifty charges a tick into a finite ball, the fan
+       * multiplies each of them, and nothing takes them out again. The space
+       * between the two fills — measurably, two hundred and thirty-three
+       * charges in a box of two hundred and twenty-five cells — and then
+       * every single thing in the model stops at once, because moving is
+       * trading places with space and there is no space left to trade with.
+       * Not a slowdown: the population, the distance between the sources and
+       * the connections of both of them go constant on the same tick and
+       * never change again.
+       *
+       * A range fixes the population instead of letting it climb: emitted per
+       * tick times how long each lasts, which is a number that can be kept
+       * well under what the ball holds. And it is the right shape of rule —
+       * a pulse spreading over a bigger and bigger shell is thinning as it
+       * goes, and at some distance it is no longer anything the space it is
+       * crossing can tell from space.
+       */
+      range = 14,
+      spread = 0.45,
+      // Far enough out that a shell has room for its fan, and close enough in
+      // that it has fanned before it gets to the other source — which is at
+      // `sep` from one and `sep` from the other, so halfway there.
+      fanAt = Math.max(Math.floor(sep / 2), 2),
+    }: {
+      radius?: number, sep?: number, every?: number,
+      spin?: boolean, alone?: boolean, wander?: number,
+      spread?: number, fanAt?: number, range?: number,
+    } = {},
+  ): Graph {
+    const graph = new Graph();
+    graph.dims = 3;
+    graph.ringRadius = 1; // the lattice is the picture; nothing to round off
+    graph.relax = true;
+    graph.wander = wander;
+    graph.sealed = true; // a closed ball: no edges to walk off, no tears
+
+    // A ball rather than a cube, so that "the same in every direction" is
+    // true of the space as well as of what is emitted into it.
+    const coords: number[][] = [];
+    for (let x = -radius; x <= radius; x++)
+      for (let y = -radius; y <= radius; y++)
+        for (let z = -radius; z <= radius; z++)
+          if (x * x + y * y + z * z <= radius * radius) coords.push([x, y, z]);
+
+    // Nothing is charged to begin with. Every charge in this universe comes
+    // out of one of the two sources, so there is nothing to confuse a pulse
+    // with — what you see moving was emitted.
+    const { byCoord, key } = Graph.wire(
+      graph, coords, () => Polarity.Neutral, directions(3),
+    );
+
+    // The camera is for the part of the ball that anything ever happens in,
+    // which is the part inside the absorbing edge below. Framing the whole
+    // ball instead leaves a fifth of the picture as lattice nothing can reach
+    // — and makes the shells look as though they vanish well short of the
+    // edge, when in fact they are running the whole way to it.
+    graph.focus = radius - 2;
+
+    // One source at the middle, or two facing each other across the gap.
+    const sides: [number[], MagnetSide][] = alone
+      ? [[[0, 0, 0], a]]
+      : [[[-sep, 0, 0], a], [[sep, 0, 0], b]];
+
+    sides.forEach(([coord, side], source) => {
+      const nd = byCoord.get(key(coord));
+      if (!nd) return;
+
+      const ray = nd[0];
+      ray.magnet = true;
+      ray.source = source;
+      ray.emits = side.emits;
+      ray.phase = side.phase ?? 0;
+      ray.mass = MAGNET_MASS;
+      ray.axis = side.axis;
+
+      // An initial direction is named as a lattice step and resolved to the
+      // boundary that actually goes that way, so a direction the point hasn't
+      // got lands on the nearest one it has rather than on nothing.
+      if (side.moving) {
+        const length = Math.hypot(...side.moving) || 1;
+        ray.moving = graph.along(ray, side.moving.map(v => v / length), 1);
+      }
+    });
+
+    graph.onTick = g => {
+      /**
+       * The edge of the world absorbs.
+       *
+       * Left to itself this universe does not run: it fills. Every pulse
+       * charges more space than the last, nothing ever gives its charge back
+       * (a charge only stops being one by meeting its opposite head-on), and
+       * within a dozen ticks every point in the ball is a charge going
+       * somewhere. At which point the sources have nothing left to emit
+       * into — a source can only write onto space, and there isn't any — so
+       * the pulsing stops, and what is left is a ball of stuff drifting
+       * outwards, dragging the frame after it as it goes.
+       *
+       * So a charge that reaches the edge is simply undone: its polarity goes
+       * and it stops going anywhere, which is to say it becomes space again.
+       * Space is neither created nor destroyed by it — the point is still
+       * there, it is just nobody. The ball stays the size it was, the
+       * frame stays where it was, and there is always somewhere for the next
+       * pulse to go, so the pulsing is continuous rather than a burst that
+       * silts the world up.
+       *
+       * It is a boundary condition and not a rule: it says what happens at
+       * the edge of the part we are looking at, which in a universe that
+       * didn't have an edge would be nothing at all.
+       */
+      // How far out the world is still live. Ordinarily the seeded ball —
+      // held two in from its edge, since the longest step here is a corner
+      // one at √3 ≈ 1.74 and nothing may step over the edge before it is
+      // reached. But sources that travel take the experiment with them:
+      // absorbing at a fixed distance from where they STARTED would undo
+      // their field the moment they had gone anywhere, and framing there
+      // would leave them sailing off the edge of a picture of the space they
+      // had left.
+      let reach = radius - 2;
+
+      for (const nd of g.nodes) {
+        if (!nd.some(r => r.magnet)) continue;
+
+        const pos = g.gridPos.get(nd);
+        if (pos) reach = Math.max(reach, Math.hypot(...pos) + 4);
+      }
+
+      g.focus = reach;
+
+      // Spent, or out at the rim: either way it stops being a charge and goes
+      // back to being somewhere. No point is made or destroyed by it — see
+      // `range` for why the second condition alone is not enough.
+      for (const nd of g.nodes) {
+        const pos = g.gridPos.get(nd);
+        if (!pos) continue;
+
+        const out = Math.hypot(...pos) >= reach;
+
+        for (const ray of nd) {
+          if (ray.magnet) continue;
+          if (!out && (ray.age ?? 0) < range) continue;
+
+          ray.moving = undefined;
+          ray.wave = undefined;
+          ray.heading = undefined;
+          ray.age = 0;
+          ray.fanned = false;
+          for (const bd of ray.boundaries) bd.polarity = Polarity.Neutral;
+        }
+      }
+
+      /**
+       * Huygens: every point of a front is itself a source of the front to
+       * come.
+       *
+       * Without this a pulse is twenty-six bullets. Moving is a swap with
+       * space, so the number of charges in a pulse is fixed at the number of
+       * directions the source had — while the shell they are supposed to make
+       * up needs more points the bigger it gets. Twenty-six points on a shell
+       * of radius one is a shell; twenty-six on a shell of radius ten is
+       * twenty-six rays with nothing in between, and two of those crossing
+       * almost never meet.
+       *
+       * So a charge in flight writes its polarity onto the neutral space
+       * around it that lies AHEAD — `spread` is how far round the front
+       * counts as ahead, as a dot product against where it is going — and
+       * each of those goes on in the direction it was written in. Nothing is
+       * created by this: a point that was space becomes a point that is a
+       * charge, and the population is what it was. What grows is how much of
+       * the space the wave passes through it is actually in.
+       */
+      const since = g._tickId - 1;
+
+      // Which way round the magnets are by now. `phase` is what makes this a
+      // property of each one rather than of the clock they share.
+      const pulse = Math.floor(since / every);
+
+      /*
+       * There was a rule here that cleared every cell touching a source, on
+       * the grounds that the space around a source belongs to it. It kept the
+       * sources emitting, and it is why the distance between them stops
+       * falling.
+       *
+       * A cell that is wiped clean every tick can never be holding a charge,
+       * so it can never be one of two that cancel, so it can never be
+       * destroyed. Each source was therefore wrapped in a shell of
+       * indestructible space, and two such shells with the sources inside
+       * them are a floor under how close the two can get — around six steps,
+       * which is exactly where it stopped. Nothing was wrong with the
+       * attraction; it had eaten everything it was allowed to eat.
+       *
+       * What the sources actually needed was not to be silted up by charges
+       * arriving back at them, and that is handled where it happens: a charge
+       * that moves into a source is absorbed by it (see `reflections` in
+       * `tick`). One rule, at the point of contact, and no protected region
+       * anywhere.
+       */
+
+      /**
+       * The sources emit FIRST, before the front below spreads.
+       *
+       * This is not a detail of ordering, it is what decides whether there is
+       * more than one pulse at all. A source can only write onto space, and
+       * the only space it ever has is the shell of points immediately around
+       * it — which is fresh every tick, because last tick's pulse moved off
+       * it and left new space behind. Spread the existing front first and
+       * that shell is claimed by the pulse that has just left it, tagged with
+       * the pulse before's name; the source then looks round, finds itself
+       * walled in by its own last emission, and emits nothing.
+       *
+       * What comes of that is one blob rather than a train of shells: a
+       * single wave id filling outwards, whose middle radius climbs much
+       * faster than one step a tick because it is thickening as well as
+       * travelling.
+       */
+      if (since % every === 0) {
+        for (const nd of [...g.nodes]) {
+          for (const ray of [...nd]) {
+            if (!ray.magnet) continue;
+
+            const here = g.gridPos.get(nd);
+            if (!here) continue;
+
+            // One point per place, and only places next door.
+            //
+            // A source emits onto the space AROUND it, which is the couple of
+            // dozen points a step away. What it must not do is emit down
+            // every connection it happens to hold: annihilation hands what
+            // the dying points were carrying to whatever was behind them, and
+            // a charge that turns round and cancels next to its own source
+            // leaves all of it there. The source accumulates connections
+            // reaching right across the world, emits down all of them, and
+            // each emission makes more charges to come back and leave more —
+            // which is a few dozen a tick becoming a few thousand, and a
+            // universe several times the size it was seeded at.
+            const written = new Set<node>();
+
+            const emits = ray.emits ?? Polarity.Positive;
+            const turned = spin && (pulse + (ray.phase ?? 0)) % 2 === 1;
+
+            const polarity = !turned ? emits
+              : emits === Polarity.Positive ? Polarity.Negative : Polarity.Positive;
+
+            // Every direction at once: the pulse is written onto everything
+            // the source is connected to, and each point of it leaves along
+            // the direction it was written in. A boundary with nothing on the
+            // far side is a direction with nowhere yet to put anything, so it
+            // waits — the frontier grows by things moving into it, not by the
+            // source shouting past the end of the world.
+            for (const bd of [...ray.boundaries]) {
+              const facing = bd.target;
+              if (!facing) continue;
+
+              const there = facing.at.node;
+              if (there === nd || written.has(there)) continue;
+
+              const at = g.gridPos.get(there);
+              if (!at) continue;
+
+              // Next door, and not down some connection that closed up over
+              // the space it used to pass through.
+              if (Math.max(...here.map((v, i) => Math.abs(at[i] - v))) !== 1) continue;
+
+              written.add(there);
+
+              // Only space can be told what to be. Anything already going
+              // somewhere is somebody, and so is the other magnet.
+              if (there.some(r => r.moving || r.magnet)) continue;
+
+              const dir = g.direction(bd);
+              if (!dir) continue;
+
+              // Which pole this direction is out of. A source with no axis
+              // has no poles and puts the same thing out everywhere; one with
+              // an axis puts `polarity` out of the half facing along it and
+              // the opposite out of the half facing back, with the ring
+              // exactly across it emitting nothing — an equator, which is
+              // what makes it a magnet and not a lamp.
+              let out = polarity;
+
+              if (ray.axis) {
+                const along = dir.reduce((sum, v, i) => sum + v * (ray.axis![i] ?? 0), 0);
+                if (Math.abs(along) < 1e-9) continue;
+
+                if (along < 0) out = polarity === Polarity.Positive
+                  ? Polarity.Negative
+                  : Polarity.Positive;
+              }
+
+              for (const r of there)
+                for (const x of r.boundaries) x.polarity = out;
+
+              facing.at.moving = g.along(facing.at, dir, 1);
+
+              // Which emission this is: one pulse per source per turn of it,
+              // which is what makes a pulse a thing with a surface.
+              facing.at.wave = pulse * sides.length + (ray.source ?? 0);
+
+              g.stats.emitted++;
+            }
+          }
+        }
+      }
+
+      /**
+       * Once each, and not straight away.
+       *
+       * Concentric shells one step apart, one per tick, moving one step per
+       * tick, are exactly the shells that tile a ball — so filling every one
+       * of them fills the ball completely, and a ball with no space in it is
+       * a ball in which nothing can move, since moving is trading places with
+       * space. That is not a near miss to be tuned around; unit shells at
+       * every radius sum to the volume they sit in, and it is why spreading
+       * on every tick froze the field solid.
+       *
+       * What is affordable is a fixed number of points per shell rather than
+       * a filled one: each ray fans out ONCE, into the ring of directions
+       * across its path, and its children never fan again. A pulse is then
+       * twenty-six rays and their fan — a couple of hundred points — however
+       * far out it gets.
+       *
+       * And it waits until `fanAt` before doing it. A shell of radius two has
+       * only a few dozen cells in it and is already as full as it can be, so
+       * fanning immediately puts every child straight into the crush around
+       * the source, walls the source in, and stops the emission. Waiting
+       * until the shell is wide enough to have somewhere to put them spends
+       * the same points where there is room for them — and where they are
+       * wanted, since what a shell is for is meeting the other one, and that
+       * happens out at the distance between the sources rather than next
+       * door.
+       */
+      if (spread <= 1) {
+        const front: { ray: Ray, dir: number[], polarity: Polarity, wave?: number }[] = [];
+
+        for (const nd of g.nodes) {
+          for (const ray of nd) {
+            if (ray.magnet || !ray.moving) continue;
+            if (ray.moving.polarity === Polarity.Neutral) continue;
+
+            // Age is counted in `tick`, once, for everything in flight.
+            if (ray.fanned || (ray.age ?? 0) < fanAt) continue;
+
+            const dir = g.direction(ray.moving);
+            if (!dir) continue;
+
+            ray.fanned = true;
+            front.push({ ray, dir, polarity: ray.moving.polarity, wave: ray.wave });
+          }
+        }
+
+        for (const { ray, dir, polarity, wave } of front) {
+          for (const bd of ray.boundaries) {
+            const facing = bd.target;
+            if (!facing) continue;
+
+            const there = facing.at.node;
+            if (there === ray.node) continue;
+            if (there.some(r => r.moving || r.magnet)) continue;
+
+            const d = g.direction(bd);
+            if (!d) continue;
+
+            // BESIDE us — not behind, and not ahead either.
+            //
+            // Behind is everywhere the wave has already been, and filling
+            // that in is a wave that never leaves anywhere. Ahead is where we
+            // are going ourselves, and filling that in is a wave that thickens
+            // into a solid ball instead of staying a surface. What is left is
+            // the ring of directions across our path, which is the front
+            // itself: the shell grows sideways, into the room a bigger shell
+            // has that a smaller one didn't.
+            const along = d.reduce((sum, v, i) => sum + v * dir[i], 0);
+            if (along < spread || along > 0.9) continue;
+
+            for (const r of there)
+              for (const x of r.boundaries) x.polarity = polarity;
+
+            // And it leaves in the direction between ours and its own, so the
+            // front fans out as it goes rather than travelling as a sheaf of
+            // parallel lines. Twenty-six directions repeatedly split between
+            // is how a lattice with twenty-six of them makes a round shell.
+            const bias = dir.map((v, i) => v + d[i]);
+
+            facing.at.moving = g.along(facing.at, bias, 1);
+            facing.at.wave = wave; // still the same pulse, spread wider
+
+            // Already fanned, as far as it is concerned. Otherwise each child
+            // fans in turn and the shell doubles every tick until it has
+            // filled everything, which is where this started.
+            facing.at.fanned = true;
+            facing.at.age = ray.age;
+          }
+        }
+      }
+    };
+
+    return graph;
+  }
+
   /**
    * The smallest possible universe: two spatial points A—B, one ray each,
    * joined by a mutual boundary pair. Every permutation of (polarity,
@@ -1162,7 +2682,7 @@ class Graph {
       rights.push(right);
 
       graph.nodes.push(nd);
-      graph.gridPos.set(nd, [i - (n - 1) / 2, 0, 0]);
+      graph.setPos(nd, [i - (n - 1) / 2, 0, 0]);
     });
 
     for (let i = 0; i + 1 < n; i++) {
@@ -1188,6 +2708,12 @@ class Graph {
     graph.ringRadius = this.ringRadius;
     graph._tickId = this._tickId;
     graph.onTick = this.onTick;
+    graph.relax = this.relax;
+    graph.wander = this.wander;
+    graph.sealed = this.sealed;
+    graph.focus = this.focus;
+    graph.events = this.events.map(e => ({ ...e, at: e.at.slice() }));
+    graph.history = this.history.slice();
 
     const rays = new Map<Ray, Ray>();
     const boundaries = new Map<Boundary, Boundary>();
@@ -1200,6 +2726,17 @@ class Graph {
         r.id = ray.id;
         r.node = copy;
         r.boundaries = [];
+        r.magnet = ray.magnet;
+        r.emits = ray.emits;
+        r.phase = ray.phase;
+        r.source = ray.source;
+        r.wave = ray.wave;
+        r.credit = ray.credit;
+        r.mass = ray.mass;
+        r.age = ray.age;
+        r.fanned = ray.fanned;
+        r.axis = ray.axis;
+        r.heading = ray.heading?.slice();
         rays.set(ray, r);
         copy.push(r);
 
@@ -1216,7 +2753,7 @@ class Graph {
       graph.nodes.push(copy);
 
       const pos = this.gridPos.get(nd);
-      if (pos) graph.gridPos.set(copy, pos.slice());
+      if (pos) graph.setPos(copy, pos.slice());
     }
 
     // Second pass — every boundary now exists, so the references between
@@ -1239,6 +2776,12 @@ class Graph {
   private dirty = true;
 
   get layout(): Map<node, Vec> {
+    // A relaxed layout is never done: it eases towards the shape the
+    // connections are asking for, and is recomputed every time it is looked
+    // at rather than once per tick, so what the structure does to it is
+    // something that happens over frames instead of in one jump.
+    if (this.relax) return this.relaxedLayout();
+
     if (!this.layoutCache || this.dirty) {
       this.layoutCache = this.sphereLayout({ scale: LATTICE_STEP });
       this.dirty = false;
@@ -1247,6 +2790,240 @@ class Graph {
     return this.layoutCache;
   }
 
+  /**
+   * The last relaxed layout, which the next one starts from — and, with it,
+   * the working set the solve runs on.
+   *
+   * This is cached across frames on purpose. The connections only change when
+   * the world does, which is once a tick, while the solve runs every frame:
+   * rebuilding the list of them sixty times a second means allocating some
+   * eighty thousand of them sixty times a second, for a list that was already
+   * correct. So the structure is rebuilt when the structure changes, and in
+   * between, the passes run over what is already there — mutating the
+   * position vectors in place, which is also why the map handed to the
+   * renderer doesn't have to be rebuilt either.
+   */
+  private relaxed?: {
+    at: Map<node, Vec>;
+    P: Vec[];
+    links: { i: number, j: number, rest: number, weight: number }[];
+    correction: Vec[];
+    asked: number[];
+  };
+
+  /**
+   * Where the points are, if where they are is decided by what they are
+   * connected to.
+   *
+   * Every connection wants to be one step long — one step in ITS direction,
+   * so a face connection wants 1 and a corner connection √3, which is what
+   * keeps a lattice wired in all twenty-six directions from crumpling. A
+   * connection whose two ends are three cells apart in coordinates still
+   * wants to be one step, because the two cells in between were annihilated
+   * and are not anywhere any more. That single sentence is the gravity in
+   * this model: destroyed space is shorter space, and shorter space pulls
+   * whatever is on either side of it together.
+   *
+   * It is a positional solve rather than a force integration — each pass
+   * moves every point by the average of what its connections are asking of
+   * it — so there is no velocity to blow up and no timestep to tune. It
+   * cannot overshoot at stiffness ≤ 1, which matters when the thing being
+   * solved gains and loses points every tick.
+   */
+  relaxedLayout(
+    {
+      scale = LATTICE_STEP,
+      iterations = 3,
+      stiffness = 0.65,
+      adjacency = 12,
+    }: {
+      scale?: number, iterations?: number,
+      stiffness?: number, adjacency?: number,
+    } = {},
+  ): Map<node, Vec> {
+    const dims = this.dims;
+
+    if (!this.dirty && this.relaxed) {
+      this.solve(this.relaxed, iterations, stiffness, dims);
+
+      return this.relaxed.at;
+    }
+
+    this.dirty = false;
+
+    const previous = this.relaxed?.at;
+    const list = this.nodes;
+
+    const index = new Map<node, number>();
+    list.forEach((nd, i) => index.set(nd, i));
+
+    const P: Vec[] = new Array(list.length);
+    const fresh: number[] = [];
+
+    for (let i = 0; i < list.length; i++) {
+      const was = previous?.get(list[i]);
+
+      if (was) { P[i] = was; continue; }
+
+      fresh.push(i);
+      const grid = this.gridPos.get(list[i]);
+      P[i] = grid && grid.length ? grid.map(v => v * scale) : new Array(dims).fill(0);
+    }
+
+    // A point that has only just come into being appears where its neighbours
+    // already are, one step off them in the direction its coordinate says it
+    // lies — not at the coordinate itself. It was put down in space that has
+    // already been bent, and dropping it in at the unbent position would be a
+    // kick delivered every time anything moves.
+    const isFresh = new Set(fresh);
+
+    for (const i of fresh) {
+      const here = this.gridPos.get(list[i]);
+      if (!here) continue;
+
+      const sum = new Array(dims).fill(0);
+      let n = 0;
+
+      for (const ray of list[i]) {
+        for (const bd of ray.boundaries) {
+          const other = bd.target?.at.node;
+          if (!other) continue;
+
+          const j = index.get(other);
+          if (j === undefined || isFresh.has(j)) continue;
+
+          const there = this.gridPos.get(other);
+          if (!there) continue;
+
+          const step = latticeStep(here.map((v, k) => v - there[k]));
+          if (!step) continue;
+
+          for (let k = 0; k < dims; k++) sum[k] += P[j][k] + step[k] * scale;
+          n++;
+        }
+      }
+
+      if (n) P[i] = sum.map(v => v / n);
+    }
+
+    /**
+     * Every connection, once, with the length it is asking for and how loudly
+     * it asks. Built up front rather than per pass, since it is the same list
+     * every pass.
+     *
+     * `adjacency` is how much more a connection that spans destroyed space
+     * counts than an ordinary one, per cell it spans. At 1 they count the
+     * same, and the picture is the honest compromise: two sources that have
+     * eaten their way to each other are held apart anyway, because each of
+     * them has twenty-six other connections all quite happy where they are,
+     * and one voice against twenty-six moves nothing.
+     *
+     * Above 1 the picture takes a side. It says that a connection standing
+     * where sixteen points used to be is a stronger claim about what is next
+     * to what than a connection that has never had anything happen to it —
+     * that adjacency arrived at by destroying everything in between should
+     * win against the undisturbed shape of the lattice around it.
+     *
+     * That is a decision about the drawing and not a law of the model, and it
+     * is worth being plain that nothing derives it. What it buys is a picture
+     * in which two things that have become neighbours are drawn as
+     * neighbours, which is the thing the whole exercise is trying to show and
+     * which the even-handed version will not show at any zoom.
+     */
+    const links: { i: number, j: number, rest: number, weight: number }[] = [];
+
+    for (let i = 0; i < list.length; i++) {
+      const here = this.gridPos.get(list[i]);
+
+      for (const ray of list[i]) {
+        for (const bd of ray.boundaries) {
+          const other = bd.target?.at.node;
+          if (!other) continue;
+
+          const j = index.get(other);
+          if (j === undefined || j <= i) continue; // once per pair
+
+          const there = this.gridPos.get(other);
+          const offset = here && there ? here.map((v, k) => v - there[k]) : undefined;
+          const step = offset && latticeStep(offset);
+
+          // How far apart the two ends still are in coordinates — which, for
+          // a connection, is how much has been taken out from between them.
+          const spans = offset ? Math.max(...offset.map(Math.abs)) : 1;
+
+          links.push({
+            i, j,
+            rest: (step ? Math.hypot(...step) : 1) * scale,
+            weight: 1 + Math.max(spans - 1, 0) * adjacency,
+          });
+        }
+      }
+    }
+
+    const at = new Map<node, Vec>();
+    for (let i = 0; i < list.length; i++) at.set(list[i], P[i]);
+
+    this.relaxed = {
+      at, P, links,
+      correction: list.map(() => new Array(dims).fill(0)),
+      asked: new Array(list.length).fill(0),
+    };
+
+    this.solve(this.relaxed, iterations, stiffness, dims);
+
+    return at;
+  }
+
+  // One or more passes of the solve above, over a working set that is already
+  // built. Positions are moved in place, so everything holding a reference to
+  // one — the map the renderer reads, above all — is up to date by the time
+  // this returns.
+  private solve(
+    { P, links, correction, asked }: NonNullable<Graph['relaxed']>,
+    iterations: number,
+    stiffness: number,
+    dims: number,
+  ) {
+    for (let pass = 0; pass < iterations; pass++) {
+      for (let i = 0; i < P.length; i++) {
+        correction[i].fill(0);
+        asked[i] = 0;
+      }
+
+      for (const { i, j, rest, weight } of links) {
+        let lengthSq = 0;
+
+        for (let k = 0; k < dims; k++) {
+          const d = P[j][k] - P[i][k];
+          lengthSq += d * d;
+        }
+
+        const length = Math.sqrt(lengthSq);
+        if (length < 1e-6) continue;
+
+        // Half the error each, so neither end is privileged over the other.
+        const pull = ((length - rest) / length) * 0.5 * stiffness * weight;
+
+        for (let k = 0; k < dims; k++) {
+          const d = (P[j][k] - P[i][k]) * pull;
+          correction[i][k] += d;
+          correction[j][k] -= d;
+        }
+
+        // A weighted average, so a connection that counts for more moves its
+        // ends more — rather than a louder constraint simply overshooting,
+        // which is what an unweighted divisor would turn it into.
+        asked[i] += weight;
+        asked[j] += weight;
+      }
+
+      for (let i = 0; i < P.length; i++) {
+        const n = asked[i] || 1;
+        for (let k = 0; k < dims; k++) P[i][k] += correction[i][k] / n;
+      }
+    }
+  }
+
   /**
    * Deterministic cube→sphere layout.
    *
@@ -1485,6 +3262,64 @@ class Ray {
   // of that boundary's connection (moving.target's node).
   moving?: Boundary;
 
+  // A source: something that goes on writing a charge onto the space around
+  // it, tick after tick, rather than being written once and then only ever
+  // interacting. Nothing in the rules makes one — the rules have no way to
+  // begin anything — so it is the seed's doing, and the only thing the rules
+  // have to know about it is that it is never mistaken for space.
+  //
+  // `emits` is the polarity it puts out, and `phase` offsets its turning
+  // against the other sources, so two magnets can be spinning together or
+  // against each other.
+  magnet?: boolean;
+  emits?: Polarity;
+  phase?: number;
+
+  // Which way round it is: `emits` out of the half pointing this way, the
+  // opposite out of the half pointing back, nothing across the middle. Absent
+  // for a source with no sides, which puts the same thing out everywhere.
+  axis?: number[];
+
+  // What a step costs this ray, as a multiple of the step's own length. One
+  // for everything the rules make; more for a source, which is the only thing
+  // here heavy enough to be worth pushing. See `MAGNET_MASS`.
+  mass?: number;
+
+  // Which source, for a source; which emission of it, for a charge that came
+  // out of one. The dynamics never read either — a charge is a charge and
+  // what it does depends on nothing but its polarity and where it is going.
+  // It is bookkeeping for the picture: what makes one pulse one pulse, and
+  // therefore something that can be drawn as a surface instead of as a few
+  // thousand unrelated points.
+  source?: number;
+  wave?: number;
+
+  // How many ticks a charge has been in flight, and whether it has yet fanned
+  // out into the room a bigger shell has that a smaller one hadn't. See the
+  // Huygens step in `Graph.magnets`.
+  age?: number;
+  fanned?: boolean;
+
+  /**
+   * The way it is going in the large, which is not the same as the step it is
+   * taking this tick.
+   *
+   * Wandering takes a direction apart — a ray heading along (1,1,1) may spend
+   * this move going (1,0,0) instead — and without somewhere to keep the whole
+   * direction, taking it apart destroys it: the step becomes the direction,
+   * its only piece is itself, and the ray is committed to an axis forever
+   * after one unlucky move. Kept here, the pieces are only ever a detour, and
+   * the way it was going is still there to come back to.
+   */
+  heading?: number[];
+
+  // How much of its next step it has paid for. A step costs its own length
+  // and a tick pays one, so a ray going along an axis is always ready and one
+  // going through a corner is ready five times in nine — which is what makes
+  // every direction travel at the same speed. See the movement half of
+  // `tick`.
+  credit?: number;
+
   constructor(
     public node: node, // reassignable: nodes merge on annihilation
     graph: Graph
@@ -1572,6 +3407,24 @@ function initialPosition(
 // is passed as a bare boolean rather than a count.
 const DEFAULT_STEPS = 8;
 
+/**
+ * How much of the universe is worth drawing.
+ *
+ * `lattice` draws all of it: every boundary of every point, one stroke each.
+ * That is the right thing for a universe of a dozen points, where each one is
+ * the subject.
+ *
+ * `field` is for the ones with thousands. A point wired in all twenty-six
+ * directions has twenty-six boundaries, and a ball of a thousand such points
+ * has some thirteen thousand connections — drawn one stroke at a time it is
+ * both unaffordable and a solid grey fog. So the space is drawn as its
+ * axis-aligned connections only, batched into a single path, and everything
+ * on top of it is only what is HAPPENING: the sources, and the charges in
+ * flight. The lattice bending is then something you can see, because there is
+ * a lattice to see rather than a fill.
+ */
+type RenderMode = 'lattice' | 'field';
+
 export interface CalculusVisualizationProps {
   // The universe to run. A factory, not an instance: it is called again on
   // every reset, so each cycle starts from a freshly seeded graph.
@@ -1594,6 +3447,13 @@ export interface CalculusVisualizationProps {
   // costs a few hundred gradient fills a frame, times however many of these
   // are on the page).
   density?: boolean;
+
+  mode?: RenderMode;
+
+  // Seconds per tick. The default is slow enough to read one interaction at a
+  // time; a universe whose interest is in what it does over a hundred ticks
+  // wants to be quicker than that.
+  interval?: number;
 }
 
 /**
@@ -1610,6 +3470,7 @@ const GraphView = ({
   graph: current,
   animate = false,
   density = true,
+  mode = 'lattice',
   onFrame,
 }: {
   // Read afresh every frame, so a reset that swaps the whole graph out is
@@ -1617,6 +3478,7 @@ const GraphView = ({
   graph: () => Graph;
   animate?: boolean;
   density?: boolean;
+  mode?: RenderMode;
   onFrame?: (dt: number) => void;
 }) => {
   const canvasRef = useRef(null);
@@ -1739,6 +3601,7 @@ const GraphView = ({
     function draw() {
       const cam = camRef.current;
       const graph = latest.current.current();
+      const field = mode === 'field';
 
       const w = canvas.clientWidth, h = canvas.clientHeight;
 
@@ -1754,13 +3617,19 @@ const GraphView = ({
 
       const layout = graph.layout;
 
+      // What the camera measures itself against. Everything, unless the
+      // universe has said which part of itself is the subject — see `focus`.
+      const framed = graph.focus === undefined
+        ? [...layout]
+        : [...layout].filter(([nd]) => graph.inFocus(nd));
+
       // Raw world extent (unprojected) — this is what the base pixel scale
       // tracks, deliberately independent of camera distance/perspective, so
       // there's no feedback loop between "how far the camera has dollied" and
       // "how much of the grid fits on screen". A real camera doesn't refit
       // its FOV to guarantee everything stays visible as it moves closer.
       let worldExtent = 1e-6;
-      for (const [node, pos] of layout) {
+      for (const [node, pos] of framed) {
         const r = Math.hypot(...pos);
         if (r > worldExtent) worldExtent = r;
       }
@@ -1775,7 +3644,7 @@ const GraphView = ({
       // rather than snapping.
       const lo = [Infinity, Infinity, Infinity];
       const hi = [-Infinity, -Infinity, -Infinity];
-      for (const [, pos] of layout) {
+      for (const [, pos] of framed) {
         for (let k = 0; k < 3; k++) {
           const v = pos[k] || 0;
           if (v < lo[k]) lo[k] = v;
@@ -1853,7 +3722,7 @@ const GraphView = ({
         if (y > hiY) hiY = y;
       };
       for (const [n, p] of projected) {
-        if (p.clipped) continue;
+        if (p.clipped || !graph.inFocus(n)) continue;
         consider(p.x, p.y);
 
         for (const ray of n) {
@@ -1921,25 +3790,74 @@ const GraphView = ({
       // Connections — one faint line per boundary link (deduped), following
       // the actual graph structure, so merged and newly-created nodes read
       // correctly wherever they sit.
-      ctx.strokeStyle = "rgba(140,150,180,0.3)";
-      ctx.lineWidth = 2.2;
+      //
+      // In `field` mode this is the whole of how space is drawn, and it is
+      // one path stroked once rather than a stroke per connection — a lattice
+      // wired in every direction has too many of them for anything else. Only
+      // the axis-aligned ones are taken: the diagonals are just as real, but
+      // drawing all twenty-six through every point is a grey fill you can
+      // read nothing off, where three lines through every point is a grid
+      // whose bending is the thing worth seeing.
+      // Faint enough to be the paper rather than the drawing: what the
+      // lattice is here for is to be bent, and reading a bend needs only
+      // enough of a grid to see it against.
+      ctx.strokeStyle = field ? "rgba(124,136,176,0.08)" : "rgba(140,150,180,0.3)";
+      ctx.lineWidth = field ? 1 : 2.2;
       const idxOf = new Map<node, number>();
       graph.nodes.forEach((nd, i) => idxOf.set(nd, i));
-      const drawnEdge = new Set<string>();
+
+      if (field) ctx.beginPath();
       for (const nd of graph.nodes) {
         const a = pts.get(nd);
         if (!a || a.clipped) continue;
+
+        // Outside the frame there is lattice nothing can reach — the edge
+        // absorbs before anything gets there — so it is a few thousand
+        // segments a frame drawn beyond the edge of the picture.
+        if (field && !graph.inFocus(nd)) continue;
+
         for (const ray of nd) {
           for (const bd of ray.boundaries) {
             const other = bd.target?.at.node;
             if (!other || other === nd) continue;
-            const ia = idxOf.get(nd)!, ib = idxOf.get(other)!;
-            const ek = ia < ib ? ia + "-" + ib : ib + "-" + ia;
-            if (drawnEdge.has(ek)) continue;
-            drawnEdge.add(ek);
+
+            // Each connection drawn once, from its lower-numbered end. This
+            // was a set of "ia-ib" strings, which on a lattice wired in
+            // twenty-six directions is a couple of hundred thousand strings
+            // built and hashed every frame to answer a question two integers
+            // already answer.
+            if (idxOf.get(nd)! > idxOf.get(other)!) continue;
+
             const b = pts.get(other);
             if (!b || b.clipped) continue;
             if (!onScreen(a) && !onScreen(b)) continue;
+
+            if (field) {
+              const from = graph.gridPos.get(nd), to = graph.gridPos.get(other);
+              if (!from || !to) continue;
+
+              // One step, along an axis. Anything longer is a connection that
+              // has closed up over space that was annihilated out from
+              // between its two ends — real, and the reason the two ends are
+              // now near each other, but it is not an event and must not look
+              // like one. They accumulate: every cancellation there has ever
+              // been leaves one behind, permanently, so marking them out puts
+              // a growing web of bright lines over the picture that reads as
+              // things happening everywhere at once and never stopping.
+              //
+              // What they do is already visible without drawing them, because
+              // the layout is solved against them (`relaxedLayout`): they pull
+              // their ends together, and that pulling IS the attraction. So
+              // they are left to act rather than shown acting.
+              const off = from.map((v, i) => to[i] - v);
+              if (off.filter(v => v !== 0).length !== 1) continue;
+              if (Math.max(...off.map(Math.abs)) > 1) continue;
+
+              ctx.moveTo(a.x, a.y);
+              ctx.lineTo(b.x, b.y);
+              continue;
+            }
+
             ctx.beginPath();
             ctx.moveTo(a.x, a.y);
             ctx.lineTo(b.x, b.y);
@@ -1948,6 +3866,8 @@ const GraphView = ({
         }
       }
 
+      if (field) ctx.stroke();
+
       // Gravity-flow density cloud — the warm glow that fills the dense
       // core. A continuous scalar potential sampled on a real 3D grid,
       // colored on a dark→purple→orange→white ramp and blended additively
@@ -2034,13 +3954,276 @@ const GraphView = ({
         ctx.globalCompositeOperation = prevComposite;
       }
 
+      /**
+       * The way from one source to the other, as it currently runs.
+       *
+       * Two sources that have eaten the space between them end up one step
+       * apart along ONE route, and as far apart as they ever were along every
+       * other — because what a pulse meeting a pulse destroys is a line, not
+       * a region. That structure has no faithful drawing in three dimensions:
+       * asked to put two points both next to each other and far apart, a
+       * layout can only compromise, and that compromise is the dimple you see
+       * instead of two things arriving.
+       *
+       * So the closeness is drawn as what it actually is — the chain of
+       * points you would have to pass through to get from one source to the
+       * other. Long and wandering to begin with, a short bright link between
+       * two neighbours by the end. That shortening IS the attraction, and it
+       * is visible here whether or not the two are ever drawn near each
+       * other.
+       */
+      if (field && graph.route.length > 1) {
+        const chain = graph.route
+          .map(nd => pts.get(nd))
+          .filter(p => p && !p.clipped) as { x: number, y: number }[];
+
+        if (chain.length > 1) {
+          ctx.strokeStyle = "rgba(255,214,66,0.45)";
+          ctx.lineWidth = 2.4;
+          ctx.lineCap = "round";
+          ctx.beginPath();
+          ctx.moveTo(chain[0].x, chain[0].y);
+          for (let i = 1; i < chain.length; i++) ctx.lineTo(chain[i].x, chain[i].y);
+          ctx.stroke();
+
+          ctx.fillStyle = "rgba(255,232,150,0.8)";
+          for (const p of chain) {
+            ctx.beginPath();
+            ctx.arc(p.x, p.y, 2, 0, Math.PI * 2);
+            ctx.fill();
+          }
+
+          ctx.lineCap = "butt";
+        }
+      }
+
+      /**
+       * Wavefronts, drawn as what they actually are.
+       *
+       * A pulse is hundreds of charges and drawing them one at a time is a
+       * snowstorm — least of all can you tell where one pulse ends and the
+       * next begins, which is the thing worth seeing when two sources are
+       * turning over and putting out alternating shells. So each is drawn as
+       * one translucent surface, coloured by the charge it carries.
+       *
+       * Not as a sphere, though. A sphere is a claim about the space it is
+       * drawn in — that a pulse is the same distance out in every direction,
+       * from a centre — and it is exactly the claim this picture exists to
+       * deny. Space here is warped by what has been destroyed in it: the
+       * layout is solved against the connections rather than laid out on a
+       * grid, so a shell that left its source evenly is drawn dented wherever
+       * the space it is crossing has been eaten. Fitting a circle to that
+       * puts a ring somewhere near the points and centred on nothing in
+       * particular — which is why the rings did not appear to come out of
+       * their source.
+       *
+       * So the surface is taken from the points themselves: the outline that
+       * encloses them as they are actually drawn. It has no centre and no
+       * radius and assumes no shape. It surrounds its pulse — dented where
+       * the pulse is dented, and starting at the source because that is where
+       * the pulse starts.
+       */
+      if (field) {
+        /**
+         * Grouped by pulse AND by charge, not by pulse alone.
+         *
+         * A source with poles puts opposite charges out of its two halves in
+         * the same breath, so one pulse is two things: positive over here and
+         * negative over there. Collected under the pulse alone they are one
+         * set of points, drawn as one outline, in whichever of the two
+         * charges happened to be looked at first — a magnet drawn as a plain
+         * ring of one polarity, with the entire fact that it has sides thrown
+         * away in the grouping.
+         *
+         * Split by charge as well and each half gets its own surface in its
+         * own colour: two lobes leaving together, one warm and one cold, with
+         * the equator between them that emits nothing.
+         */
+        const waves = new Map<string, {
+          id: number, at: { x: number, y: number }[], depth: number, polarity: Polarity,
+        }>();
+
+        for (const nd of graph.nodes) {
+          // A pulse that has left the space we set up has left the picture
+          // with it. Drawn anyway, every shell ever emitted is still on
+          // screen as an ever-larger outline, and the thing being watched is
+          // behind forty of them.
+          if (!graph.inFocus(nd)) continue;
+
+          for (const ray of nd) {
+            if (ray.magnet || !ray.moving || ray.wave === undefined) continue;
+
+            const p = pts.get(nd);
+            if (!p || p.clipped) continue;
+
+            const polarity = ray.moving.polarity;
+            const key = `${ray.wave}|${polarity}`;
+
+            let wave = waves.get(key);
+            if (!wave) waves.set(key, wave = { id: ray.wave, at: [], depth: 0, polarity });
+
+            wave.at.push({ x: p.x, y: p.y });
+            wave.depth += p.depth;
+            break; // one point per point, however many rays are sitting on it
+          }
+        }
+
+        // Pulses go out in order, so the largest id is the newest, and a
+        // handful before it are the ones still in flight. Anything older than
+        // that is a straggler — a few charges that jammed against each other
+        // long ago and have been sitting there since, still carrying the id
+        // of the pulse they set out with. Drawn, they are a shell that never
+        // leaves.
+        let newest = -Infinity;
+        for (const wave of waves.values()) if (wave.id > newest) newest = wave.id;
+
+        /**
+         * How far back to keep drawing, and it is a question about reading
+         * rather than about honesty.
+         *
+         * Every pulse still in flight is really there, and drawing all of
+         * them puts a dozen nested outlines around each source with a dozen
+         * more from the other laid over the top. Nothing in that is wrong and
+         * none of it can be followed.
+         *
+         * What has to survive the trim is that the pulses ALTERNATE, and that
+         * takes about as many of them as it takes to see warm, cold, warm —
+         * half a dozen, fading out with age so the sequence reads as a train
+         * going outwards rather than as a set of rings that happen to be
+         * nested. The older ones are still in the world doing their work; the
+         * picture just stops insisting on them.
+         */
+        const LIVE = 12; // ids — six ticks' worth, across two sources
+
+        // The outline enclosing a set of points, as drawn. Andrew's monotone
+        // chain: sort, then walk once along the bottom and once back along
+        // the top, dropping any point the walk turns the wrong way at.
+        const outline = (at: { x: number, y: number }[]) => {
+          const p = at.slice().sort((a, b) => a.x - b.x || a.y - b.y);
+          const turn = (o: typeof p[0], a: typeof p[0], b: typeof p[0]) =>
+            (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+
+          const half = (source: typeof p) => {
+            const out: typeof p = [];
+
+            for (const q of source) {
+              while (out.length >= 2 && turn(out[out.length - 2], out[out.length - 1], q) <= 0) out.pop();
+              out.push(q);
+            }
+
+            out.pop();
+
+            return out;
+          };
+
+          return half(p).concat(half(p.slice().reverse()));
+        };
+
+        const shells = [...waves.values()]
+          .filter(wave => wave.id >= newest - LIVE && wave.at.length >= 3)
+          .map(wave => ({
+            hull: outline(wave.at),
+            depth: wave.depth / wave.at.length,
+            polarity: wave.polarity,
+            // 0 for the pulse just emitted, 1 for the oldest still drawn.
+            age: Math.min((newest - wave.id) / LIVE, 1),
+          }))
+          .filter(shell => shell.hull.length >= 3)
+          // Far ones first, so a near shell reads as being in front of one
+          // behind it rather than the two just adding up.
+          .sort((a, b) => b.depth - a.depth);
+
+        const prev = ctx.globalCompositeOperation;
+        ctx.globalCompositeOperation = "lighter";
+
+        for (const shell of shells) {
+          const tint = shell.polarity === Polarity.Positive ? "255,122,69"
+            : shell.polarity === Polarity.Negative ? "61,220,255"
+              : "150,157,178";
+
+          // Drawn as a smooth closed curve rather than as the corners it was
+          // computed from. A surface through a few dozen points is a surface;
+          // the straight lines between them are an artefact of there being
+          // finitely many, and drawing those says the shell has flat facets
+          // and sharp edges, which is a claim about it that nothing supports.
+          //
+          // Catmull-Rom: each span is bent by where the points on either side
+          // of it are, so the curve passes through every point and leaves it
+          // heading towards the next one.
+          const h = shell.hull;
+          const at = (i: number) => h[(i % h.length + h.length) % h.length];
+
+          ctx.beginPath();
+          ctx.moveTo(h[0].x, h[0].y);
+
+          for (let i = 0; i < h.length; i++) {
+            const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
+
+            ctx.bezierCurveTo(
+              p1.x + (p2.x - p0.x) / 6, p1.y + (p2.y - p0.y) / 6,
+              p2.x - (p3.x - p1.x) / 6, p2.y - (p3.y - p1.y) / 6,
+              p2.x, p2.y,
+            );
+          }
+
+          ctx.closePath();
+
+          // Newest brightest, oldest nearly gone — which is what makes half a
+          // dozen outlines read as one train going outwards instead of as a
+          // stack of rings all insisting equally.
+          const fade = 1 - shell.age * 0.85;
+
+          // Barely there through the middle, so shells behind and the lattice
+          // through them stay visible, with the surface itself on the edge.
+          ctx.fillStyle = `rgba(${tint},${0.025 * fade})`;
+          ctx.fill();
+
+          ctx.strokeStyle = `rgba(${tint},${0.42 * fade})`;
+          ctx.lineWidth = 1.1;
+          ctx.stroke();
+        }
+
+        ctx.globalCompositeOperation = prev;
+      }
+
       for (const n of graph.nodes) {
         const p = pts.get(n);
         if (!p || p.clipped || !onScreen(p)) continue;
         const depth = Math.min(Math.max(p.depth, 0.4), 1.6);
 
-        // Center seed: a soft glow marking where the universe started.
-        if (isCenterNode(n)) {
+        // In field mode everything in flight has already been drawn, as the
+        // surface it belongs to. What is left to draw one point at a time is
+        // what isn't a surface: the sources, and (below) the places where
+        // something is about to happen.
+        const magnet = n.some(r => r.magnet);
+        if (field && !magnet) continue;
+
+        // The origin of the waves. Everything charged in this universe came
+        // out of one of these, so it is the one thing that isn't an event but
+        // a cause of them — drawn as its own colour rather than as a polarity,
+        // since it has none.
+        if (magnet) {
+          const r = Math.min(Math.max(cam.scale * 0.2 * depth, 2), 30);
+
+          const halo = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3.2);
+          halo.addColorStop(0, "rgba(255,214,66,0.85)");
+          halo.addColorStop(0.35, "rgba(255,186,40,0.3)");
+          halo.addColorStop(1, "rgba(255,186,40,0)");
+          ctx.fillStyle = halo;
+          ctx.beginPath();
+          ctx.arc(p.x, p.y, r * 3.2, 0, Math.PI * 2);
+          ctx.fill();
+
+          ctx.fillStyle = "#FFE066";
+          ctx.beginPath();
+          ctx.arc(p.x, p.y, Math.max(r * 0.4, 1.6), 0, Math.PI * 2);
+          ctx.fill();
+        }
+
+        // Center seed: a soft glow marking where the universe started. In
+        // field mode the origin is only the point halfway between the two
+        // sources, and glowing there would read as a third one.
+        if (!field && isCenterNode(n)) {
           const r = Math.min(Math.max(cam.scale * 0.16 * depth, 0.8), 26);
           const g = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3);
           g.addColorStop(0, "rgba(255,217,168,0.9)");
@@ -2148,15 +4331,193 @@ const GraphView = ({
           }
         }
 
-        // Dim pass first, so the highlighted one is never overdrawn by it.
+        // Dim pass first, so the highlighted one is never overdrawn by it —
+        // and skipped entirely in field mode, where the twenty-five
+        // directions a charge ISN'T going are twenty-five stubs saying
+        // nothing, per charge, per frame.
         for (const { bd, moving } of slots.values())
-          if (!moving) stub(bd, false);
+          if (!moving && !field) stub(bd, false);
 
         for (const { bd, moving } of slots.values())
           if (moving) stub(bd, true);
 
         ctx.lineCap = "butt";
       }
+
+      // What is about to happen — and only ever one thing.
+      //
+      // Everything in this universe is charges moving, and almost all of the
+      // time a charge moving is nothing happening: it swaps places with the
+      // space in front of it and the world is as it was. Two alike meeting
+      // head-on and turning each other round is barely more than that —
+      // nothing is lost by it, the pair carry on the other way, and there are
+      // thousands of them a tick all over the field.
+      //
+      // Cancelling is the only event that leaves the world a different size.
+      // It is the whole of what gravity is here, and marking anything else
+      // alongside it buries it in the general bustle.
+      if (field) {
+        // Drawn plainly, NOT added together like the shells above.
+        //
+        // Additive blending is right for a few translucent surfaces and wrong
+        // for a thousand marks: where the fields properly meet there are
+        // hundreds of these on top of one another, and adding a hundred faint
+        // whites gives solid white. The middle of the picture — which is the
+        // part being watched — turns into a lamp. Ordinary alpha means a
+        // hundred stacked marks are no brighter than a few, so a dense region
+        // reads as dense rather than as blown out.
+        const prev = ctx.globalCompositeOperation;
+
+        for (const nd of graph.nodes) {
+          for (const ray of nd) {
+            const a = ray.moving;
+            const b = a?.target;
+            if (!a || !b) continue;
+
+            const other = b.at.node;
+            if (other === nd) continue;
+
+            // Each moving into where the other is — the same test the tick
+            // itself uses, so what is marked is what will actually happen.
+            const met = other.find(x => x.moving?.target?.at.node === nd);
+            if (!met) continue;
+
+            // Found from both ends; drawn from one.
+            if (idxOf.get(nd)! > idxOf.get(other)!) continue;
+
+            // Against what the other one is actually carrying towards us,
+            // which is its own moving boundary — the same pair of polarities
+            // the tick will compare. Only one of each cancels; everything
+            // else meeting head-on turns around, and turning around leaves
+            // the world exactly as big as it was.
+            const facing = met.moving!.polarity;
+
+            const opposed =
+              (a.polarity === Polarity.Positive && facing === Polarity.Negative) ||
+              (a.polarity === Polarity.Negative && facing === Polarity.Positive);
+
+            if (!opposed) continue;
+
+            const p = pts.get(nd), q = pts.get(other);
+            if (!p || !q || p.clipped || q.clipped) continue;
+
+            const x = (p.x + q.x) / 2, y = (p.y + q.y) / 2;
+            if (!onScreen({ x, y })) continue;
+
+            // Sized in pixels with only a little from the zoom. These are
+            // marks ON the picture rather than things in it — scaled to the
+            // lattice they are two or three pixels across on a ball this big,
+            // which is to say invisible, which is to say the one thing the
+            // picture is for isn't in it.
+            // Sized in pixels rather than scaled to the lattice, but only
+            // just: there are a great many of these once the fields properly
+            // meet, and at full brightness they stop being marks on the
+            // picture and become the picture.
+            const r = 3 + cam.scale * 0.012 * p.depth;
+
+            const flash = ctx.createRadialGradient(x, y, 0, x, y, r);
+            flash.addColorStop(0, "rgba(255,240,214,0.28)");
+            flash.addColorStop(0.4, "rgba(255,240,214,0.1)");
+            flash.addColorStop(1, "rgba(255,240,214,0)");
+            ctx.fillStyle = flash;
+            ctx.beginPath();
+            ctx.arc(x, y, r, 0, Math.PI * 2);
+            ctx.fill();
+
+            // A small hard centre, so it still reads as a point where
+            // something is happening rather than as one more soft glow.
+            ctx.fillStyle = "rgba(255,244,224,0.4)";
+            ctx.beginPath();
+            ctx.arc(x, y, 1, 0, Math.PI * 2);
+            ctx.fill();
+          }
+        }
+
+        // And what DID happen — the same events a tick later, at the place
+        // they happened, fading. An annihilation is over inside the tick it
+        // occurs in and takes both of the points it occurred between with it,
+        // so without this the one thing in this universe that changes how
+        // much space there is is the one thing never shown happening.
+        for (const event of graph.events) {
+          if (event.kind !== 'annihilate') continue;
+
+          const age = graph._tickId - event.tick;
+          if (age > 1) continue;
+
+          const pr = place(project(event.at, cam.rot, cam.tilt, cam.dist || 1));
+          if (pr.clipped || !onScreen(pr)) continue;
+
+          const fade = age === 0 ? 0.3 : 0.12;
+          const r = 5 + cam.scale * 0.018 * pr.depth;
+
+          const burst = ctx.createRadialGradient(pr.x, pr.y, 0, pr.x, pr.y, r);
+          burst.addColorStop(0, `rgba(255,236,196,${fade})`);
+          burst.addColorStop(0.35, `rgba(255,236,196,${0.35 * fade})`);
+          burst.addColorStop(1, "rgba(255,236,196,0)");
+          ctx.fillStyle = burst;
+          ctx.beginPath();
+          ctx.arc(pr.x, pr.y, r, 0, Math.PI * 2);
+          ctx.fill();
+        }
+
+        ctx.globalCompositeOperation = prev;
+
+        // What the last tick actually consisted of. "Nothing is happening"
+        // has several quite different causes that look identical on screen,
+        // and these are what tell them apart: emitted 0 means the sources are
+        // walled in, moved 0 with blocked high means everything has jammed,
+        // and annihilated 0 with both of those healthy means the waves are
+        // travelling perfectly well and simply never meeting.
+        const s = graph.stats;
+        const line = `t${graph._tickId}  pts ${graph.nodes.length}  emit ${s.emitted}  move ${s.moved}  block ${s.blocked}  kill ${s.annihilated}  turn ${s.turned}  holes ${s.holes}`;
+
+        ctx.font = "11px ui-monospace, SFMono-Regular, Menlo, monospace";
+        ctx.textBaseline = "top";
+        ctx.fillStyle = "rgba(150,158,180,0.75)";
+        ctx.fillText(line, 10, 8);
+
+        /**
+         * How far apart the two sources are, in steps through the structure,
+         * plotted against time.
+         *
+         * Flat means they are not gravitating, whatever the picture above it
+         * appears to be doing. Every step down is space between them that has
+         * been annihilated and is not there any more. It is the one reading
+         * here that cannot be argued with by looking harder: the layout is a
+         * solve and can be stiff or slow, and the coordinates never move at
+         * all, but a path is a count of points and either there are fewer of
+         * them than there were or there are not.
+         */
+        const history = graph.history;
+
+        // Nothing to measure with one source: there is no "apart".
+        if (history.length > 1 && graph.route.length > 1) {
+          const W = 150, H = 38, X = 10, Y = h - H - 12;
+
+          const top = Math.max(...history, 1);
+          const now = history[history.length - 1];
+
+          ctx.strokeStyle = "rgba(150,158,180,0.22)";
+          ctx.lineWidth = 1;
+          ctx.strokeRect(X, Y, W, H);
+
+          ctx.strokeStyle = "rgba(120,230,180,0.85)";
+          ctx.lineWidth = 1.4;
+          ctx.beginPath();
+
+          for (let i = 0; i < history.length; i++) {
+            const x = X + (i / Math.max(history.length - 1, 1)) * W;
+            const y = Y + H - (Math.max(history[i], 0) / top) * (H - 4) - 2;
+
+            if (i) ctx.lineTo(x, y); else ctx.moveTo(x, y);
+          }
+
+          ctx.stroke();
+
+          ctx.fillStyle = "rgba(150,158,180,0.75)";
+          ctx.fillText(`source to source: ${now} steps (from ${history[0]})`, X, Y - 15);
+        }
+      }
     }
 
     function frame(now) {
@@ -2183,7 +4544,7 @@ const GraphView = ({
       // window.removeEventListener("mousemove", onMouseMove);
       // window.removeEventListener("mouseup", onMouseUp);
     };
-  }, [animate, density]);
+  }, [animate, density, mode]);
 
 
   return <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%" }} />;
@@ -2198,6 +4559,8 @@ const CalculusPlayer = ({
   autoplay = repeated !== false,
   height = 150,
   density = true,
+  mode = 'lattice',
+  interval = 0.45,
 }: CalculusVisualizationProps) => {
   const [running, setRunning] = useState(autoplay);
 
@@ -2223,17 +4586,16 @@ const CalculusPlayer = ({
     stepsRef.current++;
   };
 
-  // Step the polarity dynamics once every TICK_INTERVAL seconds while
-  // running — annihilation / turn-around / structure-absorption.
-  const TICK_INTERVAL = 0.45;
+  // Step the polarity dynamics once every `interval` seconds while running —
+  // annihilation / turn-around / structure-absorption.
   const accum = useRef(0);
 
   const onFrame = (dt: number) => {
     if (!running || !graphRef.current!.nodes.length) return;
 
     accum.current += dt;
-    while (accum.current >= TICK_INTERVAL) {
-      accum.current -= TICK_INTERVAL;
+    while (accum.current >= interval) {
+      accum.current -= interval;
 
       // A repeating pattern spends one interval showing the seed again
       // before stepping on, so the loop point is legible rather than an
@@ -2245,7 +4607,7 @@ const CalculusPlayer = ({
 
   return <div>
     <div style={{ height }}>
-      <GraphView graph={() => graphRef.current!} animate density={density} onFrame={onFrame} />
+      <GraphView graph={() => graphRef.current!} animate density={density} mode={mode} onFrame={onFrame} />
     </div>
     <Row end="xs" className="child-px-2">
       {running
@@ -2278,6 +4640,7 @@ const CalculusFilmstrip = ({
   repeated = false,
   height = 150,
   density = true,
+  mode = 'lattice',
 }: CalculusVisualizationProps) => {
   const cycle = typeof repeated === 'number' ? repeated : DEFAULT_STEPS;
 
@@ -2300,7 +4663,7 @@ const CalculusFilmstrip = ({
           ? <div style={{ flex: '0 0 auto', padding: '0 0.5em', color: '#515254' }}>→</div>
           : null}
         <div style={{ flex: '1 1 120px', height }}>
-          <GraphView graph={() => graph} density={density} />
+          <GraphView graph={() => graph} density={density} mode={mode} />
         </div>
       </Fragment>
     ))}
@@ -2527,6 +4890,174 @@ const alternatingIntoRandom = (size: number, inner: Polarity): LineSide[] => [
   ...randomBlock(size, 'left'),
 ];
 
+/**
+ * Two spinning magnets in a 3D space that has every direction in it, and the
+ * ways they can be set going.
+ *
+ * They are laid out along x with the origin between them, so:
+ *
+ *  - `towards` / `apart` are along the line joining them — the only thing the
+ *    flat two-block version could express at all;
+ *  - `across` is both of them going the same way perpendicular to it, which
+ *    is the two of them travelling together and asks whether whatever holds
+ *    them holds them while they move;
+ *  - `shear` is each going the opposite way across that line, which is the
+ *    setup an orbit is made of: angular momentum about the midpoint, with an
+ *    attraction to bend it into something closed;
+ *  - `corner` sends each along a body diagonal, which no lattice wired only
+ *    to its faces has at all, and which is the case that says whether "every
+ *    direction" is a real claim here or just six of them dressed up;
+ *  - `still` is the control — neither of them going anywhere, so anything
+ *    that moves, moved because of the field.
+ *
+ * Each is run twice: with the two magnets turning together (both emitting the
+ * same thing at the same time) and turning against each other (one always
+ * putting out the opposite of what the other is).
+ *
+ * It is tempting to read that as the difference between annihilating and not
+ * — like shells bouncing, opposite shells cancelling — and it isn't. A magnet
+ * that turns over every tick lays down alternating shells, so directly behind
+ * every shell is one of the opposite charge. Two like shells meeting in the
+ * middle do turn each other round, and what each of them then runs into is
+ * the opposite-charged shell coming along behind it, and THAT cancels. Both
+ * ways round eat the space between the two sources; turning together just
+ * takes one more step about it.
+ */
+const MAGNET_CASES: {
+  name: string, a?: number[], b?: number[],
+  axis?: number[], spin?: boolean, alone?: boolean,
+}[] = [
+  /**
+   * One magnet, on its own, held still — and the answer to whether anything
+   * here loops from one pole round to the other is no, by construction.
+   *
+   * What comes out is two opposed caps: the one charge straight out of the
+   * half facing along the axis, the other straight out of the half facing
+   * back, and nothing at all off the equator. They go out radially and they
+   * keep going. Nothing bends.
+   *
+   * Nothing CAN bend. A ray in this calculus does exactly two things — it
+   * moves the way it is going, or it meets something head-on and turns
+   * completely around. There is no rule anywhere that alters a direction by a
+   * little, so no path here is ever a curve; every path is a straight run
+   * with the occasional reversal in it. A field line that leaves the north
+   * pole, arcs over, and comes back into the south would need a charge to be
+   * continuously deflected by the space it is passing through, and space here
+   * does not act on anything: it is what gets traded places with.
+   *
+   * There is also a reason it shouldn't be expected. Magnetic field lines
+   * close because the field has no sources to start or stop on. This field is
+   * nothing BUT sources — every charge on screen was written onto space by a
+   * magnet and is on its way out of it. So the thing being drawn is much
+   * closer to two opposite charges radiating than to a dipole, and radiating
+   * is what it looks like.
+   *
+   * What DOES happen, and is worth watching for, is at the equator: the two
+   * caps fan sideways as they travel (see the Huygens step), so their edges
+   * eventually reach around into each other's half. Where a positive edge
+   * meets a negative one they cancel. That is not a line curving from pole to
+   * pole. It is the nearest thing these rules have to one: the two halves of
+   * the field closing on each other, around the middle, some way out.
+   */
+  { name: 'one magnet, on its own', axis: [1, 0, 0], spin: false, alone: true },
+
+  // Neither going anywhere: the baseline, in which anything that moves, moved
+  // because of the field.
+  { name: 'still' },
+
+  /**
+   * Angular momentum, both the same way round.
+   *
+   * The sources sit at −sep and +sep along x. Take the one on the left up
+   * (+y) and the one on the right down (−y) and the pair is circulating about
+   * the point between them — clockwise, looking down the z axis at the plane
+   * they are in. Checking the sign rather than trusting it: a rotation about
+   * +z carries a point at −x towards −y, so a point at −x heading towards +y
+   * is going round the other way, which is the clockwise one.
+   *
+   * Both of them the same way round is what makes this angular momentum
+   * rather than two things passing. Opposite ways round would cancel about
+   * the midpoint and be a shear — the two sliding past each other with
+   * nothing going round anything.
+   *
+   * Whether it closes into an orbit is the question, and it is a real one
+   * rather than a foregone conclusion: an orbit needs the pull to bend the
+   * motion by just as much as the motion carries it past, and nothing here
+   * has been arranged to make those two match. The likely outcomes are all
+   * legible — they spiral together, they curve and escape, or the radiation
+   * knocks them off course before either.
+   */
+  // { name: 'both clockwise', a: [0, 1, 0], b: [0, -1, 0] },
+
+  /**
+   * Closing, but not on each other.
+   *
+   * The left one goes up and to the right, the right one down and to the
+   * left. Along x they are approaching; along y they are pulling apart. So
+   * they converge without ever being aimed at one another, and pass at an
+   * offset rather than meeting — which is the one arrangement where a pull
+   * has something to work with.
+   *
+   * Head-on, attraction can only make them arrive sooner; there is nothing
+   * for it to bend. Set going sideways (`both clockwise`), they were already
+   * leaving and it has to catch them. Between the two is this: a fly-by with
+   * an impact parameter, coming in fast enough to pass and close enough to be
+   * turned, which is the case where a pull either bends the path into
+   * something that comes back round or doesn't — and either answer is worth
+   * having.
+   *
+   * The angular momentum is the same sense for both, as above, so what they
+   * carry past each other is a rotation about the midpoint rather than two
+   * things sliding by.
+   *
+   * Both directions are edge steps rather than axis ones, √2 long, which the
+   * clock in `tick` charges accordingly — so these two cover the same ground
+   * per tick as everything else and arrive when they would have arrived.
+   */
+  // { name: 'closing at an angle', a: [1, 1, 0], b: [-1, -1, 0] },
+
+  /**
+   * Two actual magnets, poles along the line between them, not turning.
+   *
+   * Everything above is a source with no sides that flips over every tick:
+   * the same charge in every direction, reversed, again and again. That is
+   * where the waves come from — the alternation IS the wave, and a train of
+   * shells is a record of a thing being turned over.
+   *
+   * A magnet doesn't do that. It has a north and a south and it holds them:
+   * `emits` out of the half facing +x, its opposite out of the half facing
+   * −x, nothing across the equator, tick after tick without reversing. So
+   * there are no shells here at all — no alternation to make a front out of.
+   * What comes off each pole is a steady stream of the one charge, and the
+   * field between the two is not a sequence of arrivals but a standing thing
+   * that is simply there.
+   *
+   * Both get the same axis, which is what faces them at each other properly:
+   * the left one's right-hand side is its north and the right one's left-hand
+   * side is its south. So everything crossing the gap is the opposite of what
+   * it meets, permanently. Between two turning sources the two streams were
+   * alike as often as not, and alike charges bounce; here every meeting in
+   * the gap cancels, and cancelling is the one event that takes space out of
+   * the world.
+   *
+   * Which makes this the arrangement to ask the question of. If a steady
+   * one-sided cancellation right along the line between them does not draw
+   * them together, nothing built out of these rules will, and the answer is
+   * about the rules rather than about the setup.
+   */
+  { name: 'two magnets, poles facing', axis: [1, 0, 0], spin: false },
+];
+
+const MAGNET_SPINS: { name: string, phase: number }[] = [
+  { name: 'turning together', phase: 0 },
+  { name: 'turning against', phase: 1 },
+];
+
+
+const Caption = ({ children }: { children: any }) => (
+  <div style={{ color: '#8a8d99', fontSize: '0.8em', paddingTop: '0.6em' }}>{children}</div>
+);
+
 const RayCalculiAndPhysics = () => {
   const navigate = useNavigate();
 
@@ -2618,6 +5149,47 @@ const RayCalculiAndPhysics = () => {
           />
         ))}
 
+        {/* The same two magnets, in three dimensions, each radiating into all
+            twenty-six directions of the lattice instead of down one corridor,
+            and each set going a different way to begin with. The sources are
+            the yellow points; every charge on screen came out of one of them.
+            What is drawn is the structure rather than the coordinates, so
+            space that has been annihilated out of the world is not a hole in
+            the picture — it is two things that are now nearer each other. */}
+        {MAGNET_CASES.map(({ name, a, b, axis, spin: turning = true, alone }) => (
+          <Fragment key={`magnets-${name}`}>
+            {/* Which way round each is turning only means something if they
+                are turning. Held still, "together" and "against" are the same
+                run twice. */}
+            {(turning ? MAGNET_SPINS : [{ name: 'held', phase: 0 }]).map(spin => (
+              <div key={spin.name} style={{ marginBottom: '1.5rem' }}>
+                <CalculusVisualization
+                  graph={() => Graph.magnets(
+                    { emits: Polarity.Positive, moving: a, axis },
+                    { emits: Polarity.Positive, moving: b, phase: spin.phase, axis },
+                    { spin: turning, alone },
+                  )}
+                  repeated={60}
+                  // Said outright rather than left to follow from `repeated`,
+                  // which is what it defaults to: turn the repeat off to
+                  // watch one run go on indefinitely and the whole thing
+                  // silently stops autoplaying too, which looks exactly like
+                  // a universe in which nothing happens.
+                  autoplay
+                  height={320}
+                  interval={0.2}
+                  mode="field"
+                  // The glow is a sum over every charge, and with a pulse
+                  // going out every tick that is most of the ball — one even
+                  // wash, hiding the shells it is drawn from.
+                  density={false}
+                />
+                <Caption>{name} — {spin.name}</Caption>
+              </div>
+            ))}
+          </Fragment>
+        ))}
+
         {ANTI_GROUPS.map((group, i) => (
           <div key={i} style={{ marginBottom: '1.5rem' }}>
             {group.map((pair, j) => (

From 01a557cae77a0f0e49fe7a95e2cc5d9d92b9a07a Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Thu, 6 Aug 2026 17:29:26 +0200
Subject: [PATCH 09/47] First attempt at 3D

---
 .../archive/2026.RayCalculiAndPhysics.tsx     | 146 ++++++++++++++++--
 1 file changed, 135 insertions(+), 11 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index ab3c17f..ca1139e 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -72,8 +72,44 @@ type MagnetSide = {
    * opposite charges meeting is the one event that destroys space.
    */
   axis?: number[];
+
+  /**
+   * Which way round it turns, if it turns: +1 or −1, and nothing for a magnet
+   * held still.
+   *
+   * `spin` flips a source's poles over on the spot — north becomes south,
+   * south becomes north, and nothing has moved. Turning is the other thing,
+   * and the one a magnet actually does: the axis itself comes round, so north
+   * is somewhere else than it was, and a direction that was looking at the
+   * north pole is looking at the equator a moment later and at the south pole
+   * after that.
+   *
+   * Which means a turning magnet needs no `spin` at all. Standing anywhere
+   * off its axis you are swept by north, then nothing, then south, then
+   * nothing — an alternation that is a consequence of the thing going round
+   * rather than a property stipulated of it. That is where the waves come
+   * from here, and unlike flipping in place it has a handedness: two magnets
+   * can turn the same way or against each other, and what crosses the gap
+   * between them depends on which.
+   */
+  turning?: 1 | -1;
 };
 
+/**
+ * A turn, in a space that has eight directions to a plane.
+ *
+ * These are the in-plane directions in order round the circle, so stepping
+ * along the list by one is a rotation of an eighth of a turn and stepping by
+ * eight is back where it started. It is the whole of what "rotating" can mean
+ * on a lattice: there is no angle between neighbouring directions to subdivide
+ * further, and a magnet whose axis moved by less than this would not have
+ * moved at all.
+ */
+const TURN: number[][] = [
+  [1, 0, 0], [1, 1, 0], [0, 1, 0], [-1, 1, 0],
+  [-1, 0, 0], [-1, -1, 0], [0, -1, 0], [1, -1, 0],
+];
+
 /**
  * How much harder a source is to move than the charges it emits: a multiple
  * of the step's own length, paid out of the same one-per-tick everything else
@@ -2205,6 +2241,25 @@ class Graph {
       every = 1,
       spin = true,
       alone = false,
+
+      /**
+       * Ticks per eighth of a turn, and one is as fast as turning goes.
+       *
+       * Not a tuning choice: an eighth of a turn is the smallest rotation
+       * this space has, because there are eight directions to a plane and
+       * nothing between neighbouring ones to move through. So one step per
+       * tick is a magnet coming round as fast as anything here does anything.
+       * Anything quicker is not a faster rotation but a coarser one — two
+       * steps a tick is the axis jumping a quarter turn and never facing the
+       * directions in between, which is a magnet being teleported round
+       * rather than turned.
+       *
+       * A full revolution is therefore eight ticks, and with a pulse leaving
+       * every tick that is exactly one pulse per direction: the emission
+       * sweeps the plane once per revolution, laying down a spiral rather
+       * than a stack of shells.
+       */
+      turnEvery = 1,
       // Half the moves taken as one of the pieces the direction is made of:
       // enough that a stream genuinely searches the space around it, while
       // the whole diagonal being one option among its pieces keeps the drift
@@ -2241,7 +2296,7 @@ class Graph {
       fanAt = Math.max(Math.floor(sep / 2), 2),
     }: {
       radius?: number, sep?: number, every?: number,
-      spin?: boolean, alone?: boolean, wander?: number,
+      spin?: boolean, alone?: boolean, turnEvery?: number, wander?: number,
       spread?: number, fanAt?: number, range?: number,
     } = {},
   ): Graph {
@@ -2290,6 +2345,7 @@ class Graph {
       ray.phase = side.phase ?? 0;
       ray.mass = MAGNET_MASS;
       ray.axis = side.axis;
+      ray.turning = side.turning;
 
       // An initial direction is named as a lattice step and resolved to the
       // boundary that actually goes that way, so a direction the point hasn't
@@ -2452,6 +2508,16 @@ class Graph {
             // universe several times the size it was seeded at.
             const written = new Set<node>();
 
+            // A magnet that turns is somewhere else by now. Its axis steps
+            // round the plane an eighth of a turn every `turnEvery` ticks,
+            // one way or the other, and everything below reads it as it
+            // stands rather than as it was set.
+            if (ray.turning) {
+              const step = Math.floor(since / turnEvery) * ray.turning + (ray.phase ?? 0);
+
+              ray.axis = TURN[((step % TURN.length) + TURN.length) % TURN.length];
+            }
+
             const emits = ray.emits ?? Polarity.Positive;
             const turned = spin && (pulse + (ray.phase ?? 0)) % 2 === 1;
 
@@ -2735,7 +2801,8 @@ class Graph {
         r.mass = ray.mass;
         r.age = ray.age;
         r.fanned = ray.fanned;
-        r.axis = ray.axis;
+        r.axis = ray.axis?.slice();
+        r.turning = ray.turning;
         r.heading = ray.heading?.slice();
         rays.set(ray, r);
         copy.push(r);
@@ -3280,6 +3347,10 @@ class Ray {
   // for a source with no sides, which puts the same thing out everywhere.
   axis?: number[];
 
+  // Which way the axis comes round, an eighth of a turn at a time, or nothing
+  // for a magnet that is held still. See `TURN`.
+  turning?: number;
+
   // What a step costs this ray, as a multiple of the step's own length. One
   // for everything the rules make; more for a source, which is the only thing
   // here heavy enough to be worth pushing. See `MAGNET_MASS`.
@@ -4925,7 +4996,7 @@ const alternatingIntoRandom = (size: number, inner: Polarity): LineSide[] => [
  */
 const MAGNET_CASES: {
   name: string, a?: number[], b?: number[],
-  axis?: number[], spin?: boolean, alone?: boolean,
+  axis?: number[], spin?: boolean, alone?: boolean, turning?: 1 | -1,
 }[] = [
   /**
    * One magnet, on its own, held still — and the answer to whether anything
@@ -5046,6 +5117,45 @@ const MAGNET_CASES: {
    * about the rules rather than about the setup.
    */
   { name: 'two magnets, poles facing', axis: [1, 0, 0], spin: false },
+
+  /**
+   * One magnet, actually turning.
+   *
+   * Its axis comes round an eighth of a turn at a time, so north sweeps
+   * through every direction in the plane and comes back. It emits the whole
+   * while and nothing about it flips: standing anywhere off the axis you are
+   * passed by north, then the equator, then south, then the equator again,
+   * which is an alternation that happens TO you because the thing is going
+   * round rather than one stipulated of it.
+   *
+   * What that should make is the difference between this and every source
+   * above. A source flipping in place puts out shells — the same in every
+   * direction, one polarity after another, and drawn as a surface a shell is
+   * a sphere. A source turning puts out two lobes that are pointing somewhere
+   * different each time, so what leaves it is a fan sweeping the plane it
+   * turns in, and what is left behind is a spiral of alternating charge
+   * rather than a stack of shells. Flat, because the turn is flat.
+   */
+  { name: 'one magnet, turning', axis: [1, 0, 0], spin: false, alone: true, turning: 1 },
+
+  /**
+   * Two of them, turning opposite ways.
+   *
+   * Same as above with a second magnet across the gap, and it comes round the
+   * other way — so the two are counter-rotating, like a pair of gears rather
+   * than a pair of clocks. Which is the arrangement where what crosses the
+   * gap is not the same twice: the face each presents to the other is
+   * changing, and changing in opposite senses, so the charge arriving from
+   * one is sometimes alike to what it meets and sometimes opposite, on a
+   * cycle set by how fast they turn rather than by anything about the space.
+   *
+   * Both turning the same way is the other half of the experiment and is what
+   * the pairing below draws alongside it — there the two present matching
+   * faces to each other throughout, which is a different thing entirely from
+   * two counter-rotating ones and should not eat the space between them the
+   * same way.
+   */
+  { name: 'two magnets, turning', axis: [1, 0, 0], spin: false, turning: 1 },
 ];
 
 const MAGNET_SPINS: { name: string, phase: number }[] = [
@@ -5156,18 +5266,32 @@ const RayCalculiAndPhysics = () => {
             What is drawn is the structure rather than the coordinates, so
             space that has been annihilated out of the world is not a hole in
             the picture — it is two things that are now nearer each other. */}
-        {MAGNET_CASES.map(({ name, a, b, axis, spin: turning = true, alone }) => (
+        {MAGNET_CASES.map(({ name, a, b, axis, spin: flipping = true, alone, turning }) => (
           <Fragment key={`magnets-${name}`}>
-            {/* Which way round each is turning only means something if they
-                are turning. Held still, "together" and "against" are the same
-                run twice. */}
-            {(turning ? MAGNET_SPINS : [{ name: 'held', phase: 0 }]).map(spin => (
+            {/* What the pair of runs is contrasting depends on what the
+                sources are doing. Flipping in place, it is whether they flip
+                in step; turning, it is whether they turn the same way or
+                against each other, which is the only sense in which a thing
+                going round has a hand. Doing neither, there is nothing to
+                contrast and it is one run. */}
+            {((turning
+              ? [{ name: 'turning the same way', phase: 0, sense: 1 },
+                 { name: 'turning opposite ways', phase: 0, sense: -1 }]
+              : flipping
+                ? MAGNET_SPINS.map(s => ({ ...s, sense: 1 }))
+                : [{ name: 'held', phase: 0, sense: 1 }]
+            ) as { name: string, phase: number, sense: 1 | -1 }[]).map(spin => (
               <div key={spin.name} style={{ marginBottom: '1.5rem' }}>
                 <CalculusVisualization
                   graph={() => Graph.magnets(
-                    { emits: Polarity.Positive, moving: a, axis },
-                    { emits: Polarity.Positive, moving: b, phase: spin.phase, axis },
-                    { spin: turning, alone },
+                    { emits: Polarity.Positive, moving: a, axis, turning },
+                    {
+                      emits: Polarity.Positive, moving: b, phase: spin.phase, axis,
+                      // The second one comes round the other way when they
+                      // are set against each other.
+                      turning: turning ? (turning * spin.sense) as 1 | -1 : undefined,
+                    },
+                    { spin: flipping, alone },
                   )}
                   repeated={60}
                   // Said outright rather than left to follow from `repeated`,

From 6f2e6be77adae76b457752be7bdcefd259e59487 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Thu, 6 Aug 2026 19:32:00 +0200
Subject: [PATCH 10/47] Playing with rendering options, spinnning magnet

---
 .../archive/2026.RayCalculiAndPhysics.tsx     | 1355 +++++++++++++++--
 1 file changed, 1189 insertions(+), 166 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index ca1139e..2052372 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -93,6 +93,12 @@ type MagnetSide = {
    * between them depends on which.
    */
   turning?: 1 | -1;
+
+  // The plane it turns in, as the two directions it turns between. Anything
+  // in three dimensions, not only the one the code happens to be written
+  // around — two magnets can be set turning in different planes, which is a
+  // thing only a 3D world can be asked.
+  plane?: [number[], number[]];
 };
 
 /**
@@ -105,10 +111,49 @@ type MagnetSide = {
  * further, and a magnet whose axis moved by less than this would not have
  * moved at all.
  */
-const TURN: number[][] = [
-  [1, 0, 0], [1, 1, 0], [0, 1, 0], [-1, 1, 0],
-  [-1, 0, 0], [-1, -1, 0], [0, -1, 0], [1, -1, 0],
-];
+/**
+ * The eight of them, in whatever plane is asked for.
+ *
+ * A turn is only ever a turn in a plane, and a plane is two directions to
+ * turn between. Given those, this walks the circle they span in eighths and
+ * rounds each step onto the nearest direction the lattice actually has — so a
+ * magnet can come round in the xy-plane, or the xz, or about any diagonal,
+ * and the axis it sweeps is the axis it was given rather than the one the
+ * code was written with.
+ *
+ * The default is x towards y, which is the plane the two sources are laid out
+ * in, so a pair of them turn in the plane they face each other across.
+ */
+function turnRing(u: number[] = [1, 0, 0], v: number[] = [0, 1, 0]): number[][] {
+  const out: number[][] = [];
+
+  for (let k = 0; k < 8; k++) {
+    const a = (k / 8) * Math.PI * 2;
+    const c = Math.cos(a), s = Math.sin(a);
+
+    const dir = u.map((x, i) => x * c + (v[i] ?? 0) * s);
+    const step = latticeStep(dir.map(x => (Math.abs(x) < 0.3827 ? 0 : x)));
+
+    if (step) out.push(step);
+  }
+
+  return out;
+}
+
+const TURN = turnRing();
+
+/**
+ * How many ticks a source takes to come back to what it was doing.
+ *
+ * The same for every kind of source, which is the whole point of it. A
+ * rotation through the eight directions of a plane and a flip held half the
+ * time each way are both one cycle, and both lay their structure down at the
+ * same spacing: a wave advances a cell a tick, so a cycle of this many ticks
+ * puts the same charge every this many cells — bands half that wide with the
+ * same again between them, whether those bands come out as rings or as
+ * spirals.
+ */
+const CYCLE = TURN.length;
 
 /**
  * How much harder a source is to move than the charges it emits: a multiple
@@ -1397,7 +1442,17 @@ class Graph {
      * already given up, and half the interactions in the tick are worked out
      * against a world nobody is in any more.
      */
-    for (const r of rays) if (r.moving && !r.magnet) r.age = (r.age ?? 0) + 1;
+    /*
+     * Age is counted in the movement phase below, in steps actually taken
+     * rather than in ticks lived through.
+     *
+     * It is read as a distance everywhere it is used — how far out a charge
+     * has got, for fanning and for the range at which it gives up being one —
+     * and for anything moving at a cell a tick the two are the same number.
+     * For anything slower they are not: a charge held to a cell every third
+     * tick ages three times as fast as it travels, so it expires a third of
+     * the way out and the field never reaches the edge of the world.
+     */
 
     if (this.wander > 0) {
       for (const r of rays) {
@@ -1500,6 +1555,11 @@ class Graph {
       for (const other of ahead) {
         if (met.has(other)) continue;
 
+        // Not against itself: two charges of the same source are two parts of
+        // one field, and a field arriving where it already is is not an
+        // event. See the arriving-together case below.
+        if (r.source !== undefined && r.source === other.source) continue;
+
         const bd = headed.get(other);
         if (!bd || bd.target?.at.node !== r.node) continue;
 
@@ -1566,6 +1626,30 @@ class Graph {
 
       const b = headed.get(other)!;
 
+      /**
+       * A field does not interact with itself.
+       *
+       * Two charges thrown out by the same source are two parts of one thing
+       * it is doing, and one part of a field arriving where another part of
+       * the same field already is has never been an event. Left to interact,
+       * they are a disaster: a source that turns puts consecutive shells out
+       * at an eighth of a turn from each other, so where one shell's north
+       * lobe overtakes the next one's south they are opposite, and they
+       * cancel — the field eats itself as fast as it is made. What survives
+       * blocks, stalls, and is overtaken, and the shells lose their order.
+       * Measured: waves emitted fourteen, twelve, nine and eight pulses ago
+       * all sitting at the same radius, each pointing a different way, their
+       * lobes averaging out to nothing in particular.
+       *
+       * Each shell is a clean two-lobed thing on its own — that much is
+       * emitted correctly and always was. It is only in being allowed to
+       * annihilate against its own neighbours that the order is lost.
+       *
+       * Charges from DIFFERENT sources still meet in the ordinary way, which
+       * is the whole of what two magnets do to each other.
+       */
+      if (r.source !== undefined && r.source === other.source) continue;
+
       const opposed =
         (a.polarity === Polarity.Positive && b.polarity === Polarity.Negative) ||
         (a.polarity === Polarity.Negative && b.polarity === Polarity.Positive);
@@ -1697,30 +1781,26 @@ class Graph {
     const blocked = new Set<Ray>();
 
     /**
-     * A step is a step, whichever way it goes.
-     *
-     * The alternative is to charge a step its own length — a face costs 1, an
-     * edge √2, a corner √3 — which makes every direction advance the same
-     * distance per tick and the front of a pulse perfectly round. It is the
-     * tidier physics and it was what this did.
+     * One step, one tick, whichever way it goes.
      *
-     * But it makes the diagonals worse than useless. A corner connection
-     * exists precisely so that a point can get somewhere without going round
-     * two sides of a square, and charging it for the shortcut takes the
-     * shortcut away again: √3 of distance for √3 of time is the same speed as
-     * the long way round, so nothing is ever reached sooner by going
-     * diagonally and the twenty-six directions collapse back into six with
-     * extra steps.
+     * Everything moves away every tick, and that is the whole of it: a cell
+     * emptied this tick is available the next, so a source is never waiting
+     * on its own last pulse and every shell leaves complete.
      *
-     * A step per tick regardless makes a diagonal a genuine shortcut, which
-     * is what gives a ray somewhere to get to faster than the lattice would
-     * otherwise allow. The price is that a pulse's front is a cube rather
-     * than a sphere — corners running out at 1.73 times the speed of faces —
-     * which is the true shape of "one move a tick" in this space and no
-     * longer worth hiding.
+     * The alternative is to charge a step its own length — √2 through an
+     * edge, √3 through a corner — so that every direction covers the same
+     * DISTANCE per tick and a shell stays a round shell. It is the tidier
+     * geometry and it costs too much: the corner directions then take nearly
+     * two ticks a step, the cells they occupy are still occupied when the
+     * next pulse is due, and what leaves is fourteen of the twenty-six
+     * directions with holes in the same places every time.
      *
-     * Every direction in a lattice wired only to its faces costs 1 either
-     * way, so none of the earlier examples can tell the difference.
+     * A step per tick makes the front a cube rather than a sphere — the
+     * corners of it run out at 1.73 times the speed of the faces — and that
+     * is simply the true shape of "one move a tick" in a space with
+     * twenty-six directions. It is a coherent front either way: shell k is
+     * the points k steps out, all of them, and no shell ever overtakes
+     * another.
      */
     const cost = new Map<Ray, number>();
 
@@ -1799,7 +1879,12 @@ class Graph {
 
     // Paid on going, not on being ready to: something held up in traffic
     // keeps what it has saved and leaves the moment the way is clear.
-    for (const r of going) r.credit = (r.credit ?? 0) - (cost.get(r) ?? 1);
+    for (const r of going) {
+      r.credit = (r.credit ?? 0) - (cost.get(r) ?? 1);
+
+      // One cell older, because it is one cell further on.
+      if (!r.magnet) r.age = (r.age ?? 0) + 1;
+    }
 
     this.stats.moved = going.length;
     this.stats.blocked = movers.length - going.length;
@@ -2346,6 +2431,7 @@ class Graph {
       ray.mass = MAGNET_MASS;
       ray.axis = side.axis;
       ray.turning = side.turning;
+      if (side.plane) ray.ring = turnRing(side.plane[0], side.plane[1]);
 
       // An initial direction is named as a lattice step and resolved to the
       // boundary that actually goes that way, so a direction the point hasn't
@@ -2513,13 +2599,43 @@ class Graph {
             // one way or the other, and everything below reads it as it
             // stands rather than as it was set.
             if (ray.turning) {
+              const ring = ray.ring ?? TURN;
               const step = Math.floor(since / turnEvery) * ray.turning + (ray.phase ?? 0);
 
-              ray.axis = TURN[((step % TURN.length) + TURN.length) % TURN.length];
+              ray.axis = ring[((step % ring.length) + ring.length) % ring.length];
             }
 
             const emits = ray.emits ?? Polarity.Positive;
-            const turned = spin && (pulse + (ray.phase ?? 0)) % 2 === 1;
+
+            /**
+             * One turn of a source takes a turn's worth of ticks, whatever
+             * kind of turning it does.
+             *
+             * A source that rotates comes round through the eight directions
+             * of its plane, one a tick, and is back where it started after
+             * eight. A source that only flips over has two states rather than
+             * eight — and flipping between them every tick made its cycle
+             * four times shorter than the other's, which is not a difference
+             * in kind between the two sources but an accident of counting.
+             *
+             * What it cost was space. Each ring a wave lays down is one
+             * tick's emission, and a wave advances a cell a tick, so a cycle
+             * of two ticks puts the same charge every other cell: bands one
+             * cell wide with one cell between them, which no drawing can
+             * separate and which average to nothing the moment they are
+             * smoothed. Held for half a cycle each way, the same source lays
+             * down bands four cells wide with four cells between them, and
+             * they are bands you can see.
+             *
+             * The two then differ only in what the state is FOR. A flip is
+             * the same everywhere at once, so what it writes is rings. A
+             * rotation points somewhere, so what it writes is spirals. Same
+             * clock, same wave, same spacing — the difference is whether the
+             * source's state has a direction in it.
+             */
+            const beat = ray.turning ? TURN.length : CYCLE;
+            const turn = pulse + (ray.phase ?? 0) * (beat / 2);
+            const turned = spin && ((turn % beat) + beat) % beat >= beat / 2;
 
             const polarity = !turned ? emits
               : emits === Polarity.Positive ? Polarity.Negative : Polarity.Positive;
@@ -2561,24 +2677,109 @@ class Graph {
               // what makes it a magnet and not a lamp.
               let out = polarity;
 
+              // How nearly this direction lies along the magnet's axis: +1
+              // straight out of the north pole, −1 out of the south, 0 on the
+              // equator between them.
+              const cos = ray.axis
+                ? dir.reduce((sum, v, i) => sum + v * (ray.axis![i] ?? 0), 0)
+                  / (Math.hypot(...ray.axis) || 1)
+                : 0;
+
               if (ray.axis) {
-                const along = dir.reduce((sum, v, i) => sum + v * (ray.axis![i] ?? 0), 0);
-                if (Math.abs(along) < 1e-9) continue;
+                if (Math.abs(cos) < 1e-9) continue; // the equator emits nothing
 
-                if (along < 0) out = polarity === Polarity.Positive
+                if (cos < 0) out = polarity === Polarity.Positive
                   ? Polarity.Negative
                   : Polarity.Positive;
               }
 
+              /**
+               * A magnet that turns radiates into the plane it turns in.
+               *
+               * Its poles are in that plane and sweeping round it, so a
+               * direction lying in the plane is swept by north, then the
+               * equator, then south — the full stroke, once per revolution.
+               * A direction along the axis it turns ABOUT is perpendicular to
+               * the poles at every moment of the turn: it sits on the dipole's
+               * equator permanently, and the equator is exactly what emits
+               * nothing. In between, the further out of the plane you are,
+               * the less of the stroke reaches you.
+               *
+               * So the emission is thrown outward rather than all around, and
+               * a revolution lays down a disk. Which is not something added
+               * to make the picture flat — the poles being in the plane is
+               * what makes it flat, and the version without this was drawing
+               * a sphere for a source that has no business making one.
+               */
+              /**
+               * A turning magnet emits along its poles, not out of half of
+               * itself.
+               *
+               * Held still, a pole is a hemisphere: everything on the north
+               * side gets north's charge, and it does not matter that the
+               * side is a hundred and eighty degrees wide, because the thing
+               * is not going anywhere and every direction in that half is
+               * being given the same answer forever.
+               *
+               * Turning, the width is the whole problem. A hemisphere pointed
+               * one way overlaps almost entirely with a hemisphere pointed an
+               * eighth of a turn later, so consecutive pulses land on top of
+               * one another and what winds out from the source is not a
+               * pattern but a wash. Measured: the distance from the source
+               * tracks how long ago a pulse left, cleanly — but the direction
+               * of it does not track where the magnet was pointing at all,
+               * because a lobe spanning half the sky has no direction to
+               * speak of.
+               *
+               * Narrowed to the poles themselves, each pulse goes one way,
+               * the next goes an eighth of a turn round from it, and the
+               * locus of them is an arm winding outward. Which is what a
+               * lighthouse is, and a pulsar, and why the beam has to be a
+               * beam for there to be a sweep at all.
+               */
+              /*
+               * Every direction, here as everywhere else.
+               *
+               * There was a cone here, narrowing a turning magnet's emission
+               * to a beam near its poles, on the reasoning that a lighthouse
+               * needs a beam to have a sweep. It does — but this is not a
+               * lighthouse, and the sweep does not have to be made of where
+               * the pulse went.
+               *
+               * A pulse goes everywhere, as it does for every other source in
+               * this article. What rotates is WHICH WAY ROUND it goes: the
+               * half of the sky facing the north pole gets one charge and the
+               * half facing south gets the other, and the line between those
+               * halves comes round an eighth of a turn every tick. So the
+               * charge a given direction receives alternates as the poles
+               * sweep past it, and the boundary between the two — traced
+               * outward through everything already in flight, each shell
+               * having been laid down with the magnet pointing somewhere
+               * slightly different — is a spiral. Not a spiral anything
+               * travels along. A spiral in the arrangement of what was
+               * emitted, which is what a rotating dipole actually makes.
+               */
+
               for (const r of there)
                 for (const x of r.boundaries) x.polarity = out;
 
               facing.at.moving = g.along(facing.at, dir, 1);
 
+// Nothing travels slower than anything else: a charge is a
+              // charge, and it leaves at one step a tick like everything
+              // here does.
+              
+
               // Which emission this is: one pulse per source per turn of it,
               // which is what makes a pulse a thing with a surface.
               facing.at.wave = pulse * sides.length + (ray.source ?? 0);
 
+              // And whose it is, which for a turning source is what says
+              // which arm a charge is on — see the spiral pass in the
+              // renderer.
+              facing.at.source = ray.source;
+              facing.at.turning = ray.turning;
+
               g.stats.emitted++;
             }
           }
@@ -2666,6 +2867,20 @@ class Graph {
 
             facing.at.moving = g.along(facing.at, bias, 1);
             facing.at.wave = wave; // still the same pulse, spread wider
+            facing.at.source = ray.source;
+            facing.at.turning = ray.turning;
+            facing.at.age = ray.age;
+
+            // And it travels at the speed its parent does.
+            //
+            // Without this a fanned charge is quick and the charge it came
+            // from is slow — three times as quick, where the source is one
+            // that turns — so it runs out through the shell ahead of it and
+            // the one ahead of that, carrying its own polarity into the
+            // middle of theirs. Every shell ends up holding both charges at
+            // once, mixed, and the neat alternation that IS the spiral is
+            // stirred out of the field before anything gets to draw it.
+            facing.at.mass = ray.mass;
 
             // Already fanned, as far as it is concerned. Otherwise each child
             // fans in turn and the shell doubles every tick until it has
@@ -2803,6 +3018,7 @@ class Graph {
         r.fanned = ray.fanned;
         r.axis = ray.axis?.slice();
         r.turning = ray.turning;
+        r.ring = ray.ring;
         r.heading = ray.heading?.slice();
         rays.set(ray, r);
         copy.push(r);
@@ -3348,8 +3564,10 @@ class Ray {
   axis?: number[];
 
   // Which way the axis comes round, an eighth of a turn at a time, or nothing
-  // for a magnet that is held still. See `TURN`.
+  // for a magnet that is held still, and the ring of directions it comes
+  // round through. See `turnRing`.
   turning?: number;
+  ring?: number[][];
 
   // What a step costs this ray, as a multiple of the step's own length. One
   // for everything the rules make; more for a source, which is the only thing
@@ -3494,7 +3712,7 @@ const DEFAULT_STEPS = 8;
  * flight. The lattice bending is then something you can see, because there is
  * a lattice to see rather than a fill.
  */
-type RenderMode = 'lattice' | 'field';
+type RenderMode = 'lattice' | 'shells' | 'field';
 
 export interface CalculusVisualizationProps {
   // The universe to run. A factory, not an instance: it is called again on
@@ -3571,6 +3789,11 @@ const GraphView = ({
     let raf: number;
     let last = performance.now();
 
+    // The field as drawn, which lags the field as computed and catches up a
+    // fraction every frame. Kept across frames because that lag is the whole
+    // of what makes the animation flow rather than step.
+    let eased: Float32Array | null = null;
+
     function resize() {
       const parent = canvas.parentElement;
       const w = parent.clientWidth, h = parent.clientHeight;
@@ -3672,7 +3895,34 @@ const GraphView = ({
     function draw() {
       const cam = camRef.current;
       const graph = latest.current.current();
-      const field = mode === 'field';
+      // The outline enclosing a set of points. Andrew's monotone chain:
+      // sort, then walk once along the bottom and once back along the top,
+      // dropping any point the walk turns the wrong way at.
+      const outline = (at: { x: number, y: number }[]) => {
+        const p = at.slice().sort((a, b) => a.x - b.x || a.y - b.y);
+        const turn = (o: typeof p[0], a: typeof p[0], b: typeof p[0]) =>
+          (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+
+        const half = (source: typeof p) => {
+          const out: typeof p = [];
+
+          for (const q of source) {
+            while (out.length >= 2 && turn(out[out.length - 2], out[out.length - 1], q) <= 0) out.pop();
+            out.push(q);
+          }
+
+          out.pop();
+
+          return out;
+        };
+
+        return half(p).concat(half(p.slice().reverse()));
+      };
+
+      // Both of the two field renderings want the lattice, the sources and
+      // the marks; they differ in what they make of the charges.
+      const field = mode !== 'lattice';
+      const contours = mode === 'field';
 
       const w = canvas.clientWidth, h = canvas.clientHeight;
 
@@ -3872,7 +4122,7 @@ const GraphView = ({
       // Faint enough to be the paper rather than the drawing: what the
       // lattice is here for is to be bent, and reading a bend needs only
       // enough of a grid to see it against.
-      ctx.strokeStyle = field ? "rgba(124,136,176,0.08)" : "rgba(140,150,180,0.3)";
+      ctx.strokeStyle = field ? "rgba(124,136,176,0.05)" : "rgba(140,150,180,0.3)";
       ctx.lineWidth = field ? 1 : 2.2;
       const idxOf = new Map<node, number>();
       graph.nodes.forEach((nd, i) => idxOf.set(nd, i));
@@ -4069,161 +4319,75 @@ const GraphView = ({
       }
 
       /**
-       * Wavefronts, drawn as what they actually are.
-       *
-       * A pulse is hundreds of charges and drawing them one at a time is a
-       * snowstorm — least of all can you tell where one pulse ends and the
-       * next begins, which is the thing worth seeing when two sources are
-       * turning over and putting out alternating shells. So each is drawn as
-       * one translucent surface, coloured by the charge it carries.
+       * One surface per pulse: the shells as they were drawn before.
        *
-       * Not as a sphere, though. A sphere is a claim about the space it is
-       * drawn in — that a pulse is the same distance out in every direction,
-       * from a centre — and it is exactly the claim this picture exists to
-       * deny. Space here is warped by what has been destroyed in it: the
-       * layout is solved against the connections rather than laid out on a
-       * grid, so a shell that left its source evenly is drawn dented wherever
-       * the space it is crossing has been eaten. Fitting a circle to that
-       * puts a ring somewhere near the points and centred on nothing in
-       * particular — which is why the rings did not appear to come out of
-       * their source.
+       * Each emission is taken on its own and given the outline that encloses
+       * it — split by charge as well as by pulse, because a source with poles
+       * throws opposite charges out of its two halves in the same breath and
+       * collecting them together loses the fact that it has sides at all.
        *
-       * So the surface is taken from the points themselves: the outline that
-       * encloses them as they are actually drawn. It has no centre and no
-       * radius and assumes no shape. It surrounds its pulse — dented where
-       * the pulse is dented, and starting at the source because that is where
-       * the pulse starts.
+       * Not drawn as circles: the outline is taken from where the charges
+       * actually are, so a shell crossing space that has been eaten comes out
+       * dented, which is the thing worth seeing in the examples where the two
+       * magnets are pulling on each other.
        */
-      if (field) {
-        /**
-         * Grouped by pulse AND by charge, not by pulse alone.
-         *
-         * A source with poles puts opposite charges out of its two halves in
-         * the same breath, so one pulse is two things: positive over here and
-         * negative over there. Collected under the pulse alone they are one
-         * set of points, drawn as one outline, in whichever of the two
-         * charges happened to be looked at first — a magnet drawn as a plain
-         * ring of one polarity, with the entire fact that it has sides thrown
-         * away in the grouping.
-         *
-         * Split by charge as well and each half gets its own surface in its
-         * own colour: two lobes leaving together, one warm and one cold, with
-         * the equator between them that emits nothing.
-         */
+      if (field && !contours) {
         const waves = new Map<string, {
-          id: number, at: { x: number, y: number }[], depth: number, polarity: Polarity,
+          at: { x: number, y: number }[], depth: number, out: number, polarity: Polarity,
         }>();
 
         for (const nd of graph.nodes) {
-          // A pulse that has left the space we set up has left the picture
-          // with it. Drawn anyway, every shell ever emitted is still on
-          // screen as an ever-larger outline, and the thing being watched is
-          // behind forty of them.
           if (!graph.inFocus(nd)) continue;
 
           for (const ray of nd) {
             if (ray.magnet || !ray.moving || ray.wave === undefined) continue;
+            if (ray.moving.polarity === Polarity.Neutral) continue;
 
             const p = pts.get(nd);
             if (!p || p.clipped) continue;
 
-            const polarity = ray.moving.polarity;
-            const key = `${ray.wave}|${polarity}`;
+            const key = `${ray.wave}|${ray.moving.polarity}`;
 
             let wave = waves.get(key);
-            if (!wave) waves.set(key, wave = { id: ray.wave, at: [], depth: 0, polarity });
+            if (!wave) waves.set(key, wave = {
+              at: [], depth: 0, out: 0, polarity: ray.moving.polarity,
+            });
 
             wave.at.push({ x: p.x, y: p.y });
             wave.depth += p.depth;
-            break; // one point per point, however many rays are sitting on it
-          }
-        }
 
-        // Pulses go out in order, so the largest id is the newest, and a
-        // handful before it are the ones still in flight. Anything older than
-        // that is a straggler — a few charges that jammed against each other
-        // long ago and have been sitting there since, still carrying the id
-        // of the pulse they set out with. Drawn, they are a shell that never
-        // leaves.
-        let newest = -Infinity;
-        for (const wave of waves.values()) if (wave.id > newest) newest = wave.id;
+            const wp = layout.get(nd);
+            if (wp) wave.out += Math.hypot(...wp) / ((graph.focus ?? 12) * LATTICE_STEP);
 
-        /**
-         * How far back to keep drawing, and it is a question about reading
-         * rather than about honesty.
-         *
-         * Every pulse still in flight is really there, and drawing all of
-         * them puts a dozen nested outlines around each source with a dozen
-         * more from the other laid over the top. Nothing in that is wrong and
-         * none of it can be followed.
-         *
-         * What has to survive the trim is that the pulses ALTERNATE, and that
-         * takes about as many of them as it takes to see warm, cold, warm —
-         * half a dozen, fading out with age so the sequence reads as a train
-         * going outwards rather than as a set of rings that happen to be
-         * nested. The older ones are still in the world doing their work; the
-         * picture just stops insisting on them.
-         */
-        const LIVE = 12; // ids — six ticks' worth, across two sources
-
-        // The outline enclosing a set of points, as drawn. Andrew's monotone
-        // chain: sort, then walk once along the bottom and once back along
-        // the top, dropping any point the walk turns the wrong way at.
-        const outline = (at: { x: number, y: number }[]) => {
-          const p = at.slice().sort((a, b) => a.x - b.x || a.y - b.y);
-          const turn = (o: typeof p[0], a: typeof p[0], b: typeof p[0]) =>
-            (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
-
-          const half = (source: typeof p) => {
-            const out: typeof p = [];
-
-            for (const q of source) {
-              while (out.length >= 2 && turn(out[out.length - 2], out[out.length - 1], q) <= 0) out.pop();
-              out.push(q);
-            }
-
-            out.pop();
-
-            return out;
-          };
-
-          return half(p).concat(half(p.slice().reverse()));
-        };
+            break;
+          }
+        }
 
         const shells = [...waves.values()]
-          .filter(wave => wave.id >= newest - LIVE && wave.at.length >= 3)
+          .filter(wave => wave.at.length >= 3)
           .map(wave => ({
             hull: outline(wave.at),
             depth: wave.depth / wave.at.length,
+            out: Math.min(wave.out / wave.at.length, 1),
             polarity: wave.polarity,
-            // 0 for the pulse just emitted, 1 for the oldest still drawn.
-            age: Math.min((newest - wave.id) / LIVE, 1),
           }))
           .filter(shell => shell.hull.length >= 3)
-          // Far ones first, so a near shell reads as being in front of one
-          // behind it rather than the two just adding up.
+          // Far ones first, so a near shell reads as in front of one behind
+          // it rather than the two adding up.
           .sort((a, b) => b.depth - a.depth);
 
         const prev = ctx.globalCompositeOperation;
         ctx.globalCompositeOperation = "lighter";
 
         for (const shell of shells) {
-          const tint = shell.polarity === Polarity.Positive ? "255,122,69"
-            : shell.polarity === Polarity.Negative ? "61,220,255"
-              : "150,157,178";
-
-          // Drawn as a smooth closed curve rather than as the corners it was
-          // computed from. A surface through a few dozen points is a surface;
-          // the straight lines between them are an artefact of there being
-          // finitely many, and drawing those says the shell has flat facets
-          // and sharp edges, which is a claim about it that nothing supports.
-          //
-          // Catmull-Rom: each span is bent by where the points on either side
-          // of it are, so the curve passes through every point and leaves it
-          // heading towards the next one.
+          const tint = shell.polarity === Polarity.Positive ? "255,122,69" : "61,220,255";
           const h = shell.hull;
           const at = (i: number) => h[(i % h.length + h.length) % h.length];
 
+          // A smooth closed curve rather than the corners it was computed
+          // from: the straight lines between them are an artefact of there
+          // being finitely many charges, and drawing those claims the shell
+          // has facets and edges, which nothing supports.
           ctx.beginPath();
           ctx.moveTo(h[0].x, h[0].y);
 
@@ -4239,24 +4403,765 @@ const GraphView = ({
 
           ctx.closePath();
 
-          // Newest brightest, oldest nearly gone — which is what makes half a
-          // dozen outlines read as one train going outwards instead of as a
-          // stack of rings all insisting equally.
-          const fade = 1 - shell.age * 0.85;
+          // Bright where it was emitted, faint by the time it is far out — a
+          // wave spreading the same charge over a larger and larger surface.
+          const lift = Math.max(1 - shell.out, 0);
+          const fade = 0.1 + lift * lift * 0.9;
 
-          // Barely there through the middle, so shells behind and the lattice
-          // through them stay visible, with the surface itself on the edge.
-          ctx.fillStyle = `rgba(${tint},${0.025 * fade})`;
+          ctx.fillStyle = `rgba(${tint},${0.06 * fade})`;
           ctx.fill();
 
-          ctx.strokeStyle = `rgba(${tint},${0.42 * fade})`;
-          ctx.lineWidth = 1.1;
+          ctx.strokeStyle = `rgba(${tint},${0.55 * fade})`;
+          ctx.lineWidth = 1.2;
           ctx.stroke();
         }
 
         ctx.globalCompositeOperation = prev;
       }
 
+      /**
+       * ONE of two ways of drawing the same charges, and they answer
+       * different questions.
+       *
+       * `shells` draws each pulse: one surface per emission, so what you see
+       * is the source letting go of shell after shell and each of them
+       * travelling. It is the honest picture of a thing that emits, and for a
+       * source that only flips over it is the whole story, since every shell
+       * is the same in every direction and there is nothing else to say about
+       * one.
+       *
+       * `field` draws what the pulses add up to: the region where the field
+       * is one charge and the region where it is the other, with the boundary
+       * between them. For a source that TURNS, that is the only way to see
+       * what it is doing — a turning source lays down a spiral, and a spiral
+       * is a property of a whole train of shells and of none of them
+       * separately. Drawn shell by shell it is a stack of lobes, and the
+       * winding they make is nowhere in the picture.
+       *
+       * Two surfaces. Not two hundred.
+       *
+       * A charge at distance r in direction θ left r cells ago, when the
+       * magnet's north pole pointed at α − ωr rather than at α. So its sign
+       * depends on θ − ωr: the positive charges are one Archimedean spiral
+       * winding out from the source, and the negative ones fill exactly the
+       * gaps between its turns. One body each, connected from the middle to
+       * the edge, and neither is ever where the other is.
+       *
+       * Drawing per pulse guarantees the one thing that must not happen. A
+       * pulse is a ring, so a picture made of pulses is a stack of rings
+       * lying across one another — when what is actually there is two
+       * interleaved spirals that never cross at all.
+       *
+       * So the outline is still an outline, drawn exactly as the shells were:
+       * a smooth closed curve, barely filled, its own colour at the edge,
+       * fading with distance. What changed is what it goes round. Instead of
+       * enclosing the charges of one pulse, it follows the edge of the region
+       * where the field has that sign — which is found by reconstructing the
+       * field from the charges and walking the line along which it crosses.
+       * The result is one curve per body rather than one per pulse, it is
+       * shaped like the body (so it winds, because the body winds), and two
+       * of them can no more overlap than a place can be both positive and
+       * negative.
+       */
+      if (contours) {
+        const CELL = 4;                                 // pixels per sample
+        const cols = Math.max(Math.ceil(w / CELL), 1);
+        const rows = Math.max(Math.ceil(h / CELL), 1);
+
+        const sum = new Float32Array(cols * rows);
+        const weight = new Float32Array(cols * rows);
+        const near = new Float32Array(cols * rows);
+        const cut = new Float32Array(cols * rows);
+
+        /**
+         * How far one charge speaks for, and it is bounded on both sides.
+         *
+         * Too small and the charges never meet: the region comes apart into
+         * one little ring per charge, which is the picture of points that
+         * keeps coming back. Too large and a band bleeds into the next band
+         * round, the alternation averages itself away, and there is one grey
+         * body instead of two winding ones.
+         *
+         * The right size is set by the winding itself. A source turning an
+         * eighth of a turn a tick, whose wave advances a cell every third
+         * tick, comes right round every two and two thirds cells — so bands
+         * of one sign lie that far apart, and a charge should speak for about
+         * half of that. Then a band closes up along its own length and still
+         * stops dead against its neighbour.
+         */
+        const step = cam.scale * LATTICE_STEP;          // pixels per cell
+
+        /**
+         * And it reaches further ALONG a band than across to the next one.
+         *
+         * A round reach has to be a compromise between two things that want
+         * opposite sizes. The holes to be closed are the gaps between charges
+         * of one shell, which open up as the shell grows and are the reason
+         * the bands come out as strings of islands; closing them wants a
+         * generous reach. What must not be closed is the gap between one turn
+         * of the spiral and the next, which is where the alternation lives;
+         * keeping that wants a mean one. Round, there is no size that does
+         * both, and the picture is either beads or porridge.
+         *
+         * But the two gaps are not in the same direction. A band runs the way
+         * a shell runs — around the source — and the next band along is
+         * further out from it. So the reach is made an ellipse: long the way
+         * round, short the way out. Charges of one shell run together along
+         * their own arc, and the arc still stops dead against the arc beyond
+         * it. Nothing is invented by this — it is a statement about which
+         * neighbours a charge has, and a charge on a shell has its neighbours
+         * beside it rather than in front.
+         */
+        const along = Math.max((step * 3.4) / CELL, 4);   // the way round
+        const across = Math.max((step * 0.6) / CELL, 1.2); // the way out
+        const span = Math.ceil(along);
+
+        // Where each source is on the screen, which is what "out from it"
+        // means. Anything with no source of its own is measured from the
+        // middle of the picture.
+        const origin = new Map<number, { x: number, y: number }>();
+        for (const nd of graph.nodes) {
+          for (const ray of nd) {
+            if (!ray.magnet || ray.source === undefined) continue;
+
+            const p = pts.get(nd);
+            if (p && !p.clipped) origin.set(ray.source, { x: p.x, y: p.y });
+          }
+        }
+
+        for (const nd of graph.nodes) {
+          if (!graph.inFocus(nd)) continue;
+
+          for (const ray of nd) {
+            if (ray.magnet || !ray.moving) continue;
+            if (ray.moving.polarity === Polarity.Neutral) continue;
+
+            const p = pts.get(nd);
+            if (!p || p.clipped) continue;
+
+            const cx = p.x / CELL, cy = p.y / CELL;
+            const sign = ray.moving.polarity === Polarity.Positive ? 1 : -1;
+
+            const wp = layout.get(nd);
+            const out = wp
+              ? Math.min(Math.hypot(...wp) / ((graph.focus ?? 12) * LATTICE_STEP), 1)
+              : 0;
+
+            // Which way is "out" here, and so which way is "round".
+            const from = origin.get(ray.source ?? 0);
+            let ox = from ? cx - from.x / CELL : 0;
+            let oy = from ? cy - from.y / CELL : 0;
+            const len = Math.hypot(ox, oy);
+
+            if (len > 1e-6) { ox /= len; oy /= len; } else { ox = 1; oy = 0; }
+
+            for (let y = Math.max(Math.floor(cy - span), 0); y <= Math.min(Math.ceil(cy + span), rows - 1); y++) {
+              for (let x = Math.max(Math.floor(cx - span), 0); x <= Math.min(Math.ceil(cx + span), cols - 1); x++) {
+                const dx = x - cx, dy = y - cy;
+
+                // Split into how far out and how far round, and measure each
+                // against its own reach.
+                const out2 = dx * ox + dy * oy;
+                const round2 = dx * -oy + dy * ox;
+
+                const d = Math.hypot(out2 / across, round2 / along);
+                if (d >= 1) continue;
+
+                // Smooth to nothing at the edge of its reach, so no charge
+                // leaves a rim of its own in the field.
+                const k = (1 - d * d) ** 2;
+                const i = y * cols + x;
+
+                sum[i] += sign * k;
+                weight[i] += k;
+                if (1 - out > near[i]) near[i] = 1 - out;
+              }
+            }
+
+            /**
+             * Two charges moving into each other are never one thing.
+             *
+             * They are about to meet — next tick they cancel, or they turn
+             * each other round — and the whole meaning of that is that they
+             * came from different places and are arriving at each other. A
+             * body cannot be approaching itself. Yet nothing said so: the
+             * field is built from where charges are and not from where they
+             * are going, so two shells closing on one another read as one
+             * thick region of the same charge, with the interface that is
+             * about to be an event drawn straight through its middle as if it
+             * were the inside of something.
+             *
+             * So the place between them is cut. Where a charge is moving into
+             * a point that holds a charge coming back at it, the field is
+             * held to nothing along the line between the two — and a boundary
+             * is what gets drawn there, which is what puts them in different
+             * islands and keeps them there right up until the tick where they
+             * resolve.
+             */
+            const ahead = ray.moving.target?.at.node;
+
+            if (ahead && ahead !== nd
+              && ahead.some(x => x.moving?.target?.at.node === nd)) {
+              const q = pts.get(ahead);
+
+              if (q && !q.clipped) {
+                const mx = (p.x + q.x) / 2 / CELL, my = (p.y + q.y) / 2 / CELL;
+                const bite = Math.max(across, 2);
+
+                for (let y = Math.max(Math.floor(my - bite), 0); y <= Math.min(Math.ceil(my + bite), rows - 1); y++) {
+                  for (let x = Math.max(Math.floor(mx - bite), 0); x <= Math.min(Math.ceil(mx + bite), cols - 1); x++) {
+                    const d = Math.hypot(x - mx, y - my) / bite;
+                    if (d >= 1) continue;
+
+                    const k = (1 - d * d) ** 2;
+                    const i = y * cols + x;
+
+                    if (k > cut[i]) cut[i] = k;
+                  }
+                }
+              }
+            }
+
+            break; // one sample per point, however many rays are on it
+          }
+        }
+
+        // How positive or negative each part of the picture is: +1 well
+        // inside an amber band, −1 well inside a cyan one, and nothing where
+        // no charge reaches or where the two meet.
+        const target = new Float32Array(cols * rows);
+        const known = new Uint8Array(cols * rows);
+
+        for (let i = 0; i < target.length; i++) {
+          if (weight[i] <= 0) continue;
+
+          target[i] = Math.max(Math.min(sum[i] / weight[i], 1), -1);
+          known[i] = 1;
+        }
+
+        /**
+         * Places no charge reached take the value their surroundings imply.
+         *
+         * A charge is a sample of the field, not the extent of it. Where two
+         * of them happen to fall a little far apart the reading in between is
+         * not "no field" — it is a place nothing was measured, and treating
+         * unmeasured as zero puts a boundary through the middle of a band
+         * wherever the sampling thinned. That is what the holes in the arms
+         * are: not gaps in the field, gaps in the record of it.
+         *
+         * So a value is grown into them from their edges, a ring at a time,
+         * and each takes the average of whatever is already known beside it.
+         * Somewhere with amber on all sides fills in amber, and the band
+         * closes; somewhere between amber and cyan fills in with what is
+         * between them, which is nothing, and the boundary stays exactly
+         * where it was. Only a few rings of it, so a genuinely empty part of
+         * the world stays empty rather than being papered over.
+         */
+        for (let pass = 0; pass < 5; pass++) {
+          const grown: [number, number][] = [];
+
+          for (let y = 1; y + 1 < rows; y++) {
+            for (let x = 1; x + 1 < cols; x++) {
+              const i = y * cols + x;
+              if (known[i]) continue;
+
+              let total = 0, n = 0, warm = 0, cold = 0;
+
+              for (const j of [i - 1, i + 1, i - cols, i + cols]) {
+                if (!known[j]) continue;
+
+                total += target[j];
+                n++;
+
+                if (target[j] > 0.05) warm++;
+                else if (target[j] < -0.05) cold++;
+              }
+
+              /**
+               * Filled only where its surroundings agree.
+               *
+               * Averaging whatever is beside it is right in the middle of a
+               * band and wrong on the edge of one. A place with amber on one
+               * side and cyan on the other is not a hole in either — it is
+               * the seam between them, and filling it with the average is
+               * filling it with something halfway, which is a step towards
+               * one band and the next one out becoming a single band. Enough
+               * of those and the layers close up into each other and the
+               * winding goes.
+               *
+               * So a gap is only closed from the inside. Where the known
+               * neighbours are all of one charge it fills with that charge
+               * and the band mends; where they disagree it is left as it is,
+               * because what is there is a boundary and a boundary is
+               * supposed to be empty.
+               */
+              if (warm && cold) continue;
+
+              if (n >= 2) grown.push([i, total / n]);
+            }
+          }
+
+          if (!grown.length) break;
+
+          // All of them at once, so a ring fills from the ring outside it
+          // rather than from itself half-filled.
+          for (const [i, v] of grown) { target[i] = v; known[i] = 1; }
+        }
+
+        /**
+         * Eased from the last frame rather than replaced.
+         *
+         * The world only changes on a tick, and a tick is a whole cell — a
+         * charge is here, and then it is a cell further out, with nothing in
+         * between because there is nothing in between to be in. Drawn
+         * directly, the picture stands still for a fifth of a second and then
+         * jumps, which is honest about the model and awful to watch: the eye
+         * reads the jump instead of the movement.
+         *
+         * The FIELD, though, is a continuous quantity — how positive a place
+         * is — and there is nothing wrong with a place becoming more positive
+         * gradually. So the drawn field walks towards the true one a fraction
+         * each frame instead of arriving at it at once. A band that moves one
+         * cell out fades out of where it was and into where it has got to,
+         * and what you see is the wave travelling rather than a slideshow of
+         * where it has been.
+         *
+         * It is a property of the drawing and not of the model. Nothing here
+         * is fed back into the dynamics, and a still of any frame is the same
+         * picture the unsmoothed version would have reached a moment later.
+         */
+        if (!eased || eased.length !== target.length) eased = target.slice();
+        else for (let i = 0; i < eased.length; i++)
+          eased[i] += (target[i] - eased[i]) * 0.2;
+
+        /**
+         * And smoothed across itself before anything is traced from it.
+         *
+         * The field is built by dropping a kernel at every charge, so it
+         * carries the charges in it: little bumps where one landed, little
+         * dips between two, all at the scale of a single lattice cell. A line
+         * traced through that follows every one of them, and the arm comes
+         * out scalloped — which is not the shape of the arm, it is the shape
+         * of the fact that it was measured at points.
+         *
+         * A few passes of each sample settling towards the average of the
+         * ones around it takes that out. It is the same operation as the
+         * kernel and could be folded into it, but it is far cheaper here:
+         * spreading a wider kernel costs its area at every charge, while this
+         * costs four additions per sample however wide it ends up being. The
+         * arm is a band across many cells and survives it untouched; the
+         * bumps are one cell across and do not.
+         */
+        // On a copy, never on the eased field itself: that one is carried
+        // from frame to frame, and smoothing something that is then smoothed
+        // again next frame is not a smoothing, it is a slow erasure — after a
+        // few seconds there would be nothing left of the field at all.
+        const f = eased.slice();
+
+        const blur = (a: Float32Array, passes: number) => {
+          for (let pass = 0; pass < passes; pass++) {
+            for (let y = 1; y + 1 < rows; y++) {
+              for (let x = 1; x + 1 < cols; x++) {
+                const i = y * cols + x;
+
+                a[i] = (
+                  a[i] * 4
+                  + a[i - 1] + a[i + 1]
+                  + a[i - cols] + a[i + cols]
+                ) / 8;
+              }
+            }
+          }
+
+          return a;
+        };
+
+        blur(f, 3);
+
+        /**
+         * And the valley between two bands is deepened until it separates
+         * them.
+         *
+         * Where an arm of one charge passes close to another arm of the same
+         * charge, what lies between them is a thin band of the other — and
+         * thin means weak, because the two sides of it are pulling the
+         * average back towards themselves. If it is weak enough that the
+         * field never quite crosses the level being traced, the two arms are
+         * drawn as one: an island that is really two islands with a seam in
+         * it that did not print.
+         *
+         * Comparing the field against a blurred copy of itself says exactly
+         * where that is happening. A place in the middle of a wide band looks
+         * like its own surroundings and the two agree; a place in a narrow
+         * gap is much less positive than its surroundings, because its
+         * surroundings are the arms on either side of it. Taking the
+         * difference and pushing it back in leaves the middles of the bands
+         * where they were and drives the gaps between them down through zero
+         * — which is where a boundary is, so a boundary is what gets drawn,
+         * and the two arms come apart into the two islands they are.
+         */
+        const wide = blur(f.slice(), 9);
+
+        for (let i = 0; i < f.length; i++)
+          f[i] = Math.max(Math.min(f[i] + (f[i] - wide[i]) * 1.6, 1), -1);
+
+        // And nothing survives where two charges are about to meet: the field
+        // there belongs to neither of them, because in a tick it will belong
+        // to whatever they become.
+        for (let i = 0; i < f.length; i++) f[i] *= 1 - cut[i];
+
+        // And the pulses they were emitted in, kept separately, so the grain
+        // of the thing can be drawn under its shape.
+        const waves = new Map<string, {
+          at: { x: number, y: number }[], out: number, n: number, polarity: Polarity,
+        }>();
+
+        for (const nd of graph.nodes) {
+          if (!graph.inFocus(nd)) continue;
+
+          for (const ray of nd) {
+            if (ray.magnet || !ray.moving || ray.wave === undefined) continue;
+            if (ray.moving.polarity === Polarity.Neutral) continue;
+
+            const p = pts.get(nd);
+            if (!p || p.clipped) continue;
+
+            const key = `${ray.wave}|${ray.moving.polarity}`;
+
+            let wave = waves.get(key);
+            if (!wave) waves.set(key, wave = {
+              at: [], out: 0, n: 0, polarity: ray.moving.polarity,
+            });
+
+            wave.at.push({ x: p.x, y: p.y });
+
+            const wp = layout.get(nd);
+            if (wp) wave.out += Math.hypot(...wp) / ((graph.focus ?? 12) * LATTICE_STEP);
+            wave.n++;
+
+            break;
+          }
+        }
+
+
+        /**
+         * The line along which the field crosses a value.
+         *
+         * Marching squares: each little square of four neighbouring samples
+         * is wholly above the value, wholly below, or cut by it — and which
+         * of its sides the cut passes through follows from which corners are
+         * on which side. Where on a side is solved for rather than snapped to
+         * the grid, so the curve is placed to a fraction of a sample and does
+         * not come out looking like stairs.
+         *
+         * The segments come out unordered, so they are then strung together
+         * end to end into runs. That is what turns a scatter of little lines
+         * into a curve that can be smoothed and filled — and a run that
+         * arrives back where it began is a closed one, which is what the
+         * boundary of a body is.
+         */
+        const trace = (level: number) => {
+          const segs: [number, number, number, number][] = [];
+
+          for (let y = 0; y + 1 < rows; y++) {
+            for (let x = 0; x + 1 < cols; x++) {
+              const v = [
+                f[y * cols + x], f[y * cols + x + 1],
+                f[(y + 1) * cols + x + 1], f[(y + 1) * cols + x],
+              ];
+
+              let mask = 0;
+              for (let c = 0; c < 4; c++) if (v[c] > level) mask |= 1 << c;
+              if (mask === 0 || mask === 15) continue;
+
+              const corner = [[x, y], [x + 1, y], [x + 1, y + 1], [x, y + 1]];
+
+              const cut = (a: number, b: number): [number, number] => {
+                const t = Math.max(Math.min((level - v[a]) / ((v[b] - v[a]) || 1e-9), 1), 0);
+
+                return [
+                  (corner[a][0] + (corner[b][0] - corner[a][0]) * t) * CELL,
+                  (corner[a][1] + (corner[b][1] - corner[a][1]) * t) * CELL,
+                ];
+              };
+
+              const on: [number, number][] = [];
+              for (let c = 0; c < 4; c++) {
+                const d = (c + 1) % 4;
+                if (((mask >> c) & 1) !== ((mask >> d) & 1)) on.push(cut(c, d));
+              }
+
+              if (on.length === 2) segs.push([on[0][0], on[0][1], on[1][0], on[1][1]]);
+              else if (on.length === 4) {
+                segs.push([on[0][0], on[0][1], on[1][0], on[1][1]]);
+                segs.push([on[2][0], on[2][1], on[3][0], on[3][1]]);
+              }
+            }
+          }
+
+          // Strung end to end. Endpoints are shared exactly between
+          // neighbouring squares, so matching them to the nearest tenth of a
+          // pixel is enough to find which segment continues which.
+          const key = (x: number, y: number) => `${Math.round(x * 10)},${Math.round(y * 10)}`;
+          const ends = new Map<string, number[]>();
+
+          segs.forEach(([ax, ay, bx, by], i) => {
+            for (const k of [key(ax, ay), key(bx, by)]) {
+              const list = ends.get(k);
+              if (list) list.push(i); else ends.set(k, [i]);
+            }
+          });
+
+          const used = new Array(segs.length).fill(false);
+          const runs: { x: number, y: number }[][] = [];
+
+          for (let i = 0; i < segs.length; i++) {
+            if (used[i]) continue;
+            used[i] = true;
+
+            const [ax, ay, bx, by] = segs[i];
+            const run = [{ x: ax, y: ay }, { x: bx, y: by }];
+
+            // Follow it forwards, then turn round and follow the other way.
+            for (let pass = 0; pass < 2; pass++) {
+              for (; ;) {
+                const tip = run[run.length - 1];
+                const next = (ends.get(key(tip.x, tip.y)) ?? []).find(j => !used[j]);
+                if (next === undefined) break;
+
+                used[next] = true;
+
+                const [cx2, cy2, dx2, dy2] = segs[next];
+                const near = Math.hypot(cx2 - tip.x, cy2 - tip.y) < Math.hypot(dx2 - tip.x, dy2 - tip.y);
+
+                run.push(near ? { x: dx2, y: dy2 } : { x: cx2, y: cy2 });
+              }
+
+              run.reverse();
+            }
+
+            if (run.length >= 4) runs.push(run);
+          }
+
+          return runs;
+        };
+
+        /**
+         * A run, eased.
+         *
+         * Marching squares places every point on the edge of a sample square,
+         * so a curve through them carries the grid's own fret in it — a
+         * regular little waver at the scale of one sample, which is nothing
+         * about the field and everything about how it was measured. A few
+         * passes of each point drifting towards the middle of its neighbours
+         * takes that out and leaves the shape, which is at the scale of a
+         * band and untouched by it.
+         */
+        const ease = (run: { x: number, y: number }[], closed: boolean) => {
+          let cur = run;
+
+          for (let pass = 0; pass < 10; pass++) {
+            const next = cur.map((p, i) => {
+              if (!closed && (i === 0 || i === cur.length - 1)) return p;
+
+              const a = cur[(i - 1 + cur.length) % cur.length];
+              const b = cur[(i + 1) % cur.length];
+
+              return { x: (a.x + 2 * p.x + b.x) / 4, y: (a.y + 2 * p.y + b.y) / 4 };
+            });
+
+            cur = next;
+          }
+
+          return cur;
+        };
+
+        const prev = ctx.globalCompositeOperation;
+        ctx.globalCompositeOperation = "lighter";
+
+        /**
+         * The waves themselves, underneath and barely there.
+         *
+         * The spirals are what the field IS, and they are drawn above. But a
+         * spiral is made of something — one shell after another, each thrown
+         * off a moment later than the last and a little further round — and
+         * with only the boundaries drawn there is nothing in the picture that
+         * says so. A faint outline per pulse puts that back: the rings are
+         * the grain of the thing, and the winding is the thing.
+         */
+        for (const [id, wave] of waves) {
+          if (wave.at.length < 3) continue;
+
+          const hull = outline(wave.at);
+          if (hull.length < 3) continue;
+
+          const tint = wave.polarity === Polarity.Positive ? "255,122,69" : "61,220,255";
+          const at = (i: number) => hull[(i % hull.length + hull.length) % hull.length];
+
+          ctx.beginPath();
+          ctx.moveTo(hull[0].x, hull[0].y);
+
+          for (let i = 0; i < hull.length; i++) {
+            const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
+
+            ctx.bezierCurveTo(
+              p1.x + (p2.x - p0.x) / 6, p1.y + (p2.y - p0.y) / 6,
+              p2.x - (p3.x - p1.x) / 6, p2.y - (p3.y - p1.y) / 6,
+              p2.x, p2.y,
+            );
+          }
+
+          ctx.closePath();
+          /**
+           * And the older ones stop being drawn rather than piling up.
+           *
+           * A dozen pulses in the air at once is a dozen rings, and the
+           * further out they are the longer their outlines are and the more
+           * of them cross each other — so the outside of the picture ends up
+           * carrying most of the ink for the part of the field that has least
+           * in it. Cut off once they are past halfway out, what is left is
+           * the handful nearest the source, which are the ones that read as
+           * pulses.
+           */
+          const lift = Math.max(1 - wave.out / wave.n, 0);
+          if (lift < 0.45) continue;
+
+          // Faint enough to be texture. There are several of these to every
+          // band and their outlines run alongside it, so at anything like the
+          // band's own weight they stop being the grain of it and become a
+          // second set of edges arguing with the first.
+          ctx.strokeStyle = `rgba(${tint},${lift * lift * 0.18})`;
+          ctx.lineWidth = 0.9;
+          ctx.stroke();
+        }
+
+        // Traced where the field is only weakly one thing rather than
+        // firmly so. A high level draws a line well inside each band and the
+        // arm comes out thin, broken wherever it happens to be weak; a low
+        // one follows the band right out to where it gives way to its
+        // neighbour, which is where the two actually meet.
+        /**
+         * A fill that dims with distance from the source rather than with
+         * which island it belongs to.
+         *
+         * A fill takes one colour for the whole shape it fills, so a band
+         * cannot be shaded along itself the way its edge can. What it can be
+         * given is a colour that is already a gradient — bright at the middle
+         * of the picture and thin at the rim — and then every band is dim
+         * where it is far out and bright where it is close in, including the
+         * ones that are both.
+         */
+        const centre = origin.size
+          ? [...origin.values()].reduce((a, p) => ({
+            x: a.x + p.x / origin.size, y: a.y + p.y / origin.size,
+          }), { x: 0, y: 0 })
+          : { x: w / 2, y: h / 2 };
+
+        const span2 = (graph.focus ?? 12) * LATTICE_STEP * cam.scale;
+
+        const wash = (tint: string) => {
+          const g = ctx.createRadialGradient(
+            centre.x, centre.y, 0, centre.x, centre.y, Math.max(span2, 1),
+          );
+
+          g.addColorStop(0, `rgba(${tint},0.3)`);
+          g.addColorStop(0.45, `rgba(${tint},0.14)`);
+          g.addColorStop(1, `rgba(${tint},0.03)`);
+
+          return g;
+        };
+
+        const strength = (p: { x: number, y: number }) => {
+          const i = Math.min(Math.max(Math.round(p.y / CELL), 0), rows - 1) * cols
+            + Math.min(Math.max(Math.round(p.x / CELL), 0), cols - 1);
+
+          const lift = near[i];
+
+          return 0.08 + lift * lift * 0.92;
+        };
+
+        for (const [level, tint] of [[0.22, "255,122,69"], [-0.22, "61,220,255"]] as [number, string][]) {
+          const runs = trace(level).map(raw => {
+            const closed = Math.hypot(
+              raw[0].x - raw[raw.length - 1].x, raw[0].y - raw[raw.length - 1].y,
+            ) < CELL * 2;
+
+            return { run: ease(raw, closed), closed };
+          });
+
+          const curve = (into: Path2D, run: { x: number, y: number }[], closed: boolean) => {
+            const at = (i: number) => run[closed
+              ? (i % run.length + run.length) % run.length
+              : Math.max(Math.min(i, run.length - 1), 0)];
+
+            into.moveTo(run[0].x, run[0].y);
+
+            for (let i = 0; i < run.length - (closed ? 0 : 1); i++) {
+              const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
+
+              into.bezierCurveTo(
+                p1.x + (p2.x - p0.x) / 6, p1.y + (p2.y - p0.y) / 6,
+                p2.x - (p3.x - p1.x) / 6, p2.y - (p3.y - p1.y) / 6,
+                p2.x, p2.y,
+              );
+            }
+
+            if (closed) into.closePath();
+          };
+
+          /**
+           * All of one charge's boundaries filled as ONE shape, with the
+           * even-odd rule.
+           *
+           * A body of one charge is not simply a blob with an edge. An arm
+           * that winds round has the other charge inside the loop it makes,
+           * and that shows up here as a second closed curve lying within the
+           * first — the hole, not another island. Filled one curve at a time,
+           * the hole gets filled too, and amber is painted straight over the
+           * cyan that lives there: two regions that cannot overlap in the
+           * field, overlapping in the picture, purely as an artefact of
+           * filling their boundaries separately.
+           *
+           * Taken together under the even-odd rule, a place is inside the
+           * body when the boundary wraps it an odd number of times — so the
+           * inside of the arm is filled, the hole within it is not, and what
+           * is drawn is the region rather than everything its edges happen to
+           * enclose.
+           */
+          const body = new Path2D();
+          for (const { run, closed } of runs) if (closed) curve(body, run, closed);
+
+          ctx.fillStyle = wash(tint);
+          ctx.fill(body, "evenodd");
+
+          // A brighter rim on top of it, stroked span by span so that its
+          // strength is the strength of the field where each piece of it
+          // actually lies rather than the average over the whole run.
+          ctx.lineWidth = 1.4;
+          ctx.lineCap = "round";
+
+          for (const { run, closed } of runs) {
+            const at = (i: number) => run[closed
+              ? (i % run.length + run.length) % run.length
+              : Math.max(Math.min(i, run.length - 1), 0)];
+
+            for (let i = 0; i + 1 < run.length + (closed ? 1 : 0); i++) {
+              const a = at(i), b = at(i + 1);
+
+              ctx.strokeStyle = `rgba(${tint},${0.75 * strength(a)})`;
+              ctx.beginPath();
+              ctx.moveTo(a.x, a.y);
+              ctx.lineTo(b.x, b.y);
+              ctx.stroke();
+            }
+          }
+
+          ctx.lineCap = "butt";
+        }
+
+        ctx.globalCompositeOperation = prev;
+      }
+
       for (const n of graph.nodes) {
         const p = pts.get(n);
         if (!p || p.clipped || !onScreen(p)) continue;
@@ -4997,6 +5902,7 @@ const alternatingIntoRandom = (size: number, inner: Polarity): LineSide[] => [
 const MAGNET_CASES: {
   name: string, a?: number[], b?: number[],
   axis?: number[], spin?: boolean, alone?: boolean, turning?: 1 | -1,
+  crossed?: boolean,
 }[] = [
   /**
    * One magnet, on its own, held still — and the answer to whether anything
@@ -5030,7 +5936,7 @@ const MAGNET_CASES: {
    * pole. It is the nearest thing these rules have to one: the two halves of
    * the field closing on each other, around the middle, some way out.
    */
-  { name: 'one magnet, on its own', axis: [1, 0, 0], spin: false, alone: true },
+  // { name: 'one magnet, on its own', axis: [1, 0, 0], spin: false, alone: true },
 
   // Neither going anywhere: the baseline, in which anything that moves, moved
   // because of the field.
@@ -5116,7 +6022,7 @@ const MAGNET_CASES: {
    * them together, nothing built out of these rules will, and the answer is
    * about the rules rather than about the setup.
    */
-  { name: 'two magnets, poles facing', axis: [1, 0, 0], spin: false },
+  // { name: 'two magnets, poles facing', axis: [1, 0, 0], spin: false },
 
   /**
    * One magnet, actually turning.
@@ -5156,6 +6062,26 @@ const MAGNET_CASES: {
    * same way.
    */
   { name: 'two magnets, turning', axis: [1, 0, 0], spin: false, turning: 1 },
+
+  /**
+   * The two of them turning in planes at right angles to each other.
+   *
+   * Everything above turns in the plane the pair are laid out in, which is
+   * the flat case dressed up in three dimensions: both arms wind in the same
+   * plane, and a picture of it says nothing a drawing on paper could not.
+   * Here the left one comes round from x towards y and the right one from x
+   * towards z, so the two spirals lie in surfaces at right angles and cross
+   * rather than overlap.
+   *
+   * It is the one arrangement in this article that could not exist in fewer
+   * than three dimensions — two planes meeting in a line — and the thing to
+   * watch is that line, which is where the only directions belonging to both
+   * of them are, and so the only places their fields can meet at all.
+   */
+  // {
+  //   name: 'two magnets, turning in crossed planes',
+  //   axis: [1, 0, 0], spin: false, turning: 1, crossed: true,
+  // },
 ];
 
 const MAGNET_SPINS: { name: string, phase: number }[] = [
@@ -5266,7 +6192,7 @@ const RayCalculiAndPhysics = () => {
             What is drawn is the structure rather than the coordinates, so
             space that has been annihilated out of the world is not a hole in
             the picture — it is two things that are now nearer each other. */}
-        {MAGNET_CASES.map(({ name, a, b, axis, spin: flipping = true, alone, turning }) => (
+        {MAGNET_CASES.map(({ name, a, b, axis, spin: flipping = true, alone, turning, crossed }) => (
           <Fragment key={`magnets-${name}`}>
             {/* What the pair of runs is contrasting depends on what the
                 sources are doing. Flipping in place, it is whether they flip
@@ -5287,11 +6213,102 @@ const RayCalculiAndPhysics = () => {
                     { emits: Polarity.Positive, moving: a, axis, turning },
                     {
                       emits: Polarity.Positive, moving: b, phase: spin.phase, axis,
+                      // The second one turning in a plane at right angles to
+                      // the first: x towards z rather than x towards y.
+                      plane: crossed
+                        ? [[1, 0, 0], [0, 0, 1]] as [number[], number[]]
+                        : undefined,
                       // The second one comes round the other way when they
                       // are set against each other.
                       turning: turning ? (turning * spin.sense) as 1 | -1 : undefined,
                     },
-                    { spin: flipping, alone },
+                    {
+                      spin: flipping, alone,
+                      // A spiral is where each pulse went. Wandering is each
+                      // pulse going somewhere slightly else on the way, which
+                      // is exactly the information an arm is made of, rubbed
+                      // out — measurably: the distance out stops tracking how
+                      // long ago it left.
+                      wander: turning ? 0 : undefined,
+
+                      /**
+                       * One pulse per cell the wave advances, which for a
+                       * turning source means one every third tick.
+                       *
+                       * The two have to agree. Charges from a turning magnet
+                       * are held to a cell every third tick, so that the
+                       * magnet gets three eighths of a turn round between one
+                       * ring of the wave and the next and the winding is
+                       * tight. Emit every tick against that and the ring of
+                       * cells around the source has not cleared when the next
+                       * pulse is due: it goes out as one or two charges
+                       * instead of two dozen, and most of the shells are too
+                       * thin to be anything. Measured, that leaves gaps at
+                       * two thirds of the radii and under a full turn of
+                       * winding across the whole ball.
+                       *
+                       * Matched, every pulse leaves into empty space and
+                       * lands one cell further out than the one before, so
+                       * the ball is layered the whole way from the source to
+                       * the edge with a hundred and thirty-five degrees
+                       * between each layer and the next.
+                       */
+                      /**
+                       * Long enough that every direction has cleared, which
+                       * is set by the slowest of them.
+                       *
+                       * A step costs its own length, so a charge leaving
+                       * through a corner of its cell takes √3 times as long
+                       * to be gone as one leaving through a face. Emit again
+                       * before that and the corner directions are still
+                       * occupied by the last pulse: what goes out is the six
+                       * faces and a few edges — fourteen of the twenty-six —
+                       * and the shell has holes in it in exactly the
+                       * directions that were slowest, every time, in the same
+                       * places. Which is a spiral with pieces missing out of
+                       * it wherever the lattice is coarsest.
+                       *
+                       * Waiting the √3·3 ≈ 6 ticks a corner needs, every
+                       * pulse leaves whole. The wave advances two cells in
+                       * that time and the magnet turns three quarters of the
+                       * way round, so the pitch is what it was — an eighth of
+                       * a turn per third of a cell — with half as many shells
+                       * in the air, each of them entire.
+                       */
+                      // Every tick, like everything else here. A cell
+                      // emptied this tick is free the next, so the source is
+                      // never waiting on its own last pulse: a shell leaves
+                      // whole every tick, lands one cell further out than the
+                      // one before, and the magnet has turned an eighth of a
+                      // turn in between. The ball is layered the whole way
+                      // from the source to the edge, each layer rotated from
+                      // the one inside it, which is what a spiral is.
+                      every: undefined,
+
+                      /**
+                       * And fanning as early as it can, which is what closes
+                       * the gaps.
+                       *
+                       * A shell is the two dozen directions the source has,
+                       * and two dozen points spread over a sphere of radius
+                       * ten are nowhere near each other — the band they are
+                       * supposed to make is dots with holes between them, and
+                       * no amount of care in the drawing joins up something
+                       * that is not joined. Every charge fanning sideways
+                       * into the room around it as soon as it has any
+                       * multiplies each shell several times over, and it does
+                       * it where the gaps are: out at the far end, where a
+                       * shell has grown and its charges have drifted apart.
+                       */
+                      // Out where there is room for it, rather than at the
+                      // first opportunity. Fanning close in crowds the few
+                      // cells near the source and thickens the shells there
+                      // (measured: half again as thick, and half of
+                      // everything waiting to move); fanning out where a
+                      // shell has already grown puts the extra charges
+                      // exactly where the gaps between them have opened.
+                      fanAt: turning ? 5 : undefined,
+                    },
                   )}
                   repeated={60}
                   // Said outright rather than left to follow from `repeated`,
@@ -5302,7 +6319,13 @@ const RayCalculiAndPhysics = () => {
                   autoplay
                   height={320}
                   interval={0.2}
-                  mode="field"
+                  // A turning source lays down a spiral, and a spiral
+                  // belongs to a whole train of shells rather than to any one
+                  // of them — drawn pulse by pulse it is a stack of lobes and
+                  // the winding is nowhere. Everything else is a source that
+                  // emits the same thing in every direction, where the pulse
+                  // IS the object and the shells say it best.
+                  mode={turning ? "field" : "shells"}
                   // The glow is a sum over every charge, and with a pulse
                   // going out every tick that is most of the ball — one even
                   // wash, hiding the shells it is drawn from.

From 1f41768284ae91b04d796191d7c934fa0cbf2c8c Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Fri, 7 Aug 2026 15:29:26 +0200
Subject: [PATCH 11/47] Trying to stabalize rendering, 2D & optimizations

---
 .../archive/2026.RayCalculiAndPhysics.tsx     | 1344 ++++++++++++++---
 1 file changed, 1128 insertions(+), 216 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index 2052372..863359a 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -2327,6 +2327,26 @@ class Graph {
       spin = true,
       alone = false,
 
+      /**
+       * How many dimensions the space has, and two is not a lesser version
+       * of three.
+       *
+       * The turn is flat — the axis comes round in one plane and stays in it
+       * — so everything a turning source does happens in that plane, and the
+       * third dimension contributes nothing to it but the rest of a sphere
+       * for the same arms to be seen through. A picture of the 3D case is a
+       * projection: the arms are there, and so is every part of the ball that
+       * is neither in front of them nor behind them, laid over the top.
+       *
+       * Flat, the plane of the turn IS the picture. There is nothing in front
+       * of the spiral and nothing behind it, so what is on screen is the
+       * thing itself at last, rather than the thing plus the depth it was
+       * looked at through. Which makes the two worth having side by side: the
+       * flat one says what the arrangement does, and the round one says what
+       * survives being embedded in a world with a spare direction in it.
+       */
+      dims = 3,
+
       /**
        * Ticks per eighth of a turn, and one is as fast as turning goes.
        *
@@ -2382,29 +2402,35 @@ class Graph {
     }: {
       radius?: number, sep?: number, every?: number,
       spin?: boolean, alone?: boolean, turnEvery?: number, wander?: number,
-      spread?: number, fanAt?: number, range?: number,
+      spread?: number, fanAt?: number, range?: number, dims?: number,
     } = {},
   ): Graph {
     const graph = new Graph();
-    graph.dims = 3;
+    graph.dims = dims;
     graph.ringRadius = 1; // the lattice is the picture; nothing to round off
     graph.relax = true;
     graph.wander = wander;
     graph.sealed = true; // a closed ball: no edges to walk off, no tears
 
     // A ball rather than a cube, so that "the same in every direction" is
-    // true of the space as well as of what is emitted into it.
+    // true of the space as well as of what is emitted into it. A disc, in two
+    // dimensions, for the same reason and by the same test.
     const coords: number[][] = [];
-    for (let x = -radius; x <= radius; x++)
-      for (let y = -radius; y <= radius; y++)
-        for (let z = -radius; z <= radius; z++)
-          if (x * x + y * y + z * z <= radius * radius) coords.push([x, y, z]);
+
+    (function fill(at: number[]) {
+      if (at.length === dims) {
+        if (at.reduce((r, v) => r + v * v, 0) <= radius * radius) coords.push(at);
+        return;
+      }
+
+      for (let v = -radius; v <= radius; v++) fill([...at, v]);
+    })([]);
 
     // Nothing is charged to begin with. Every charge in this universe comes
     // out of one of the two sources, so there is nothing to confuse a pulse
     // with — what you see moving was emitted.
     const { byCoord, key } = Graph.wire(
-      graph, coords, () => Polarity.Neutral, directions(3),
+      graph, coords, () => Polarity.Neutral, directions(dims),
     );
 
     // The camera is for the part of the ball that anything ever happens in,
@@ -2414,10 +2440,13 @@ class Graph {
     // edge, when in fact they are running the whole way to it.
     graph.focus = radius - 2;
 
-    // One source at the middle, or two facing each other across the gap.
+    // One source at the middle, or two facing each other across the gap,
+    // laid out along x in however many dimensions there are.
+    const at = (x: number) => new Array(dims).fill(0).map((v, i) => (i === 0 ? x : v));
+
     const sides: [number[], MagnetSide][] = alone
-      ? [[[0, 0, 0], a]]
-      : [[[-sep, 0, 0], a], [[sep, 0, 0], b]];
+      ? [[at(0), a]]
+      : [[at(-sep), a], [at(sep), b]];
 
     sides.forEach(([coord, side], source) => {
       const nd = byCoord.get(key(coord));
@@ -3761,14 +3790,21 @@ const GraphView = ({
   density = true,
   mode = 'lattice',
   onFrame,
+  onVisible,
 }: {
   // Read afresh every frame, so a reset that swaps the whole graph out is
-  // picked up without tearing the render loop down.
-  graph: () => Graph;
+  // picked up without tearing the render loop down. Nothing at all is a
+  // universe that has been let go of because nobody is looking at it — the
+  // view draws nothing rather than pretending there is something to draw.
+  graph: () => Graph | null;
   animate?: boolean;
   density?: boolean;
   mode?: RenderMode;
   onFrame?: (dt: number) => void;
+
+  // Called as the view comes on and off screen, so that whoever owns the
+  // universe can let go of it and make a new one. See `CalculusPlayer`.
+  onVisible?: (visible: boolean) => void;
 }) => {
   const canvasRef = useRef(null);
   const camRef = useRef({ scale: 44, rot: Math.PI / 4, tilt: 0.6155, anchor: null, dist: null, distMult: 1.5, scaleMult: 1 });
@@ -3779,16 +3815,20 @@ const GraphView = ({
   // pausing do nothing: the loop kept calling the first render's onFrame,
   // where `running` was frozen at its initial value). Kept in refs and read
   // per frame, so the loop always calls the current ones.
-  const latest = useRef({ current, onFrame });
-  latest.current = { current, onFrame };
+  const latest = useRef({ current, onFrame, onVisible });
+  latest.current = { current, onFrame, onVisible };
 
   // TODO Right click/left click cursor=grab
   useEffect(() => {
     const canvas = canvasRef.current;
     const ctx = canvas.getContext("2d");
-    let raf: number;
+    let raf = 0;
     let last = performance.now();
 
+    // Whether anyone is looking. Nothing is drawn, ticked or held on to
+    // until this is true — see the observer at the bottom of this effect.
+    let seen = false;
+
     // The field as drawn, which lags the field as computed and catches up a
     // fraction every frame. Kept across frames because that lag is the whole
     // of what makes the animation flow rather than step.
@@ -3804,12 +3844,20 @@ const GraphView = ({
       canvas.style.height = h + "px";
       ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
     }
-    resize();
+
+    // Deliberately not called here: a view that is never scrolled to should
+    // never take its pixels at all. `show` asks for them.
     const onResize = () => {
       resize();
-      if (!animate) draw(); // no frame loop to pick the new size up
+      // No frame loop to pick the new size up — but only if there is anyone
+      // to pick it up for.
+      if (!animate && seen) draw();
     };
-    window.addEventListener("resize", onResize);
+
+    // Only while it is on screen; off screen there is no buffer to resize,
+    // and it will be asked for at the size it is when it comes back.
+    const onResizeIfSeen = () => { if (seen) onResize(); };
+    window.addEventListener("resize", onResizeIfSeen);
 
     // Scroll to zoom. 2D: cursor-anchored zoom (screen-space, no depth to
     // navigate) — modifies cam.scaleMult. 3D: real dolly — scrolling
@@ -3895,6 +3943,7 @@ const GraphView = ({
     function draw() {
       const cam = camRef.current;
       const graph = latest.current.current();
+      if (!graph) return;
       // The outline enclosing a set of points. Andrew's monotone chain:
       // sort, then walk once along the bottom and once back along the top,
       // dropping any point the walk turns the wrong way at.
@@ -4473,6 +4522,50 @@ const GraphView = ({
         const near = new Float32Array(cols * rows);
         const cut = new Float32Array(cols * rows);
 
+        /**
+         * The average over a square neighbourhood, however wide, for the
+         * price of one.
+         *
+         * A running total gives every sample the mean over its whole
+         * neighbourhood in one pass per axis, where a diffusion of the same
+         * width costs passes going as the square of it. It is a cruder shape
+         * of average than the smoothing the picture is drawn from, and it is
+         * used only where nothing is drawn from it — spreading the directions
+         * the charges are travelling in, and deciding how hard to press. Both
+         * are decisions about the field rather than the field, and there is
+         * no such thing as a square edge on a decision.
+         */
+        const scratch = new Float32Array(cols * rows);
+
+        const box = (a: Float32Array, r: number) => {
+          const clampX = (x: number) => Math.min(Math.max(x, 0), cols - 1);
+          const clampY = (y: number) => Math.min(Math.max(y, 0), rows - 1);
+          const n = 2 * r + 1;
+
+          for (let y = 0; y < rows; y++) {
+            const row = y * cols;
+            let acc = 0;
+
+            for (let x = -r; x <= r; x++) acc += a[row + clampX(x)];
+
+            for (let x = 0; x < cols; x++) {
+              scratch[row + x] = acc / n;
+              acc += a[row + clampX(x + r + 1)] - a[row + clampX(x - r)];
+            }
+          }
+
+          for (let x = 0; x < cols; x++) {
+            let acc = 0;
+
+            for (let y = -r; y <= r; y++) acc += scratch[clampY(y) * cols + x];
+
+            for (let y = 0; y < rows; y++) {
+              a[y * cols + x] = acc / n;
+              acc += scratch[clampY(y + r + 1) * cols + x] - scratch[clampY(y - r) * cols + x];
+            }
+          }
+        };
+
         /**
          * How far one charge speaks for, and it is bounded on both sides.
          *
@@ -4482,44 +4575,65 @@ const GraphView = ({
          * round, the alternation averages itself away, and there is one grey
          * body instead of two winding ones.
          *
-         * The right size is set by the winding itself. A source turning an
-         * eighth of a turn a tick, whose wave advances a cell every third
-         * tick, comes right round every two and two thirds cells — so bands
-         * of one sign lie that far apart, and a charge should speak for about
-         * half of that. Then a band closes up along its own length and still
-         * stops dead against its neighbour.
+         * The right size is set by the winding itself, and the winding here
+         * is the one `every: undefined` above settles on: a shell leaves
+         * every tick, the wave advances a cell a tick, and the source comes
+         * round an eighth of a turn in between. So a whole turn is CYCLE
+         * cells out from the source and a band of one sign is half of that —
+         * four cells thick, with four cells of the other sign beyond it.
          */
         const step = cam.scale * LATTICE_STEP;          // pixels per cell
+        const band = (CYCLE / 2) * step / CELL;         // samples across one band
 
         /**
-         * And it reaches further ALONG a band than across to the next one.
+         * And it reaches much further across a charge's path than along it.
          *
          * A round reach has to be a compromise between two things that want
          * opposite sizes. The holes to be closed are the gaps between charges
          * of one shell, which open up as the shell grows and are the reason
-         * the bands come out as strings of islands; closing them wants a
-         * generous reach. What must not be closed is the gap between one turn
-         * of the spiral and the next, which is where the alternation lives;
-         * keeping that wants a mean one. Round, there is no size that does
-         * both, and the picture is either beads or porridge.
+         * the arcs come out as strings of islands; closing them wants a
+         * generous reach. What must not be closed is the gap between one
+         * shell and the next, which is where the alternation lives, since a
+         * shell four along is the opposite charge; keeping that wants a mean
+         * one. Round, there is no size that does both, and the picture is
+         * either beads or porridge.
+         *
+         * But the two gaps are not in the same direction, and the direction
+         * that tells them apart is the one the charges are travelling in. A
+         * shell is spread out ACROSS its own motion — every part of it left
+         * together and is the same age and the same charge — and the next
+         * shell is one cell AHEAD. So the reach is an ellipse laid across the
+         * path: long the way the shell runs, short the way it is going.
+         * Nothing is invented by this. It is a statement about which charges
+         * are neighbours, and a charge's neighbours are the ones off its
+         * shoulders rather than the one in front.
          *
-         * But the two gaps are not in the same direction. A band runs the way
-         * a shell runs — around the source — and the next band along is
-         * further out from it. So the reach is made an ellipse: long the way
-         * round, short the way out. Charges of one shell run together along
-         * their own arc, and the arc still stops dead against the arc beyond
-         * it. Nothing is invented by this — it is a statement about which
-         * neighbours a charge has, and a charge on a shell has its neighbours
-         * beside it rather than in front.
+         * The short axis is the delicate one, and it is why merging with any
+         * generosity in the direction of travel was wrong. Four shells make
+         * one band, so a reach of much over a cell forward joins a charge to
+         * shells that are still its own sign, which is wanted; a reach of
+         * four joins it to the opposite one, which averages the alternation
+         * away and is how a set of arcs turns into a disc.
+         *
+         * A cell, then, and not a cell and a half. Every fraction past the
+         * spacing between two shells is spent averaging a band against the
+         * one beyond it, and that cost is paid over the whole width of the
+         * seam rather than at the seam: a reach of a cell and a half puts
+         * three cells of a four-cell band within sight of the other charge
+         * and there is very little of it left reading as wholly one thing. At
+         * exactly the spacing the shells of a band still touch — which is all
+         * that is needed for it to be one body, the closing along each shell
+         * being what actually mends it — and a charge's reach stops dead
+         * before anything of the other sign.
          */
-        const along = Math.max((step * 3.4) / CELL, 4);   // the way round
-        const across = Math.max((step * 0.6) / CELL, 1.2); // the way out
-        const span = Math.ceil(along);
+        const across = Math.max(band / 4.5, 1.2);           // the way it is going
+        const along = Math.max(band * 1.15, across * 3);    // the way it is spread
 
         // Where each source is on the screen, which is what "out from it"
         // means. Anything with no source of its own is measured from the
         // middle of the picture.
         const origin = new Map<number, { x: number, y: number }>();
+
         for (const nd of graph.nodes) {
           for (const ray of nd) {
             if (!ray.magnet || ray.source === undefined) continue;
@@ -4529,6 +4643,85 @@ const GraphView = ({
           }
         }
 
+        // How far out each part of the picture is from the nearest source,
+        // and which way that is — the fallback frame, for the places no
+        // charge has an opinion about.
+        const outX = new Float32Array(cols * rows);
+        const outY = new Float32Array(cols * rows);
+        const rad = new Float32Array(cols * rows);
+
+        {
+          const from = origin.size
+            ? [...origin.values()].map(p => ({ x: p.x / CELL, y: p.y / CELL }))
+            : [{ x: cols / 2, y: rows / 2 }];
+
+          for (let y = 0; y < rows; y++) {
+            for (let x = 0; x < cols; x++) {
+              let dx = 1, dy = 0, len = Infinity;
+
+              for (const s of from) {
+                const ex = x - s.x, ey = y - s.y;
+                const d = Math.hypot(ex, ey);
+
+                if (d < len) { len = d; dx = ex; dy = ey; }
+              }
+
+              const i = y * cols + x;
+
+              rad[i] = len;
+
+              if (len > 1e-6) { outX[i] = dx / len; outY[i] = dy / len; }
+              else { outX[i] = 1; outY[i] = 0; }
+            }
+          }
+        }
+
+        /**
+         * Which way the field runs, taken from the charges rather than
+         * supposed of them.
+         *
+         * Everything here that closes a gap or opens one needs to know which
+         * way the thing it is working on lies — the kernel, so it can be an
+         * ellipse; the smoothing and the bridging, so they run along a body
+         * and not across one; the sharpening, so it cuts between two and not
+         * through the middle of either.
+         *
+         * And the answer is not a shape to be assumed. Supposing the bodies
+         * are rings and merging round the source draws rings; supposing they
+         * are spirals of a particular pitch and merging along that draws
+         * those. Both are the picture telling you what it was told. Worse,
+         * merging the way the charges are GOING joins each one to the one in
+         * front of it, which is the one that left a tick earlier — so a band
+         * gets knitted together from the inside out, across the very
+         * direction its polarity alternates in, and the alternation is what
+         * gets averaged away.
+         *
+         * What a charge is actually beside is what left with it. A shell is
+         * one emission, every part of it the same age and the same charge,
+         * and it is spread out ACROSS the way it travels — so the neighbours
+         * of a charge are the ones off its shoulders, and the thing in front
+         * of it is a different shell of possibly the other sign. Merge
+         * orthogonal to the motion and each shell closes into the arc it is;
+         * a source that only flips gives rings, a source that turns gives
+         * arcs each rotated from the last, which is a spiral. Neither is
+         * imposed. Both come out of the same rule, which is a statement about
+         * which charges are neighbours and says nothing about shape.
+         *
+         * Kept as a doubled angle so it can be averaged at all. These are
+         * lines rather than arrows — a charge going one way and a charge
+         * coming back lie along the same line and belong together — and
+         * averaging arrows would have the two cancel to nothing exactly where
+         * two shells meet. Doubling the angle makes opposites identical,
+         * which is what they are here, and halving it back afterwards
+         * recovers the line.
+         */
+        const spinA = new Float32Array(cols * rows);   // cos of the doubled angle
+        const spinB = new Float32Array(cols * rows);   // sin of it
+        const spinW = new Float32Array(cols * rows);
+
+        const runX = new Float32Array(cols * rows);
+        const runY = new Float32Array(cols * rows);
+
         for (const nd of graph.nodes) {
           if (!graph.inFocus(nd)) continue;
 
@@ -4547,7 +4740,8 @@ const GraphView = ({
               ? Math.min(Math.hypot(...wp) / ((graph.focus ?? 12) * LATTICE_STEP), 1)
               : 0;
 
-            // Which way is "out" here, and so which way is "round".
+            // How far out it is, which is only used to keep the reach inside
+            // the arc there is to reach along.
             const from = origin.get(ray.source ?? 0);
             let ox = from ? cx - from.x / CELL : 0;
             let oy = from ? cy - from.y / CELL : 0;
@@ -4555,16 +4749,87 @@ const GraphView = ({
 
             if (len > 1e-6) { ox /= len; oy /= len; } else { ox = 1; oy = 0; }
 
+            /**
+             * And which way it is going, on the screen, which is the one
+             * thing the ellipse is oriented by.
+             *
+             * `heading` first: that is the direction in the large, and a step
+             * is only this tick's piece of it. Where there is no heading —
+             * nothing wanders in these examples, so most of the time — the
+             * step and the direction are the same thing and the point ahead
+             * says it exactly.
+             *
+             * Projected rather than taken from the lattice, because what is
+             * being drawn is the screen. A charge travelling straight at the
+             * camera has no direction in the picture at all, and its shell is
+             * a face-on ring around it there; the projection says so by
+             * coming out at nothing, and the fallback is the frame from the
+             * source, which is that ring.
+             */
+            let mx = 0, my = 0;
+
+            if (wp && ray.heading) {
+              const t = screenOf(wp.map((v, i) => v + (ray.heading![i] || 0) * LATTICE_STEP));
+
+              mx = t.x - p.x; my = t.y - p.y;
+            }
+
+            if (mx === 0 && my === 0 && ray.moving.target) {
+              const q = pts.get(ray.moving.target.at.node);
+
+              if (q && !q.clipped) { mx = q.x - p.x; my = q.y - p.y; }
+            }
+
+            const ml = Math.hypot(mx, my);
+
+            // Across the way it is going: the shoulders of its own shell.
+            let rx: number, ry: number;
+
+            if (ml > 1e-3) { rx = -my / ml; ry = mx / ml; }
+            else { rx = -oy; ry = ox; }
+
+            // Which is then remembered, so that the places between the
+            // charges can be given the same answer as the charges around
+            // them. See the doubled angle above.
+            {
+              const i0 = Math.min(Math.max(Math.round(cy), 0), rows - 1) * cols
+                + Math.min(Math.max(Math.round(cx), 0), cols - 1);
+
+              spinA[i0] += rx * rx - ry * ry;
+              spinB[i0] += 2 * rx * ry;
+              spinW[i0] += 1;
+            }
+
+            /**
+             * And it reaches no further along than there is arc to reach
+             * along.
+             *
+             * A band covers half a turn, so at radius r it is about πr long,
+             * and at one or two cells out that is shorter than the reach
+             * itself. Sweeping the full ellipse there does not join a shell
+             * to itself, it joins it right round to the next one — which is
+             * the opposite charge, and the two average away into the grey
+             * disc that the middle of these pictures kept coming out as.
+             *
+             * So the long axis is held to the arc it is supposed to be lying
+             * on. Far out that is the reach as given; close in it shrinks
+             * with the radius until the ellipse is barely longer than it is
+             * wide, which is right — near the source there are no gaps to
+             * close, the charges are on top of each other.
+             */
+            const reach = Math.max(Math.min(along, len * 0.8), across);
+            const span = Math.ceil(reach);
+
             for (let y = Math.max(Math.floor(cy - span), 0); y <= Math.min(Math.ceil(cy + span), rows - 1); y++) {
               for (let x = Math.max(Math.floor(cx - span), 0); x <= Math.min(Math.ceil(cx + span), cols - 1); x++) {
                 const dx = x - cx, dy = y - cy;
 
-                // Split into how far out and how far round, and measure each
-                // against its own reach.
-                const out2 = dx * ox + dy * oy;
-                const round2 = dx * -oy + dy * ox;
+                // Split into how far along the arm and how far off it, and
+                // measure each against its own reach.
+                const round2 = dx * rx + dy * ry;
+                const out2 = dx * -ry + dy * rx;
 
-                const d = Math.hypot(out2 / across, round2 / along);
+                const d = Math.hypot(out2 / across, round2 / reach);
                 if (d >= 1) continue;
 
                 // Smooth to nothing at the edge of its reach, so no charge
@@ -4606,11 +4871,41 @@ const GraphView = ({
 
               if (q && !q.clipped) {
                 const mx = (p.x + q.x) / 2 / CELL, my = (p.y + q.y) / 2 / CELL;
-                const bite = Math.max(across, 2);
+
+                /**
+                 * And what is put there is a seam, not a bite.
+                 *
+                 * The thing between two charges arriving at each other is an
+                 * interface — it has the two of them on either side of it and
+                 * it extends sideways, the way the two fronts do. Marked with
+                 * a disc instead, it takes a round hole out of whichever band
+                 * the pair happen to be sitting in, and a band with a dozen
+                 * such pairs along it is a band with a dozen holes punched
+                 * through it: the arm falls apart into the pieces between
+                 * them, and the pieces read as islands.
+                 *
+                 * Thin the way they are approaching and wide the way they are
+                 * not, it does the one thing it was for — the two of them end
+                 * up on opposite sides of a line — and it does not cost the
+                 * arm its continuity to do it.
+                 */
+                let jx = q.x - p.x, jy = q.y - p.y;
+                const jl = Math.hypot(jx, jy) || 1;
+
+                jx /= jl; jy /= jl;
+
+                const thin = Math.max(across / 4, 0.8);
+                const broad = Math.max(across, 2);
+                const bite = Math.ceil(broad);
 
                 for (let y = Math.max(Math.floor(my - bite), 0); y <= Math.min(Math.ceil(my + bite), rows - 1); y++) {
                   for (let x = Math.max(Math.floor(mx - bite), 0); x <= Math.min(Math.ceil(mx + bite), cols - 1); x++) {
-                    const d = Math.hypot(x - mx, y - my) / bite;
+                    const ex = x - mx, ey = y - my;
+
+                    const d = Math.hypot(
+                      (ex * jx + ey * jy) / thin,
+                      (ex * -jy + ey * jx) / broad,
+                    );
                     if (d >= 1) continue;
 
                     const k = (1 - d * d) ** 2;
@@ -4626,16 +4921,78 @@ const GraphView = ({
           }
         }
 
-        // How positive or negative each part of the picture is: +1 well
-        // inside an amber band, −1 well inside a cyan one, and nothing where
-        // no charge reaches or where the two meet.
+        /**
+         * And spread out over the places between them, so that the frame is
+         * something the whole picture has rather than something only the
+         * charges have.
+         *
+         * Averaged over about the width one charge speaks for, which is the
+         * distance at which two charges are meant to be part of the same
+         * thing anyway. Where a shell runs, its own members all say the same
+         * and the average is that; where two shells cross, they disagree and
+         * it comes out short, which is exactly a place with no one direction
+         * to it and is treated as one.
+         */
+        {
+          // Wide enough to have an answer in the gaps, which is where it is
+          // wanted: a place with no charge in it is the very place that needs
+          // to be told which way the thing running through it lies.
+          const smear = Math.max(Math.round(along * 0.6), 2);
+
+          box(spinA, smear);
+          box(spinB, smear);
+          box(spinW, smear);
+
+          for (let i = 0; i < runX.length; i++) {
+            const mag = Math.hypot(spinA[i], spinB[i]);
+
+            // Nothing said anything here, or what was said cancelled out.
+            // Both are the same answer: fall back to the shape of a shell
+            // around the nearest source, which is what a place with no
+            // direction of its own is nearest to being part of.
+            if (spinW[i] < 1e-4 || mag < spinW[i] * 0.15) {
+              runX[i] = -outY[i]; runY[i] = outX[i];
+              continue;
+            }
+
+            const a = 0.5 * Math.atan2(spinB[i], spinA[i]);
+
+            runX[i] = Math.cos(a); runY[i] = Math.sin(a);
+          }
+        }
+
+        /**
+         * How positive or negative each part of the picture is: +1 well
+         * inside an amber band, −1 well inside a cyan one, and nothing where
+         * no charge reaches or where the two meet.
+         *
+         * Divided by a little more than the weight actually there, which is
+         * the difference between how positive a place is and how sure of it
+         * the picture can be. Dividing by the weight exactly says a place
+         * with one charge in it is as wholly positive as a place with twenty
+         * — so a charge that has come adrift from everything, out ahead of
+         * its shell or left behind by it, reads at full strength and is
+         * traced as a little closed body of its own. Every one of those is an
+         * island, and they are the ones with nothing in them.
+         *
+         * The extra in the divisor is worth about a charge's own weight. One
+         * charge on its own then reads at a third of what a band reads, which
+         * is under the level anything is traced at, and it goes back to being
+         * what it is: a faint mark in the field rather than a body. Nothing
+         * is thrown away — twenty of them together still read as twenty, and
+         * a thin arm far out is still an arm. It is a preference for what is
+         * supported over what is isolated, applied to the reading rather than
+         * to the drawing.
+         */
+        const trust = 0.9;
+
         const target = new Float32Array(cols * rows);
         const known = new Uint8Array(cols * rows);
 
         for (let i = 0; i < target.length; i++) {
           if (weight[i] <= 0) continue;
 
-          target[i] = Math.max(Math.min(sum[i] / weight[i], 1), -1);
+          target[i] = Math.max(Math.min(sum[i] / (weight[i] + trust), 1), -1);
           known[i] = 1;
         }
 
@@ -4657,8 +5014,30 @@ const GraphView = ({
          * where it was. Only a few rings of it, so a genuinely empty part of
          * the world stays empty rather than being papered over.
          */
-        for (let pass = 0; pass < 5; pass++) {
+        /**
+         * And pressed a good deal further than a few rings, at the price of
+         * getting stricter about what counts as a gap.
+         *
+         * The two things it must not do are grow a band outwards into the
+         * empty space past the wavefront, and grow one band into the next.
+         * The second is already handled — disagreeing neighbours are refused
+         * below — and the first is what the small number of passes was really
+         * buying: an edge grows one ring per pass just as a hole fills one
+         * ring per pass, so the only thing keeping the outside of the picture
+         * from creeping outwards was stopping early, which also stopped every
+         * hole halfway through being mended.
+         *
+         * Told apart instead of traded off. A place inside a hole has known
+         * neighbours nearly all round it; a place just outside the edge of
+         * something has them on one side only. So the first few passes take
+         * anything with two — that is a crack one sample wide, and closing
+         * those is most of what closing is — and every pass after that wants
+         * three of four, which a hole has and an edge never does. Then the
+         * filling can run until it has nothing left to fill.
+         */
+        for (let pass = 0; pass < 16; pass++) {
           const grown: [number, number][] = [];
+          const need = pass < 3 ? 2 : 3;
 
           for (let y = 1; y + 1 < rows; y++) {
             for (let x = 1; x + 1 < cols; x++) {
@@ -4697,7 +5076,7 @@ const GraphView = ({
                */
               if (warm && cold) continue;
 
-              if (n >= 2) grown.push([i, total / n]);
+              if (n >= need) grown.push([i, total / n]);
             }
           }
 
@@ -4735,7 +5114,7 @@ const GraphView = ({
           eased[i] += (target[i] - eased[i]) * 0.2;
 
         /**
-         * And smoothed across itself before anything is traced from it.
+         * And smoothed along itself before anything is traced from it.
          *
          * The field is built by dropping a kernel at every charge, so it
          * carries the charges in it: little bumps where one landed, little
@@ -4744,13 +5123,23 @@ const GraphView = ({
          * out scalloped — which is not the shape of the arm, it is the shape
          * of the fact that it was measured at points.
          *
-         * A few passes of each sample settling towards the average of the
-         * ones around it takes that out. It is the same operation as the
-         * kernel and could be folded into it, but it is far cheaper here:
-         * spreading a wider kernel costs its area at every charge, while this
-         * costs four additions per sample however wide it ends up being. The
-         * arm is a band across many cells and survives it untouched; the
-         * bumps are one cell across and do not.
+         * A few passes of each sample settling towards the ones on either
+         * side of it takes that out. Which two are "on either side" is the
+         * whole question, and it is the same answer as everywhere else here:
+         * the ones further along the band, not the ones further out from the
+         * source. Settling towards the neighbours in every direction equally
+         * pulls each band towards the two of the other sign it lies between,
+         * so the alternation is worn down at exactly the rate the gaps in it
+         * are closed, and there is no number of passes that gets one without
+         * the other. Settling along the band only, the arm knits together
+         * down its own length and nothing at all happens across it.
+         *
+         * That is the preference, in one line: a place takes after what
+         * continues through it. A neck between two lumps of one arm has arm
+         * on both sides along the way it runs and fills in; a speck with
+         * nothing either side of it has nothing to take after and fades.
+         * Neither is decided in advance — it is read off which way the thing
+         * is going where it is.
          */
         // On a copy, never on the eased field itself: that one is carried
         // from frame to frame, and smoothing something that is then smoothed
@@ -4758,25 +5147,260 @@ const GraphView = ({
         // few seconds there would be nothing left of the field at all.
         const f = eased.slice();
 
-        const blur = (a: Float32Array, passes: number) => {
+        // The field between its samples, so a step of a fraction of one is a
+        // step rather than a rounding — the directions below are not the
+        // grid's and almost never land on it.
+        const sample = (a: Float32Array, x: number, y: number) => {
+          const px = Math.min(Math.max(x, 0), cols - 1);
+          const py = Math.min(Math.max(y, 0), rows - 1);
+
+          const x0 = Math.floor(px), y0 = Math.floor(py);
+          const x1 = Math.min(x0 + 1, cols - 1), y1 = Math.min(y0 + 1, rows - 1);
+          const fx = px - x0, fy = py - y0;
+
+          return (a[y0 * cols + x0] * (1 - fx) + a[y0 * cols + x1] * fx) * (1 - fy)
+            + (a[y1 * cols + x0] * (1 - fx) + a[y1 * cols + x1] * fx) * fy;
+        };
+
+        // One pass of it, in whichever of the two directions is asked for.
+        const drift = (a: Float32Array, passes: number, reach: number, round: boolean) => {
+          const next = new Float32Array(a.length);
+
           for (let pass = 0; pass < passes; pass++) {
-            for (let y = 1; y + 1 < rows; y++) {
-              for (let x = 1; x + 1 < cols; x++) {
+            for (let y = 0; y < rows; y++) {
+              for (let x = 0; x < cols; x++) {
                 const i = y * cols + x;
 
-                a[i] = (
-                  a[i] * 4
-                  + a[i - 1] + a[i + 1]
-                  + a[i - cols] + a[i + cols]
-                ) / 8;
+                // Held to the arm there is, close in, for the same reason the
+                // kernel's long axis is.
+                const r = round ? Math.min(reach, rad[i] * 0.5) : reach;
+
+                const dx = (round ? runX[i] : -runY[i]) * r;
+                const dy = (round ? runY[i] : runX[i]) * r;
+
+                next[i] = (
+                  a[i] * 2
+                  + sample(a, x + dx, y + dy)
+                  + sample(a, x - dx, y - dy)
+                ) / 4;
               }
             }
+
+            a.set(next);
           }
 
           return a;
         };
 
-        blur(f, 3);
+        drift(f, 10, 1.8, true);
+
+        /**
+         * Where the alternation actually is, before anything is done that
+         * could cost some of it.
+         *
+         * Everything from here on is one of two opposite pressures. Closing a
+         * gap wants a place to take after what is around it; keeping the
+         * winding wants a place to stay unlike what is around it. Applied at
+         * one strength everywhere, they are the beads-or-porridge choice
+         * again in a different guise, and whichever is turned up wrecks the
+         * half of the picture the other was for.
+         *
+         * But which of the two a place needs is a thing that can be looked
+         * at. Somewhere in the body of a band has one charge all round it out
+         * to the distance the bands repeat over; somewhere between two has
+         * both, in comparable amounts. So: how much of each is nearby, and
+         * how near they come to being equal.
+         *
+         * Measured on the field rather than assumed from the geometry, which
+         * matters where the geometry is not the whole story — near a source,
+         * where the arms have not separated yet, or out where two magnets'
+         * fields have run into each other and the alternation is nothing so
+         * tidy as one spiral's. Where there IS alternation it is protected,
+         * wherever it came from and whichever way round it lies. Where there
+         * is none, there is nothing to protect and the gaps can be closed as
+         * hard as it takes.
+         */
+        const alt = new Float32Array(f.length);
+
+        {
+          const warm = new Float32Array(f.length);
+          const cold = new Float32Array(f.length);
+
+          for (let i = 0; i < f.length; i++) {
+            warm[i] = Math.max(f[i], 0);
+            cold[i] = Math.max(-f[i], 0);
+          }
+
+          // Out to most of the way to the next band, which is the scale the
+          // question is being asked at. A cell either side finds alternation
+          // only where the two are already touching; two thirds of a band
+          // finds it while there is still something between them, which is
+          // while there is still something to keep.
+          const look = Math.max(Math.round(band / 2.2), 2);
+
+          box(warm, look);
+          box(cold, look);
+
+          for (let i = 0; i < f.length; i++) {
+            const lo = Math.min(warm[i], cold[i]);
+            const hi = Math.max(warm[i], cold[i]);
+
+            // Nothing at all nearby is not alternation; it is emptiness, and
+            // emptiness gets closed like anything else.
+            alt[i] = hi > 1e-3 ? Math.min((2 * lo) / (lo + hi) * 2.8, 1) : 0;
+          }
+        }
+
+        /**
+         * And then the gaps are bridged outright, rather than diffused shut.
+         *
+         * Smoothing along an arm closes a gap by moving what is on either
+         * side of it into the middle, which means the middle ends up weaker
+         * than either side — and a gap wide enough to be worth closing ends
+         * up filled with something under the level anything is traced at. The
+         * hole is smaller and blurrier and still a hole. Pushing the
+         * smoothing harder to get through it takes the arm's own strength
+         * down with it, because a diffusion cannot tell which of its
+         * neighbours it is supposed to be taking after.
+         *
+         * A gap is not an average, though. It is a place where something
+         * runs THROUGH — the arm arrives at one side of it and leaves from
+         * the other — and that is a thing to test for rather than to hope
+         * comes out of an average. So each place looks out along the band,
+         * both ways at once, for a distance the same charge is found in both
+         * directions, and takes the weaker of the two.
+         *
+         * Both ways at once is the whole of what makes it safe. A speck with
+         * nothing either side of it finds nothing that agrees and is left as
+         * it is; the far end of an arm finds arm behind it and empty space
+         * ahead and is not extended past where it ends; a seam between two
+         * bands has opposite signs across it and never had them along it, so
+         * it is not something this can reach through. Only a place with the
+         * same thing on both sides of it is filled, and a place with the same
+         * thing on both sides of it is the inside of an arm.
+         *
+         * Taking the weaker end rather than the stronger keeps it honest: a
+         * bridge is only ever as much as the thinner of the two things it
+         * joins, so a wisp joined to a bright arm does not come out bright.
+         *
+         * And the looking stops at the first thing of the other charge it
+         * meets, rather than running the whole way and asking about the far
+         * end. That is the one way this could do damage — a stripe of the
+         * other charge lying across the arm, with more arm beyond it, is two
+         * things with something between them and not one thing with a gap in
+         * it, and reaching over the stripe would paint it out. Stopped at it,
+         * the two sides come back disagreeing and nothing happens. So the
+         * alternation is not weighed against the closing here; it is simply
+         * in the way of it, which is what alternation ought to be.
+         */
+        /**
+         * And it is a preference for that direction, not a rule about it.
+         *
+         * A shell is not a perfect arc. It is a couple of dozen directions
+         * off a lattice, fanning as they go and passing through space that
+         * other charges have been eating, so the line through its members
+         * wanders by some tens of degrees from the one thing perpendicular to
+         * any one of them. Looking along a single exact direction, half the
+         * gaps in it are at an angle to what is being looked down and are
+         * missed — while looking down a wide fan of directions at once finds
+         * the next shell as readily as its own, which is the merge along the
+         * path that must not happen.
+         *
+         * So each pass looks slightly differently: straight across the path,
+         * then a little to one side of that, then a little to the other. A
+         * gap that lies square on is closed by the first and closed again by
+         * the other two; one on a slant is closed by whichever pass is
+         * pointing at it; nothing anywhere gets a look down the path itself,
+         * which is off the end of the fan in both directions. Preference by
+         * how much of the ink each direction gets, which is what a preference
+         * is, rather than by which directions exist.
+         */
+        const bridge = (a: Float32Array, taps: number, reach: number, tilt: number) => {
+          const next = a.slice();
+
+          // What counts as something rather than as the tail of something.
+          // Under the level anything is traced at, so a gap in an arm — which
+          // is by definition below that level — is still a gap to be crossed
+          // and not an obstacle to stop at.
+          const lip = 0.07;
+
+          // The strongest thing one way along the band, or whatever stopped
+          // us getting to it, and how far off that was. Answered into these
+          // rather than returned: it is called twice per sample of the
+          // picture and a pair of objects a sample is a great many objects.
+          let found = 0, at = 1;
+
+          const seek = (x: number, y: number, dx: number, dy: number) => {
+            found = 0; at = 1;
+
+            for (let t = 1; t <= taps; t++) {
+              const v = sample(a, x + dx * t, y + dy * t);
+
+              if (found !== 0 && v * found < 0 && Math.abs(v) > lip) break;
+              if (Math.abs(v) > Math.abs(found)) { found = v; at = t; }
+            }
+          };
+
+          for (let y = 0; y < rows; y++) {
+            for (let x = 0; x < cols; x++) {
+              const i = y * cols + x;
+
+              /**
+               * Softened, though not stopped, where the alternation is thick.
+               *
+               * The frame is least trustworthy exactly where it matters most
+               * — near a source, where the arms have not come apart yet, and
+               * out where two magnets' fields have run into each other — and
+               * there what lies "along" may well be the next band round. The
+               * test above catches that whenever the other charge is actually
+               * between the two, which is most of the time; this is for the
+               * rest of it. Not a veto, because a thin arm has the other
+               * charge close by on both sides of it by construction, and a
+               * thin arm is exactly the thing with the worst gaps in it.
+               */
+              const room = 1 - alt[i] * 0.9;
+
+              const r = Math.min(reach, Math.max(rad[i] * 0.5, 0.5));
+
+              const c = Math.cos(tilt), sn = Math.sin(tilt);
+              const dx = (runX[i] * c - runY[i] * sn) * r;
+              const dy = (runX[i] * sn + runY[i] * c) * r;
+
+              seek(x, y, dx, dy);
+              const fv = found, fat = at;
+
+              seek(x, y, -dx, -dy);
+              const bv = found, bat = at;
+
+              // Nothing runs through here.
+              if (fv * bv <= 0) continue;
+
+              const v = Math.abs(fv) < Math.abs(bv) ? fv : bv;
+
+              // Already at least this much of it, or of the other charge and
+              // meaning it — either way, not a gap.
+              if (Math.abs(v) <= Math.abs(a[i])) continue;
+              if (a[i] * v < 0 && Math.abs(a[i]) > lip) continue;
+
+              // And reaching costs something, so a gap is closed by what is
+              // just past it rather than by whatever is furthest away.
+              const far = Math.max(fat, bat) / taps;
+
+              next[i] = a[i] + (v * (1 - 0.22 * far) - a[i]) * room;
+            }
+          }
+
+          return next;
+        };
+
+        // Twice, which is not the same as once with twice the reach: what the
+        // first pass closes is arm by the time the second runs, so a run of
+        // gaps with slivers between them mends from both ends inwards rather
+        // than each gap having to be spanned in one go from whatever is left
+        // either side of it.
+        f.set(bridge(f, 9, 2.6, 0));
+        f.set(bridge(f, 9, 2.6, 0.42));
+        f.set(bridge(f, 9, 2.6, -0.42));
 
         /**
          * And the valley between two bands is deepened until it separates
@@ -4799,16 +5423,116 @@ const GraphView = ({
          * where they were and drives the gaps between them down through zero
          * — which is where a boundary is, so a boundary is what gets drawn,
          * and the two arms come apart into the two islands they are.
+         *
+         * Compared ACROSS itself, though, and not in the round. The gap that
+         * wants deepening is the one between one turn of the spiral and the
+         * next, and that is out from the source by construction. A round
+         * comparison finds a second kind of thin place the arm has — the neck
+         * where it happens to be narrow along its own length — and deepens
+         * that one too, which cuts the arm in half. Every island this used to
+         * make was made honestly, by a rule that could not tell the gap it
+         * was for from the arm it was cutting.
+         *
+         * And turned up where there is alternation to keep and down where
+         * there is not.
+         *
+         * Sharpening is a separator, and a separator applied where there is
+         * nothing to separate has only one thing left to do: find whatever is
+         * weakest in a body of one charge and drive it below the level, which
+         * is a hole opened in the middle of something solid. That is the same
+         * ink the bridge above just spent closing gaps, spent undoing it.
+         *
+         * Where the two charges genuinely lie against each other it is the
+         * whole reason there are two shapes in the picture instead of one, so
+         * there it goes harder than it did before. The two are not in
+         * competition once they are asked separately.
+         *
+         * And hardest of all where the change is ALONG the way the charges
+         * are going, which is the other half of the same preference the
+         * bridging is the first half of.
+         *
+         * A shell alternates with the shells in front of it and behind it,
+         * because those are the ones thrown off a moment earlier and a moment
+         * later, when the source was pointing somewhere else or had turned
+         * over. It does not alternate with itself. So a change of charge
+         * encountered by going along the path is the real thing, worth
+         * driving apart until it separates; one encountered by going across
+         * the path — round the shell — is more likely to be two arcs at
+         * different radii happening to pass, or the edge of a gap, and
+         * sharpening it is how a ring gets cut into beads.
+         *
+         * Which of the two it is, is the direction the field changes in,
+         * against the direction the charges here are travelling in. Squared,
+         * so it falls away smoothly rather than at some angle, and floored,
+         * because none of this is exact: a shell is a couple of dozen lattice
+         * directions and a change square across the path is only ever
+         * approximately square across it.
          */
-        const wide = blur(f.slice(), 9);
+        const wide = drift(f.slice(), 12, 2.0, false);
+        const before = f.slice();
+
+        for (let y = 0; y < rows; y++) {
+          for (let x = 0; x < cols; x++) {
+            const i = y * cols + x;
+
+            // Which way the field changes here.
+            const gx = before[y * cols + Math.min(x + 1, cols - 1)]
+              - before[y * cols + Math.max(x - 1, 0)];
+            const gy = before[Math.min(y + 1, rows - 1) * cols + x]
+              - before[Math.max(y - 1, 0) * cols + x];
+
+            const gl = Math.hypot(gx, gy);
+
+            // And which way the charges here are going, which is across the
+            // way their shell runs.
+            const mx = -runY[i], my = runX[i];
+
+            const par = gl > 1e-5 ? ((gx * mx + gy * my) / gl) ** 2 : 0;
+
+            // Between linear and squared: squared alone ignores everything
+            // but the thickest alternation, and half of what wants keeping
+            // here is the thin seam between two arcs that have nearly closed
+            // on each other — which is faint precisely because it is about to
+            // be lost, and is the last moment it can be saved.
+            const a2 = alt[i] * (0.4 + 0.6 * alt[i]);
 
-        for (let i = 0; i < f.length; i++)
-          f[i] = Math.max(Math.min(f[i] + (f[i] - wide[i]) * 1.6, 1), -1);
+            const gain = 0.3 + a2 * 5.2 * (0.35 + 0.65 * par);
+
+            f[i] = Math.max(Math.min(f[i] + (f[i] - wide[i]) * gain, 1), -1);
+          }
+        }
 
         // And nothing survives where two charges are about to meet: the field
         // there belongs to neither of them, because in a tick it will belong
         // to whatever they become.
-        for (let i = 0; i < f.length; i++) f[i] *= 1 - cut[i];
+        for (let i = 0; i < f.length; i++) f[i] *= 1 - cut[i] * 0.9;
+
+        /**
+         * And where the two charges lie against each other, both give ground.
+         *
+         * Everything above works on the field, and the field is traced at a
+         * level — so two bodies that meet cleanly are drawn with their
+         * outlines touching, one line doing for the pair of them, and what
+         * the eye gets is one shape with a crease in it. The alternation is
+         * there in the reading and gone from the picture.
+         *
+         * The last thing done, then, is the cheapest and the most direct:
+         * where the two are near equal, both are pushed back from zero by the
+         * same amount before the outlines are found. Neither loses anything
+         * to the other — the place they part is exactly where it was, since
+         * both give the same ground — and what opens between them is a
+         * channel of the width of what was given. Away from any seam it does
+         * nothing at all, because there is nothing there for both to be near.
+         *
+         * It is a drawing decision and says so: no charge has moved and no
+         * region has changed hands. Two things that touch are drawn as two
+         * things that touch, which is what they are.
+         */
+        for (let i = 0; i < f.length; i++) {
+          const give = alt[i] * 0.2;
+
+          f[i] = f[i] > 0 ? Math.max(f[i] - give, 0) : Math.min(f[i] + give, 0);
+        }
 
         // And the pulses they were emitted in, kept separately, so the grain
         // of the thing can be drawn under its shape.
@@ -5080,7 +5804,7 @@ const GraphView = ({
           return 0.08 + lift * lift * 0.92;
         };
 
-        for (const [level, tint] of [[0.22, "255,122,69"], [-0.22, "61,220,255"]] as [number, string][]) {
+        for (const [level, tint] of [[0.17, "255,122,69"], [-0.17, "61,220,255"]] as [number, string][]) {
           const runs = trace(level).map(raw => {
             const closed = Math.hypot(
               raw[0].x - raw[raw.length - 1].x, raw[0].y - raw[raw.length - 1].y,
@@ -5506,14 +6230,95 @@ const GraphView = ({
       raf = requestAnimationFrame(frame);
     }
 
-    // A still is drawn once here (and again whenever it is resized); only an
-    // animated view keeps a frame loop alive.
-    if (animate) raf = requestAnimationFrame(frame);
-    else draw();
+    /**
+     * And none of it happens at all while nobody is looking.
+     *
+     * A frame loop is a claim on the machine for as long as it is alive, and
+     * an article like this one is thirty-odd universes stacked up a page
+     * where at most two of them are on screen at a time. Left running, the
+     * twenty-eight that cannot be seen go on ticking, projecting every point
+     * they have, reconstructing a field over every sample of a canvas nobody
+     * is looking at, sixty times a second — which is most of the cost of the
+     * page spent on nothing, and it is the reason scrolling this article got
+     * slower the further down it went.
+     *
+     * So the loop is not merely paused off screen: it is not scheduled, and
+     * whatever the drawing was holding on to is dropped. What comes back
+     * when it returns is a new one — see `onVisible`, and what
+     * `CalculusPlayer` does with it.
+     *
+     * A margin, so that a view is running by the time it is looked at rather
+     * than starting the moment it is. Half a screen is enough at any speed a
+     * page is read at, and it costs nothing when it is wrong.
+     */
+    const start = () => {
+      if (raf) return;
+
+      last = performance.now();
+      raf = requestAnimationFrame(frame);
+    };
+
+    const stop = () => {
+      if (!raf) return;
 
-    return () => {
       cancelAnimationFrame(raf);
-      window.removeEventListener("resize", onResize);
+      raf = 0;
+    };
+
+    const show = (visible: boolean) => {
+      if (visible === seen) return;
+      seen = visible;
+
+      latest.current.onVisible?.(visible);
+
+      if (visible) {
+        resize();             // the pixels, given back below, taken again
+
+        if (animate) start();
+        else draw();          // a still, drawn the once, now that it is worth it
+        return;
+      }
+
+      stop();
+
+      // The field as drawn, which is the one thing this view keeps between
+      // frames. Everything else it allocates lives and dies inside a draw.
+      eased = null;
+
+      /**
+       * And the pixels, which are the larger half of it by some way.
+       *
+       * A canvas of this size on a display of this density is several
+       * megabytes of buffer, and there are thirty of them down the page —
+       * comfortably more than every universe on it put together. Clearing it
+       * frees nothing; the buffer is the same size empty. Setting it to no
+       * size at all is what hands it back, and asking for the size again is
+       * what takes it.
+       *
+       * The element's own layout is unaffected, since that comes from the
+       * style rather than from the attributes, so the box stays exactly where
+       * it was and exactly the size it was — which it has to, or the thing
+       * watching for it to come back on screen would have nothing to watch.
+       */
+      canvas.width = 0;
+      canvas.height = 0;
+    };
+
+    const watcher = typeof IntersectionObserver === "undefined"
+      ? undefined
+      : new IntersectionObserver(
+        entries => show(entries[entries.length - 1].isIntersecting),
+        { rootMargin: "50% 0px" },
+      );
+
+    // Nothing to watch with: the old behaviour, which is to run regardless.
+    if (watcher) watcher.observe(canvas);
+    else show(true);
+
+    return () => {
+      watcher?.disconnect();
+      stop();
+      window.removeEventListener("resize", onResizeIfSeen);
       // canvas.removeEventListener("wheel", onWheel);
       // canvas.removeEventListener("contextmenu", onContextMenu);
       // canvas.removeEventListener("mousedown", onMouseDown);
@@ -5540,11 +6345,27 @@ const CalculusPlayer = ({
 }: CalculusVisualizationProps) => {
   const [running, setRunning] = useState(autoplay);
 
-  // The live universe. Held in a ref rather than state because resetting
-  // swaps the whole graph out mid-animation-frame — the render loop reads it
-  // afresh every frame, so it picks the new one up without tearing down.
+  /**
+   * The live universe. Held in a ref rather than state because resetting
+   * swaps the whole graph out mid-animation-frame — the render loop reads it
+   * afresh every frame, so it picks the new one up without tearing down.
+   *
+   * And nothing at all while the view is off screen. A universe here is some
+   * thousands of points, each with twenty-six boundaries and a projection
+   * cached against it, and there are thirty of these on the page — so what
+   * is being held between the reader scrolling past a picture and scrolling
+   * back to it is tens of megabytes of a thing nobody can see. Dropped, it
+   * is a null and a re-seed.
+   *
+   * Which is not a loss of anything, because there is nothing here to lose.
+   * The dynamics are stochastic, and a repeating example throws its universe
+   * away and re-seeds every `cycle` ticks anyway: coming back to one of
+   * these is coming back to a fresh run whether it was let go of or not.
+   * Seeded lazily rather than eagerly for the same reason as everything else
+   * in this — thirty seeds built at mount is thirty universes' worth of work
+   * for the one or two that can be seen.
+   */
   const graphRef = useRef<Graph | null>(null);
-  if (!graphRef.current) graphRef.current = seed();
 
   // Ticks taken since the last reset, against which `repeated` is measured.
   const stepsRef = useRef(0);
@@ -5566,8 +6387,32 @@ const CalculusPlayer = ({
   // annihilation / turn-around / structure-absorption.
   const accum = useRef(0);
 
+  /**
+   * Made when it is first looked at, and let go of the moment it is not.
+   *
+   * Except when it is paused, which is the one case where the state on
+   * screen is something the reader chose. Stopping a run at a particular
+   * tick to look at it, scrolling a little too far, and coming back to a
+   * fresh one would be losing the thing they stopped for. A running view has
+   * no such state — it is somewhere in the middle of a loop that resets
+   * every `cycle` ticks regardless — so there is nothing to lose in letting
+   * it go, and coming back to it starts the run again from the top, which is
+   * where it wants to be watched from anyway.
+   */
+  const onVisible = (visible: boolean) => {
+    if (!visible) {
+      if (!running) return;
+
+      graphRef.current = null;
+      accum.current = 0;
+      return;
+    }
+
+    if (running || !graphRef.current) reset();
+  };
+
   const onFrame = (dt: number) => {
-    if (!running || !graphRef.current!.nodes.length) return;
+    if (!running || !graphRef.current?.nodes.length) return;
 
     accum.current += dt;
     while (accum.current >= interval) {
@@ -5583,7 +6428,14 @@ const CalculusPlayer = ({
 
   return <div>
     <div style={{ height }}>
-      <GraphView graph={() => graphRef.current!} animate density={density} mode={mode} onFrame={onFrame} />
+      <GraphView
+        graph={() => graphRef.current}
+        animate
+        density={density}
+        mode={mode}
+        onFrame={onFrame}
+        onVisible={onVisible}
+      />
     </div>
     <Row end="xs" className="child-px-2">
       {running
@@ -5903,6 +6755,9 @@ const MAGNET_CASES: {
   name: string, a?: number[], b?: number[],
   axis?: number[], spin?: boolean, alone?: boolean, turning?: 1 | -1,
   crossed?: boolean,
+  // Drawn as the field rather than pulse by pulse, which a turning source
+  // gets anyway. Said outright for anything else that wants the comparison.
+  asField?: boolean,
 }[] = [
   /**
    * One magnet, on its own, held still — and the answer to whether anything
@@ -6044,6 +6899,34 @@ const MAGNET_CASES: {
    */
   { name: 'one magnet, turning', axis: [1, 0, 0], spin: false, alone: true, turning: 1 },
 
+  /**
+   * The same source, and the same drawing, with the turning taken out.
+   *
+   * A control, and the only honest way to read the one above it. Everything
+   * that picture is claiming rests on the field being reconstructed from a
+   * few thousand points, and a reconstruction can be talked into almost any
+   * shape by what it was told to prefer — so a spiral coming out of it is
+   * worth exactly as much as the same machinery drawing something that is
+   * NOT a spiral when it is not given one.
+   *
+   * This is that. No axis, so the source has no sides and puts the same
+   * charge out in every direction at once; flipping in place rather than
+   * coming round, so every shell is the opposite of the one before it. What
+   * is there is rings: concentric, alternating, evenly spaced, and closed.
+   * The winding is the whole of the difference between the two, and it is a
+   * difference in what the sources are doing rather than in how either was
+   * drawn.
+   *
+   * The preference the drawing carries is a preference about NEIGHBOURS and
+   * not about shape — a charge belongs with the ones that left when it did,
+   * which lie across the way it is going, and not with the one in front of
+   * it, which is a different shell and as likely as not the other charge. Set
+   * that loose on a source that turns and the arcs it closes are rotated one
+   * from the next, which is a spiral. Set it loose on one that only flips and
+   * they are rings. Nothing in it knows which it is drawing.
+   */
+  { name: 'one source, not turning', alone: true, asField: true },
+
   /**
    * Two of them, turning opposite ways.
    *
@@ -6192,7 +7075,7 @@ const RayCalculiAndPhysics = () => {
             What is drawn is the structure rather than the coordinates, so
             space that has been annihilated out of the world is not a hole in
             the picture — it is two things that are now nearer each other. */}
-        {MAGNET_CASES.map(({ name, a, b, axis, spin: flipping = true, alone, turning, crossed }) => (
+        {MAGNET_CASES.map(({ name, a, b, axis, spin: flipping = true, alone, turning, crossed, asField }) => (
           <Fragment key={`magnets-${name}`}>
             {/* What the pair of runs is contrasting depends on what the
                 sources are doing. Flipping in place, it is whether they flip
@@ -6204,134 +7087,163 @@ const RayCalculiAndPhysics = () => {
               ? [{ name: 'turning the same way', phase: 0, sense: 1 },
                  { name: 'turning opposite ways', phase: 0, sense: -1 }]
               : flipping
-                ? MAGNET_SPINS.map(s => ({ ...s, sense: 1 }))
+                // Phase is one source's flip against the other's, so on its
+                // own there is nothing for it to be against and the two runs
+                // would be the same run twice.
+                ? alone
+                  ? [{ name: 'pulsing', phase: 0, sense: 1 }]
+                  : MAGNET_SPINS.map(s => ({ ...s, sense: 1 }))
                 : [{ name: 'held', phase: 0, sense: 1 }]
             ) as { name: string, phase: number, sense: 1 | -1 }[]).map(spin => (
               <div key={spin.name} style={{ marginBottom: '1.5rem' }}>
-                <CalculusVisualization
-                  graph={() => Graph.magnets(
-                    { emits: Polarity.Positive, moving: a, axis, turning },
-                    {
-                      emits: Polarity.Positive, moving: b, phase: spin.phase, axis,
-                      // The second one turning in a plane at right angles to
-                      // the first: x towards z rather than x towards y.
-                      plane: crossed
-                        ? [[1, 0, 0], [0, 0, 1]] as [number[], number[]]
-                        : undefined,
-                      // The second one comes round the other way when they
-                      // are set against each other.
-                      turning: turning ? (turning * spin.sense) as 1 | -1 : undefined,
-                    },
-                    {
-                      spin: flipping, alone,
-                      // A spiral is where each pulse went. Wandering is each
-                      // pulse going somewhere slightly else on the way, which
-                      // is exactly the information an arm is made of, rubbed
-                      // out — measurably: the distance out stops tracking how
-                      // long ago it left.
-                      wander: turning ? 0 : undefined,
-
-                      /**
-                       * One pulse per cell the wave advances, which for a
-                       * turning source means one every third tick.
-                       *
-                       * The two have to agree. Charges from a turning magnet
-                       * are held to a cell every third tick, so that the
-                       * magnet gets three eighths of a turn round between one
-                       * ring of the wave and the next and the winding is
-                       * tight. Emit every tick against that and the ring of
-                       * cells around the source has not cleared when the next
-                       * pulse is due: it goes out as one or two charges
-                       * instead of two dozen, and most of the shells are too
-                       * thin to be anything. Measured, that leaves gaps at
-                       * two thirds of the radii and under a full turn of
-                       * winding across the whole ball.
-                       *
-                       * Matched, every pulse leaves into empty space and
-                       * lands one cell further out than the one before, so
-                       * the ball is layered the whole way from the source to
-                       * the edge with a hundred and thirty-five degrees
-                       * between each layer and the next.
-                       */
-                      /**
-                       * Long enough that every direction has cleared, which
-                       * is set by the slowest of them.
-                       *
-                       * A step costs its own length, so a charge leaving
-                       * through a corner of its cell takes √3 times as long
-                       * to be gone as one leaving through a face. Emit again
-                       * before that and the corner directions are still
-                       * occupied by the last pulse: what goes out is the six
-                       * faces and a few edges — fourteen of the twenty-six —
-                       * and the shell has holes in it in exactly the
-                       * directions that were slowest, every time, in the same
-                       * places. Which is a spiral with pieces missing out of
-                       * it wherever the lattice is coarsest.
-                       *
-                       * Waiting the √3·3 ≈ 6 ticks a corner needs, every
-                       * pulse leaves whole. The wave advances two cells in
-                       * that time and the magnet turns three quarters of the
-                       * way round, so the pitch is what it was — an eighth of
-                       * a turn per third of a cell — with half as many shells
-                       * in the air, each of them entire.
-                       */
-                      // Every tick, like everything else here. A cell
-                      // emptied this tick is free the next, so the source is
-                      // never waiting on its own last pulse: a shell leaves
-                      // whole every tick, lands one cell further out than the
-                      // one before, and the magnet has turned an eighth of a
-                      // turn in between. The ball is layered the whole way
-                      // from the source to the edge, each layer rotated from
-                      // the one inside it, which is what a spiral is.
-                      every: undefined,
-
-                      /**
-                       * And fanning as early as it can, which is what closes
-                       * the gaps.
-                       *
-                       * A shell is the two dozen directions the source has,
-                       * and two dozen points spread over a sphere of radius
-                       * ten are nowhere near each other — the band they are
-                       * supposed to make is dots with holes between them, and
-                       * no amount of care in the drawing joins up something
-                       * that is not joined. Every charge fanning sideways
-                       * into the room around it as soon as it has any
-                       * multiplies each shell several times over, and it does
-                       * it where the gaps are: out at the far end, where a
-                       * shell has grown and its charges have drifted apart.
-                       */
-                      // Out where there is room for it, rather than at the
-                      // first opportunity. Fanning close in crowds the few
-                      // cells near the source and thickens the shells there
-                      // (measured: half again as thick, and half of
-                      // everything waiting to move); fanning out where a
-                      // shell has already grown puts the extra charges
-                      // exactly where the gaps between them have opened.
-                      fanAt: turning ? 5 : undefined,
-                    },
-                  )}
-                  repeated={60}
-                  // Said outright rather than left to follow from `repeated`,
-                  // which is what it defaults to: turn the repeat off to
-                  // watch one run go on indefinitely and the whole thing
-                  // silently stops autoplaying too, which looks exactly like
-                  // a universe in which nothing happens.
-                  autoplay
-                  height={320}
-                  interval={0.2}
-                  // A turning source lays down a spiral, and a spiral
-                  // belongs to a whole train of shells rather than to any one
-                  // of them — drawn pulse by pulse it is a stack of lobes and
-                  // the winding is nowhere. Everything else is a source that
-                  // emits the same thing in every direction, where the pulse
-                  // IS the object and the shells say it best.
-                  mode={turning ? "field" : "shells"}
-                  // The glow is a sum over every charge, and with a pulse
-                  // going out every tick that is most of the ball — one even
-                  // wash, hiding the shells it is drawn from.
-                  density={false}
-                />
-                <Caption>{name} — {spin.name}</Caption>
+                {/* Flat and round, one under the other.
+
+                    The turn is flat: the axis comes round in a plane and
+                    never leaves it, so everything these arrangements do
+                    happens in that plane and the third dimension only offers
+                    the rest of a sphere for the same arms to be looked at
+                    through. Which makes the 3D picture a projection of the 2D
+                    one with a great deal of unrelated ball laid over it —
+                    every part of the space that is neither in front of an arm
+                    nor behind it, drawn at the same time as the arm.
+
+                    So the flat one is the picture of the thing, and the round
+                    one is the picture of the thing plus the depth it was seen
+                    through. Read together they say which of the two the
+                    features belong to: what is in both is the arrangement,
+                    and what is only in the round one is the embedding. */}
+                {[2, 3].map(dims => (
+                <Fragment key={dims}>
+                  <CalculusVisualization
+                    graph={() => Graph.magnets(
+                      { emits: Polarity.Positive, moving: a, axis, turning },
+                      {
+                        emits: Polarity.Positive, moving: b, phase: spin.phase, axis,
+                        // The second one turning in a plane at right angles to
+                        // the first: x towards z rather than x towards y.
+                        plane: crossed
+                          ? [[1, 0, 0], [0, 0, 1]] as [number[], number[]]
+                          : undefined,
+                        // The second one comes round the other way when they
+                        // are set against each other.
+                        turning: turning ? (turning * spin.sense) as 1 | -1 : undefined,
+                      },
+                      {
+                        spin: flipping, alone,
+                        // A spiral is where each pulse went. Wandering is each
+                        // pulse going somewhere slightly else on the way, which
+                        // is exactly the information an arm is made of, rubbed
+                        // out — measurably: the distance out stops tracking how
+                        // long ago it left.
+                        wander: turning || asField ? 0 : undefined,
+
+                        /**
+                         * One pulse per cell the wave advances, which for a
+                         * turning source means one every third tick.
+                         *
+                         * The two have to agree. Charges from a turning magnet
+                         * are held to a cell every third tick, so that the
+                         * magnet gets three eighths of a turn round between one
+                         * ring of the wave and the next and the winding is
+                         * tight. Emit every tick against that and the ring of
+                         * cells around the source has not cleared when the next
+                         * pulse is due: it goes out as one or two charges
+                         * instead of two dozen, and most of the shells are too
+                         * thin to be anything. Measured, that leaves gaps at
+                         * two thirds of the radii and under a full turn of
+                         * winding across the whole ball.
+                         *
+                         * Matched, every pulse leaves into empty space and
+                         * lands one cell further out than the one before, so
+                         * the ball is layered the whole way from the source to
+                         * the edge with a hundred and thirty-five degrees
+                         * between each layer and the next.
+                         */
+                        /**
+                         * Long enough that every direction has cleared, which
+                         * is set by the slowest of them.
+                         *
+                         * A step costs its own length, so a charge leaving
+                         * through a corner of its cell takes √3 times as long
+                         * to be gone as one leaving through a face. Emit again
+                         * before that and the corner directions are still
+                         * occupied by the last pulse: what goes out is the six
+                         * faces and a few edges — fourteen of the twenty-six —
+                         * and the shell has holes in it in exactly the
+                         * directions that were slowest, every time, in the same
+                         * places. Which is a spiral with pieces missing out of
+                         * it wherever the lattice is coarsest.
+                         *
+                         * Waiting the √3·3 ≈ 6 ticks a corner needs, every
+                         * pulse leaves whole. The wave advances two cells in
+                         * that time and the magnet turns three quarters of the
+                         * way round, so the pitch is what it was — an eighth of
+                         * a turn per third of a cell — with half as many shells
+                         * in the air, each of them entire.
+                         */
+                        // Every tick, like everything else here. A cell
+                        // emptied this tick is free the next, so the source is
+                        // never waiting on its own last pulse: a shell leaves
+                        // whole every tick, lands one cell further out than the
+                        // one before, and the magnet has turned an eighth of a
+                        // turn in between. The ball is layered the whole way
+                        // from the source to the edge, each layer rotated from
+                        // the one inside it, which is what a spiral is.
+                        every: undefined,
+
+                        /**
+                         * And fanning as early as it can, which is what closes
+                         * the gaps.
+                         *
+                         * A shell is the two dozen directions the source has,
+                         * and two dozen points spread over a sphere of radius
+                         * ten are nowhere near each other — the band they are
+                         * supposed to make is dots with holes between them, and
+                         * no amount of care in the drawing joins up something
+                         * that is not joined. Every charge fanning sideways
+                         * into the room around it as soon as it has any
+                         * multiplies each shell several times over, and it does
+                         * it where the gaps are: out at the far end, where a
+                         * shell has grown and its charges have drifted apart.
+                         */
+                        // Out where there is room for it, rather than at the
+                        // first opportunity. Fanning close in crowds the few
+                        // cells near the source and thickens the shells there
+                        // (measured: half again as thick, and half of
+                        // everything waiting to move); fanning out where a
+                        // shell has already grown puts the extra charges
+                        // exactly where the gaps between them have opened.
+                        fanAt: turning || asField ? 5 : undefined,
+
+                        dims,
+                      },
+                    )}
+                    repeated={60}
+                    // Said outright rather than left to follow from `repeated`,
+                    // which is what it defaults to: turn the repeat off to
+                    // watch one run go on indefinitely and the whole thing
+                    // silently stops autoplaying too, which looks exactly like
+                    // a universe in which nothing happens.
+                    autoplay
+                    height={320}
+                    interval={0.2}
+                    // A turning source lays down a spiral, and a spiral
+                    // belongs to a whole train of shells rather than to any one
+                    // of them — drawn pulse by pulse it is a stack of lobes and
+                    // the winding is nowhere. Everything else is a source that
+                    // emits the same thing in every direction, where the pulse
+                    // IS the object and the shells say it best.
+                    mode={turning || asField ? "field" : "shells"}
+                    // The glow is a sum over every charge, and with a pulse
+                    // going out every tick that is most of the ball — one even
+                    // wash, hiding the shells it is drawn from.
+                    density={false}
+                  />
+                  <Caption>
+                    {name} — {spin.name}, {dims === 2 ? 'flat' : 'in three dimensions'}
+                  </Caption>
+                </Fragment>
+                ))}
               </div>
             ))}
           </Fragment>

From 7c67913ac78859e219251ff677f0a4ae68926cb7 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Fri, 7 Aug 2026 18:47:07 +0200
Subject: [PATCH 12/47] First attempt at a continous implementation

---
 .../archive/2026.RayCalculiAndPhysics.tsx     | 2368 +++++++++++++++--
 1 file changed, 2203 insertions(+), 165 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index 863359a..86f018c 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -1268,11 +1268,47 @@ class Graph {
     // something else has just put down on its way out.
     const there = vacated.get(nd) ?? this.gridPos.get(nd);
 
-    // What lies beyond it the way we are going — carrying on, rather than
-    // across. Our own direction of travel is rewired onto that, so the line
-    // we are moving along stays a line.
+    /**
+     * What lies beyond it the way we are going — carrying on, rather than
+     * across. Our own direction of travel is rewired onto that, so the line
+     * we are moving along stays a line.
+     *
+     * And this is where gravity is, which is worth saying plainly because
+     * nothing here looks like it.
+     *
+     * "The way we are going" is not a remembered vector. It is `dir`, the
+     * direction of the connection we are moving along, measured between the
+     * two points it currently joins — so it is a fact about the lattice as it
+     * stands rather than about where we set out. What continues it is
+     * likewise chosen from the connections the point ahead actually has, now.
+     * Nothing in this reads an absolute frame, and nothing in it remembers
+     * anything.
+     *
+     * So when an annihilation somewhere nearby splices two points together
+     * that were not joined before, the fan of directions at this point is a
+     * different fan, and the best continuation of our line is a connection
+     * that was not there and does not lead where the old one led. The ray
+     * does exactly what it always does — carry on — and arrives somewhere it
+     * would not have. That is a path bending with nothing bending it, which
+     * is the whole of what a geodesic is.
+     *
+     * What used to prevent it was asking for a continuation within about
+     * twenty-five degrees of dead ahead, and taking nothing at all otherwise.
+     * That is a fine rule in a lattice that is still square, and it is
+     * precisely wrong where one is not: exactly where the space has been bent
+     * by an annihilation, the ray would find nothing straight enough, give up
+     * its line, and either stop having a direction or walk out of a bare one.
+     * The deflection was there to be had and was being thrown away for not
+     * being small.
+     *
+     * Best available, then, and forwards. A ray follows the straightest thing
+     * this point has got, whatever that has become — which in flat lattice is
+     * the same connection it would have taken anyway, and near a collision is
+     * the one that has been moved.
+     */
     let onward: Boundary | undefined;
     let onwardStep: number[] | undefined;
+    let straightest = 0;
 
     for (const other of nd) {
       for (const bd of other.boundaries) {
@@ -1281,10 +1317,15 @@ class Graph {
         const d = this.direction(bd);
         if (!d || !dir) continue;
 
-        if (d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0) > 0.9) {
-          onward = bd;
-          onwardStep = this.bare(bd);
-        }
+        const dot = d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
+
+        // Forwards, at least. A connection at right angles or behind is not a
+        // continuation of anything, it is a different journey.
+        if (dot <= straightest) continue;
+
+        straightest = dot;
+        onward = bd;
+        onwardStep = this.bare(bd);
       }
     }
 
@@ -3784,6 +3825,38 @@ export interface CalculusVisualizationProps {
  * exactly once, with the camera snapped straight to its target orientation
  * rather than eased into it, since there are no later frames to ease over.
  */
+/**
+ * Runs something while an element is worth drawing, and stops it when it is
+ * not.
+ *
+ * An article like this one is thirty-odd universes stacked up a page, of
+ * which at most two are on screen. Every one of them left running is a frame
+ * loop, a tick, and a canvas the size of the viewport being filled sixty
+ * times a second for nobody — which is most of what the page costs, and the
+ * reason it got slower the further down it went.
+ *
+ * A margin, so that a view is going by the time it is looked at rather than
+ * starting the moment it is: half a screen is enough at any speed a page is
+ * read at, and costs nothing when it turns out to be wrong.
+ */
+const whileOnScreen = (el: Element, show: (visible: boolean) => void) => {
+  if (typeof IntersectionObserver === "undefined") {
+    // Nothing to watch with: the old behaviour, which is to run regardless.
+    show(true);
+
+    return () => { };
+  }
+
+  const watcher = new IntersectionObserver(
+    entries => show(entries[entries.length - 1].isIntersecting),
+    { rootMargin: "50% 0px" },
+  );
+
+  watcher.observe(el);
+
+  return () => watcher.disconnect();
+};
+
 const GraphView = ({
   graph: current,
   animate = false,
@@ -6304,19 +6377,10 @@ const GraphView = ({
       canvas.height = 0;
     };
 
-    const watcher = typeof IntersectionObserver === "undefined"
-      ? undefined
-      : new IntersectionObserver(
-        entries => show(entries[entries.length - 1].isIntersecting),
-        { rootMargin: "50% 0px" },
-      );
-
-    // Nothing to watch with: the old behaviour, which is to run regardless.
-    if (watcher) watcher.observe(canvas);
-    else show(true);
+    const unwatch = whileOnScreen(canvas, show);
 
     return () => {
-      watcher?.disconnect();
+      unwatch();
       stop();
       window.removeEventListener("resize", onResizeIfSeen);
       // canvas.removeEventListener("wheel", onWheel);
@@ -6503,198 +6567,2152 @@ const CalculusVisualization = ({ filmstrip, ...props }: CalculusVisualizationPro
     ? <CalculusFilmstrip {...props} />
     : <CalculusPlayer {...props} />;
 
-// The four states one end of a two-point universe can be in: its polarity,
-// and whether its ray moves into the connection or away from it.
-const SIDE_STATES: PairSide[] = [
-  { polarity: Polarity.Positive, moving: 'towards' },
-  { polarity: Polarity.Positive, moving: 'away' },
-  { polarity: Polarity.Negative, moving: 'towards' },
-  { polarity: Polarity.Negative, moving: 'away' },
-];
+/**
+ * The whole of it as one expression, which is the other way of having it.
+ *
+ * Everything above is the model run: a few thousand points, each one moved
+ * or not moved by a rule that looks only at its neighbours, and a picture
+ * reconstructed afterwards from where they all ended up. That is the honest
+ * order to do it in — the rules are the claim, and the shape is whatever
+ * comes out of them — but it is expensive twice over. Once in the running,
+ * and once in the reading: a field made of points has to be turned back into
+ * a field, and every choice in that reconstruction is a chance to draw
+ * something the rules did not say.
+ *
+ * There is a second way, available only once you already know what the rules
+ * make, and it is worth having precisely because it is derived rather than
+ * assumed. A source at the origin turning at ω radians a tick, emitting the
+ * charge of whichever pole faces a direction, and a wave that travels one
+ * cell a tick. Then the charge at distance r in direction θ at time t is the
+ * charge that left the source r ticks ago, when its axis pointed at
+ * α + ω(t − r) rather than at α + ωt. So the field is
+ *
+ *     F(r, θ, t) = cos( lobes·θ − ω·(t − r) − α )
+ *
+ * and there is nothing else to it. No points, no reconstruction, no
+ * neighbours to decide between: at any place and any moment the answer is
+ * one cosine, and the picture is that cosine evaluated at every pixel.
+ *
+ * `lobes` is the only thing that separates the two cases in this article, and
+ * it is not a parameter so much as a question about the source. One: it has
+ * an axis, so what it emits depends on the direction — the field carries a θ
+ * in it, the zero set is θ = ω(t − r) + const, and that is an Archimedean
+ * spiral. Nought: it has no sides, so direction drops out altogether, the
+ * zero set is r = t − const, and that is a set of rings travelling outward.
+ * A spiral and a ring are the same function with and without an angle in it,
+ * which is what it means to say the difference between the two sources is
+ * that one turns and the other only flips.
+ *
+ * Several of them add. That is a claim rather than a definition, and it is
+ * the one place this parts company with the model above: charges there do
+ * not superpose, they meet and annihilate. But annihilation IS what addition
+ * does to two opposite numbers, and the thing that survives it — the region
+ * where one charge is left over — is what a sum of cosines has where they do
+ * not cancel. So it is the right continuous shadow of a discrete rule, and
+ * the places where the two disagree are exactly the places worth looking at.
+ */
+const LIGHT = 1;                                  // cells a wave goes in a tick
 
-// Every combination of those two ends. `j >= i` drops mirror images — a
-// universe and its left-right reflection run identically, so listing both
-// would only duplicate the same experiment. Drop the slice for all 16.
-const PAIRS: { a: PairSide, b: PairSide }[] = SIDE_STATES.flatMap((a, i) =>
-  SIDE_STATES.slice(i).map(b => ({ a, b }))
-);
+type Emitter = {
+  // Where it is, in cells.
+  at: [number, number];
 
-type Pair = { a: PairSide, b: PairSide };
+  // One if it has an axis and so has sides; nought if it puts out the same
+  // thing in every direction at once.
+  lobes: 0 | 1;
 
-// Identity of a pair up to mirroring: whichever ordering of its two ends
-// sorts first, since a universe and its reflection are the same experiment.
-const pairKey = ({ a, b }: Pair) => {
-  const end = (s: PairSide) => `${s.polarity}${s.moving}`;
-  const [x, y] = [`${end(a)}|${end(b)}`, `${end(b)}|${end(a)}`];
-  return x < y ? x : y;
-};
+  // Radians of pattern per tick, signed. Which way round it turns, for a
+  // source with sides; how fast it flips over, for one without.
+  omega: number;
 
-// The anti-universe: every polarity flipped, every movement direction kept.
-const anti = ({ a, b }: Pair): Pair => {
-  const flip = (s: PairSide): PairSide => ({
-    polarity: s.polarity === Polarity.Positive ? Polarity.Negative : Polarity.Positive,
-    moving: s.moving,
-  });
+  // Where in the cycle it starts, which is the only thing one source can be
+  // against another.
+  phase: number;
 
-  return { a: flip(a), b: flip(b) };
+  /**
+   * How it is already going, in cells a tick, and it keeps going that way.
+   *
+   * There is no force in this model and so there is nothing for a velocity to
+   * be changed BY. A source that was set moving carries on moving, at the one
+   * speed its mass allows, in the direction it was sent; nothing here
+   * accelerates anything, and nothing here can slow anything down. What
+   * happens to a pair with momentum is not that they are pulled off course —
+   * it is that the space they are crossing goes on being eaten while they
+   * cross it, so the two end up closer together than their courses would have
+   * left them, without either having gone anywhere it was not already going.
+   *
+   * Which is a strange enough thing to be worth watching, and is the whole
+   * reason for these cases. An orbit that comes out of this is not a balance
+   * of a pull against an inertia. It is a drift that keeps carrying the two
+   * sideways while the gap between them keeps shortening underneath.
+   */
+  drift?: [number, number];
+
+  /**
+   * Ticks between one pulse and the next, or nothing for a source whose
+   * emission is continuous.
+   *
+   * The cases above emit without pause: the cosine is defined everywhere, so
+   * every point in the field is carrying something and there are no shells,
+   * only a phase that varies. That is the smooth reading of the model and it
+   * is a fair one, but it hides the thing the lattice version makes obvious —
+   * that what is emitted is a shell, that shells are discrete, and that
+   * annihilation is one of them meeting one of them.
+   *
+   * Given a beat, the emission becomes a train: a pulse leaves at every
+   * multiple of it and nothing leaves in between, so what travels out is a
+   * set of rings with space between them rather than a filled field. Which
+   * changes the arithmetic of the eating, and changes it in the direction
+   * that matters. Two sources pulsing every tick have a meeting every tick;
+   * two pulsing every OTHER tick have a meeting every other tick, so the gap
+   * between them goes at half the rate while their courses carry them along
+   * at exactly the speed they did. Moving as fast and eating half as quickly
+   * is the difference between a pair that is captured and a pair that has
+   * time to get somewhere first.
+   */
+  beat?: number;
 };
 
-// Pairs grouped with their own anti-pair, so the two sit one above the other.
-// Head-on opposite polarities (and away-from-each-other opposite polarities)
-// are their own anti up to mirroring, so those groups hold a single pair.
-const ANTI_GROUPS: Pair[][] = (() => {
-  const byKey = new Map(PAIRS.map(p => [pairKey(p), p]));
-  const taken = new Set<string>();
-  const groups: Pair[][] = [];
+// How wide a pulse is, in ticks — so a ring is about this many cells thick to
+// either side of where its front is.
+const PULSE = 0.5;
 
-  for (const pair of PAIRS) {
-    const key = pairKey(pair);
-    if (taken.has(key)) continue;
-    taken.add(key);
+/**
+ * As fast as a source goes, and here it goes almost as fast as anything can.
+ *
+ * One step a tick is this model's ceiling — a ray moves at most once per tick,
+ * so nothing outruns the wave it emits — and mass is the only thing that
+ * keeps anything under it: a step costs a source `MAGNET_MASS`, a tick pays
+ * one, so a heavy source crawls. Set to within a percent of the ceiling
+ * instead, these are as light as a thing can be and still be a thing.
+ *
+ * Not a percent short for safety's sake. At the ceiling exactly, everything a
+ * source ever emitted in the direction it is going arrives at the same
+ * moment, and the retarded time ahead of it stops having one answer — that is
+ * a real feature of moving at the speed of your own light and not a numerical
+ * complaint, but it is also the point past which nothing can be drawn,
+ * because what is being asked for is not a number. A percent under, the
+ * pile-up ahead is a hundredfold compression, which is a great deal to look
+ * at and is still a finite thing.
+ */
+const PACE = 0.5 * LIGHT;
 
-    const group = [pair];
 
-    const opposite = pairKey(anti(pair));
-    if (!taken.has(opposite) && byKey.has(opposite)) {
-      taken.add(opposite);
-      group.push(byKey.get(opposite)!);
-    }
 
-    groups.push(group);
-  }
+/**
+ * A source as it currently stands, and everywhere it has been.
+ *
+ * The past is not optional here. What is at distance r left r ticks ago, from
+ * wherever the source was then — so a ring already in the air belongs to a
+ * place, and that place does not move again however the thing that made it
+ * carries on. Once these start eating they travel at half of light, and a
+ * ring emitted twenty ticks ago is centred ten cells from where its source
+ * now is; drawn from the present position instead, the whole field is hauled
+ * about every time the speed changes, which is every frame, and what should
+ * be a stack of settled layers becomes one object flapping.
+ *
+ * So it is remembered rather than extrapolated, at a couple of samples a
+ * tick, which is finer than anything in the picture varies over.
+ */
+const TRAIL = 0.5;                                // ticks between remembered places
 
-  return groups;
-})();
+type Live = Emitter & {
+  // x then y, one pair per TRAIL of t, from the beginning of the run.
+  path: number[];
 
-// The same four states a side of a pair can be in, named against the line
-// rather than against a partner.
-const LINE_STATES: LineSide[] = [
-  { polarity: Polarity.Positive, moving: 'right' },
-  { polarity: Polarity.Positive, moving: 'left' },
-  { polarity: Polarity.Negative, moving: 'right' },
-  { polarity: Polarity.Negative, moving: 'left' },
-];
+  // How it is going now, which starts as its `drift` and is then turned by
+  // the space it is going through. Nothing ever changes its SPEED; see the
+  // flow below.
+  vel: [number, number];
+};
 
-// Every arrangement of n charges in a row: each of them either polarity, each
-// of them going either way. 4ⁿ of them before the symmetries are taken out.
-const linesOf = (n: number): LineSide[][] =>
-  n === 0
-    ? [[]]
-    : linesOf(n - 1).flatMap(rest => LINE_STATES.map(side => [side, ...rest]));
+// The corner and spacing of the grid every shadow is sampled on, which is the
+// survey's grid — they are the same question asked at the same places.
+let GRID = 0, GRID_X = 0, GRID_Y = 0, GRID_STEP = 1;
 
-// Read back to front with every direction reversed, a line is the same
-// experiment watched from the other end.
-const mirrored = (line: LineSide[]): LineSide[] =>
-  [...line].reverse().map(s => ({
-    polarity: s.polarity,
-    moving: s.moving === 'left' ? 'right' : 'left',
-  }));
+// Where it was at a given moment, and how fast it was going then. Between
+// samples, and before the run began, the nearest thing it can honestly say.
+const RETARD: [number, number] = [0, 0];
+const CARRY: [number, number] = [0, 0];
 
-const opposite = (p: Polarity): Polarity =>
-  p === Polarity.Positive ? Polarity.Negative : Polarity.Positive;
+// Which way the thing `emit` just reported on is going.
+const WAY: [number, number] = [0, 0];
 
-// Every polarity flipped, every direction kept: the anti-line.
-const antiLine = (line: LineSide[]): LineSide[] =>
-  line.map(s => ({ polarity: opposite(s.polarity), moving: s.moving }));
+const was = (s: Live, when: number) => {
+  const last = s.path.length / 2 - 1;
+  const k = Math.min(Math.max(when / TRAIL, 0), last);
 
-// Identity up to mirroring: whichever way round the line reads first.
-const lineKey = (line: LineSide[]): string => {
-  const read = (l: LineSide[]) => l.map(s => `${s.polarity}${s.moving}`).join(",");
-  const [x, y] = [read(line), read(mirrored(line))];
+  const i = Math.floor(k), j = Math.min(i + 1, last);
+  const f = k - i;
 
-  return x < y ? x : y;
+  RETARD[0] = s.path[2 * i] * (1 - f) + s.path[2 * j] * f;
+  RETARD[1] = s.path[2 * i + 1] * (1 - f) + s.path[2 * j + 1] * f;
+};
+
+const wasGoing = (s: Live, when: number) => {
+  was(s, when);
+
+  const ax = RETARD[0], ay = RETARD[1];
+
+  was(s, when - TRAIL);
+
+  CARRY[0] = (ax - RETARD[0]) / TRAIL;
+  CARRY[1] = (ay - RETARD[1]) / TRAIL;
+
+  RETARD[0] = ax; RETARD[1] = ay;
 };
 
 /**
- * The distinct lines among the given ones, each grouped with its anti-line so
- * the two sit one above the other — the same experiment run on matter and on
- * antimatter. A line that is its own anti up to mirroring is a group of one.
+ * When what is at a point now left the source that made it.
+ *
+ * The retarded time is the root of |x − p(te)| = t − te, and how it is found
+ * matters entirely at these speeds. The obvious way — guess r from where the
+ * source is now, look up where it was that long ago, measure again — walks
+ * towards the answer, and how fast it walks is exactly the source's speed:
+ * each round takes off a fraction v of what is left. At a third of light that
+ * is three good rounds and done. At ninety-nine hundredths it is six hundred,
+ * which is not a thing that can be done once per source per sample of a
+ * picture, sixty times a second.
+ *
+ * So it is solved rather than approached. Over the short stretch of trail the
+ * answer lies in, the source is going in a straight line at a steady rate,
+ * and for a straight line the equation is a quadratic in te and can simply be
+ * written down. Two rounds of that — one to find roughly where to look, one
+ * to solve properly with the velocity found there — lands on the answer
+ * regardless of how near the ceiling the thing is travelling.
+ *
+ * The position is then read from the trail rather than from the straight
+ * line, so the answer is still a record of where the source actually was.
+ * Nothing already emitted moves, which was the whole reason for keeping a
+ * trail; the straight line is only ever used to work out WHEN to look.
  */
-const antiGroups = (lines: LineSide[][]): LineSide[][][] => {
-  const byKey = new Map<string, LineSide[]>();
-  for (const line of lines) {
-    const key = lineKey(line);
-    if (!byKey.has(key)) byKey.set(key, line);
-  }
+const retard = (s: Live, x: number, y: number, t: number) => {
+  let te = t - Math.hypot(x - s.at[0], y - s.at[1]) / LIGHT;
 
-  const taken = new Set<string>();
-  const groups: LineSide[][][] = [];
+  /**
+   * Two passes, and the second one earned rather than assumed.
+   *
+   * The quadratic below is exact for a source going in a straight line at a
+   * steady rate — but the FIRST guess it starts from is taken from where the
+   * source is now, and for one travelling at ninety-nine hundredths of the
+   * speed of its own light that guess can be most of the picture out. The
+   * velocity then gets looked up at the wrong moment, the quadratic is solved
+   * for the wrong straight line, and the answer is wrong by however far the
+   * source moved in between. Which is not a small error politely spread
+   * about: it is a radius, so it comes out as rings in the wrong place, and
+   * they go wrong only where the source has been quick, which is why it looks
+   * like something tearing rather than something blurred.
+   *
+   * A second pass starts from an answer that is already close and settles it.
+   * Standing still, though, the first pass is exact and the second is a
+   * measurement of nothing — so it is skipped, which is most of the time in
+   * most of these pictures.
+   */
+  for (let pass = 0; pass < 2; pass++) {
+    wasGoing(s, te);
 
-  for (const [key, line] of byKey) {
-    if (taken.has(key)) continue;
-    taken.add(key);
+    if (pass > 0 && Math.abs(CARRY[0]) + Math.abs(CARRY[1]) < 1e-6) break;
 
-    const group = [line];
+    const ex = x - RETARD[0], ey = y - RETARD[1];
+    const vx = CARRY[0], vy = CARRY[1];
 
-    const opposite = lineKey(antiLine(line));
-    if (!taken.has(opposite) && byKey.has(opposite)) {
-      taken.add(opposite);
-      group.push(byKey.get(opposite)!);
+    // How long there is between te and now, which is what the light has to
+    // cover — less however much further back the answer turns out to be.
+    const a = t - te;
+
+    const A = vx * vx + vy * vy - LIGHT * LIGHT;
+    const B = 2 * (a * LIGHT * LIGHT - (ex * vx + ey * vy));
+    const C = ex * ex + ey * ey - a * a * LIGHT * LIGHT;
+
+    let step = 0;
+
+    if (Math.abs(A) < 1e-9) {
+      if (Math.abs(B) > 1e-9) step = -C / B;
+    } else {
+      const disc = B * B - 4 * A * C;
+      if (disc < 0) break;
+
+      /**
+       * Solved the stable way, which at these speeds is not a nicety.
+       *
+       * A is v² − 1, and a source travelling at ninety-nine hundredths of
+       * light makes that about a fiftieth. Dividing by it is the textbook
+       * formula and it is exactly where the textbook formula falls apart:
+       * one of the two roots comes out as a small difference of two nearly
+       * equal numbers divided by a nearly vanishing one, and what it returns
+       * is not an approximation of the answer, it is thousands of cells of
+       * nonsense. Which is then used as a radius, so the rings it draws are
+       * nowhere near where anything is — and only where the source has been
+       * quick, which is why it tore rather than blurred.
+       *
+       * Taking the well-conditioned root first and getting the other from
+       * the product of the two has neither subtraction of like quantities nor
+       * division by the small coefficient.
+       */
+      const root = Math.sqrt(disc);
+      const q = -0.5 * (B + (B >= 0 ? root : -root));
+
+      const p1 = q / A, p2 = Math.abs(q) > 1e-12 ? C / q : q / A;
+
+      // Of the two, the one that leaves the light a non-negative time to
+      // travel in. The other is the advanced solution, which is the same
+      // algebra describing something arriving before it left.
+      const ok1 = a - p1 >= 0, ok2 = a - p2 >= 0;
+
+      step = ok1 && ok2 ? (Math.abs(p1) < Math.abs(p2) ? p1 : p2)
+        : ok1 ? p1
+          : ok2 ? p2
+            : 0;
     }
 
-    groups.push(group);
+    te = Math.min(te + step, t);
   }
 
-  return groups;
+  return te;
 };
 
-// Every arrangement of n charges, grouped with its anti.
-const lineGroups = (n: number): LineSide[][][] => antiGroups(linesOf(n));
-
 /**
- * One side of a head-on collision: `size` charges all going the same way,
- * their polarity flipping from one to the next. `inner` is the polarity of
- * the one at the interface, and the block alternates outward from there —
- * so what a block is doing at the meeting point is what names it, and the
- * rest of it follows.
+ * What ONE source puts at a point.
+ *
+ * Two things temper the bare cosine, and both are properties of the world
+ * above rather than decoration. A wave has not arrived yet where r > t·c, so
+ * there is nothing there — softened over a cell, since a lattice front is not
+ * a razor either. And it thins as it goes, because the same emission is
+ * spread over a bigger and bigger circle; in the model that shows up as the
+ * shells growing apart, here as one over the distance.
+ *
+ * And it is measured from where the source WAS, not from where it is: the
+ * ring through this point left when the source was at p(t − r), and it is
+ * centred there for good. Which is what makes a moving source's rings bunch
+ * up ahead of it and stretch out behind, and at the speeds these reach once
+ * they start eating, that bunching is most of what the picture shows.
+ *
+ * r is on both sides of that, so it is solved for rather than computed —
+ * guess it from where the source is now, look up where it was that long ago,
+ * measure again. Three rounds, because a source that is eating closes at the
+ * speed of its own light and the answer directly ahead of it is then a near
+ * thing: everything it emitted on the way arrives at once, which is a real
+ * pile-up and not an artefact, and it takes a round or two to find. The trail
+ * it looks things up in is a record rather than a projection, so nothing
+ * already emitted can move again however hard the solve works.
  */
-const alternatingBlock = (size: number, inner: Polarity, moving: 'left' | 'right'): LineSide[] => {
-  const outward = Array.from({ length: size }, (_, i) => ({
-    polarity: i % 2 === 0 ? inner : opposite(inner),
-    moving,
-  }));
+const emit = (
+  s: Live, w: Emitter, x: number, y: number, t: number, reach: number,
+  known?: number,
+) => {
+  // Solving the retarded time is the most expensive thing here, and whoever
+  // called this has usually just done it — for the ray, for the cut, for the
+  // meeting surface. Told the answer, this does not do it a second time.
+  let te = known === undefined ? retard(s, x, y, t) : known;
+
+  was(s, te);
+
+  const dx = x - RETARD[0], dy = y - RETARD[1];
+  const r = Math.hypot(dx, dy);
+
+  // Which way what is here is travelling, which is out from wherever it left.
+  // Local, and needed by anything asking whether two things are meeting or
+  // merely crossing.
+  WAY[0] = r > 1e-9 ? dx / r : 1;
+  WAY[1] = r > 1e-9 ? dy / r : 0;
 
-  // Written from the interface outward. A block moving right sits to the left
-  // of the interface, so it reads the other way round along the line.
-  return moving === 'right' ? outward.reverse() : outward;
+  /**
+   * Nothing has arrived where the wave has not reached yet, softened over a
+   * cell because a lattice front is not a razor either.
+   *
+   * Only for a source emitting without pause. A pulse train has its own
+   * edges — the shape below is nought outside the pulse and that is the whole
+   * of where it is not — and applying this to one as well says something
+   * false about the first pulse of the train, which left at the very
+   * beginning and so IS the front: its own arrival is used as evidence that
+   * it has not arrived, and it is never drawn at all.
+   */
+  const front = w.beat ? 1 : Math.min((t * LIGHT - r) / 1.5, 1);
+  if (front <= 0) return 0;
+
+  const fade = 1 / (1 + r / reach);
+
+  /**
+   * cos(θ − ψ) without ever working out θ.
+   *
+   * The direction to here is wanted only inside a cosine, and cos(θ − ψ) is
+   * cos θ·cos ψ + sin θ·sin ψ — where cos θ and sin θ are dx/r and dy/r,
+   * which are already to hand. So the arctangent, which is the most expensive
+   * thing in this whole expression and is evaluated once per source per
+   * sample of the picture, is not needed at all.
+   */
+  /**
+   * When what is here left, and — if this source pulses — whether anything
+   * left then at all.
+   *
+   * A pulse train is not a sum over pulses. The nearest multiple of the beat
+   * to the emission time IS the pulse this point could belong to, since the
+   * pulses are narrower than the gaps between them, so one rounding finds it
+   * and one bump says how much of it is here. Everything stays O(1) in the
+   * number of pulses in the air, which by now is a great many.
+   */
+  let shape = 1;
+
+  if (w.beat) {
+    const beat = Math.round(te / w.beat) * w.beat;
+    const u = (te - beat) / PULSE;
+
+    if (u <= -1 || u >= 1 || beat < 0) return 0;
+
+    shape = (1 - u * u) ** 2;
+    te = beat;
+  }
+
+  const psi = w.omega * te + w.phase;
+
+  const wave = w.lobes
+    ? (dx * Math.cos(psi) + dy * Math.sin(psi)) / (r || 1)
+    : Math.cos(psi);
+
+  return front * fade * shape * wave;
 };
 
 /**
- * Two alternating blocks run at each other. Once the alternation is fixed the
- * only freedom left is the phase of each block — which polarity it presents
- * at the interface — so these four are all of them:
+ * And what the two of them do to each other when they are ALIKE, which the
+ * sum on its own does not contain.
  *
- *   ..0101 → ← 1010..  the alternation carries straight through the meeting
- *                      point; the line is one alternating line, cut in two and
- *                      told to move at itself.
- *   ..1010 → ← 1010..  both blocks in the same phase; the alternation breaks
- *                      exactly where they meet, and the two innermost charges
- *                      are alike rather than opposite.
+ * Opposite charges meeting head-on annihilate, and that is the gravity above.
+ * Like charges meeting head-on turn each other around, and nothing so far has
+ * said so — the closed form adds the two contributions and lets them through
+ * one another.
  *
- * and the anti of each. Head-on opposites annihilate and head-on likes turn
- * around, so the phase decides whether the interface eats the line or reflects
- * it — and after the first tick the block behind is one step further in, with
- * its own phase to present.
+ * For most of these pictures that is not the omission it looks like. Two
+ * identical shells bouncing off each other are indistinguishable from two
+ * shells passing through and swapping names: A's charge ends up where B's
+ * would have been and B's where A's would have been, so the set of places
+ * that are charged is the same either way, and so is the phase at each of
+ * them — the bounced charge has travelled exactly as far as the one that came
+ * the other way. The field cannot tell, because the field does not record
+ * which source anything belongs to. Superposition is already right, and the
+ * waves not visibly turning around is not a thing going wrong.
+ *
+ * It stops being right the moment the two are not interchangeable. A bounced
+ * wave carries the phase and the cadence of the source it came from, and
+ * fades with the distance IT has travelled — and if the two sources are half
+ * a cycle apart, or pulsing at different rates, or one of them is moving and
+ * the other is not, then what comes back is not what would have gone through
+ * and the exchange does not cancel.
+ *
+ * A reflection is an image: the wave that bounced arrives as though it had
+ * come from the mirror of its source in the surface it bounced off. That
+ * surface, for a pair, is the plane halfway between them — so the mirror of
+ * one source is the position of the other, and what comes back is the OTHER
+ * one's geometry carrying THIS one's phase. Which is why the two swap out
+ * exactly when they are alike, and why they do not otherwise.
+ *
+ * So the field is the two readings blended by how much of the meeting is
+ * alike rather than opposite, which `survey` measures on its way past. For
+ * matched sources the reflected pair is the direct pair with the names
+ * exchanged, the blend is between a thing and itself, and it reduces to the
+ * plain sum with nothing left over.
  */
-const COLLISION_PHASES: [Polarity, Polarity][] = [
-  [Polarity.Positive, Polarity.Negative],
-  [Polarity.Negative, Polarity.Positive],
-  [Polarity.Positive, Polarity.Positive],
-  [Polarity.Negative, Polarity.Negative],
-];
+/**
+ * How far a wave of `a`'s gets before it runs into one of `b`'s.
+ *
+ * Both travel a cell a tick, so waves that left at the same moment meet
+ * halfway — and along a ray that is not aimed straight at the other source,
+ * further, because the surface they meet on is a plane and a slanted ray has
+ * further to go to reach it. Aimed away from the other source it never meets
+ * anything at all, and goes on for ever.
+ *
+ * This is the only thing that stops a wave, and it stops it completely. There
+ * is no thinning, no optical depth, no fraction getting through. A charge
+ * meets another charge and one of two things happens, and neither of them is
+ * "carries on a bit weaker".
+ */
+const HERE: [number, number] = [0, 0];
+const THERE: [number, number] = [0, 0];
 
-const collision = (size: number, [left, right]: [Polarity, Polarity]): LineSide[] => [
-  ...alternatingBlock(size, left, 'right'),
-  ...alternatingBlock(size, right, 'left'),
-];
+const meets = (
+  a: Live, b: Live, dx: number, dy: number, when: number,
+) => {
+  /**
+   * Worked out from where the two of them WERE, not from where they are.
+   *
+   * This is the whole of what makes it local, and getting it wrong is
+   * unmistakable: a wave that left long ago has its stopping place decided by
+   * a surface built out of the sources' present positions, so every time
+   * either of them turns or drifts, the surface swings and every wave already
+   * in the air swings with it. Rings that were laid down years of ticks ago
+   * get up and rotate, which is not a thing waves do. Nothing that has
+   * already happened is allowed to depend on anything that happened after it.
+   *
+   * So both are asked where they were when this wave was in the air, and the
+   * answer is a record — see the trail — rather than anything derived from
+   * now. What was decided then stays decided.
+   */
+  was(a, when);
+  HERE[0] = RETARD[0]; HERE[1] = RETARD[1];
 
-// The distinct collisions of two alternating blocks of `size`, grouped with
-// their antis. Mirroring identifies the two through-alternating phases, so
-// what is left is: alternation-through, and alternation-broken with its anti.
-const collisionGroups = (size: number): LineSide[][][] =>
-  antiGroups(COLLISION_PHASES.map(phases => collision(size, phases)));
+  was(b, when);
+  THERE[0] = RETARD[0]; THERE[1] = RETARD[1];
 
-/**
+  let ux = THERE[0] - HERE[0], uy = THERE[1] - HERE[1];
+  const gap = Math.hypot(ux, uy);
+  if (gap < 1e-6) return Infinity;
+
+  ux /= gap; uy /= gap;
+
+  const aim = dx * ux + dy * uy;
+
+  /**
+   * And only where the two would actually be head-on when they got there.
+   *
+   * The surface halfway between a pair is a whole plane, and it is tempting
+   * to stop everything at it — but two waves arriving at a point far out on
+   * that plane are not meeting, they are travelling side by side. Their
+   * directions there are mirror images about the plane, so the angle between
+   * them is set by how squarely the ray was aimed: dead at the other source
+   * they are exactly opposed, and at forty-five degrees off they are already
+   * at right angles and past caring about each other.
+   *
+   * Beyond that the encounter is a crossing. Charges crossing at an angle do
+   * nothing to each other in this model — they pass, and both carry on — so
+   * stopping them there would put a seam down the middle of every picture
+   * where none belongs, and it is why the arms far from the axis have to go
+   * through one another. They are not meeting. They are just both there.
+   */
+  if (aim <= 0.71) return Infinity;
+
+  return (gap / 2) / aim;
+};
+
+/**
+ * A wave of `a`'s that has met one of `b`'s and turned around.
+ *
+ * Which of the two things happened at that meeting is decided THERE, by what
+ * the two of them were, and not by any running average over the picture. Two
+ * charges meeting head-on are alike or they are opposite; alike, they turn
+ * each other round and both go back the way they came; opposite, they
+ * annihilate and neither of them is anywhere afterwards. So this asks the
+ * question at the place and the moment it was settled: what was `a` putting
+ * out along this ray when it got to the meeting, and what was `b` putting
+ * into the same spot at the same instant. Same sign, and there is a wave
+ * coming home. Opposite, and there is nothing — which is the annihilation,
+ * and it needs no separate machinery, because a thing that annihilated simply
+ * has no return.
+ *
+ * And what comes home runs into the shells its own source has emitted since,
+ * head-on, going the other way. A source that turns over is putting out the
+ * opposite charge by then, so what the returning wave meets is its opposite,
+ * and the two cancel. That is the second half of what makes the space between
+ * a pair empty, and it falls out of the arithmetic rather than being put in:
+ * these are all terms in one sum, and terms of opposite sign cancel.
+ *
+ * The going-out and the coming-back are the same wave with the sign of the
+ * radius flipped. Outgoing at distance r left r ago, so its phase runs on
+ * t − r and crests move outward. Having gone to the meeting at R and come
+ * back to r it has travelled 2R − r, so its phase runs on t − 2R + r and
+ * crests move inward. One sign, and that sign is the whole of what bouncing
+ * is.
+ */
+const bounced = (
+  a: Live, b: Live, x: number, y: number, t: number, reach: number,
+  known?: number, given?: number,
+) => {
+  // From where it was when this left it, for the reason given in `fieldAt`.
+  const left = known === undefined ? retard(a, x, y, t) : known;
+
+  was(a, left);
+
+  let dx = x - RETARD[0], dy = y - RETARD[1];
+  const r = Math.hypot(dx, dy);
+  if (r < 1e-6) return 0;
+
+  dx /= r; dy /= r;
+
+  // Asked of the moment this wave was crossing, not of now — or handed
+  // straight over by whoever has already asked.
+  const mirror = given === undefined ? meets(a, b, dx, dy, left) : given;
+  if (!isFinite(mirror) || r >= mirror) return 0;   // nothing has come back to here
+
+  // Out to the meeting and back again: how far this has travelled, and so
+  // how long ago it left.
+  const path = 2 * mirror - r;
+  const te = t - path / LIGHT;
+  if (te < 0) return 0;
+
+  // As above: a train's own pulse shape says where it is, and this would
+  // erase the first of them.
+  const front = a.beat ? 1 : Math.min((t * LIGHT - path) / 1.5, 1);
+  if (front <= 0) return 0;
+
+  let when = te, shape = 1;
+
+  if (a.beat) {
+    const beat = Math.round(when / a.beat) * a.beat;
+    const u = (when - beat) / PULSE;
+
+    if (u <= -1 || u >= 1 || beat < 0) return 0;
+
+    shape = (1 - u * u) ** 2;
+    when = beat;
+  }
+
+  const psi = a.omega * when + a.phase;
+
+  // The angle is the one it LEFT along, since that is the half of the source
+  // it came out of.
+  const mine = a.lobes ? dx * Math.cos(psi) + dy * Math.sin(psi) : Math.cos(psi);
+  if (mine === 0) return 0;
+
+  // What the other one had at that spot when this arrived there. Same sign,
+  // and the two turned each other round; opposite, and they are both gone.
+  was(a, left);
+
+  const hitX = RETARD[0] + dx * mirror, hitY = RETARD[1] + dy * mirror;
+  const struck = t - (mirror - r) / LIGHT;
+
+  const theirs = emit(b, b, hitX, hitY, struck, reach);
+
+  const agree = (mine * theirs) / (Math.abs(mine) * Math.abs(theirs) + 1e-9);
+  const alike = Math.max(agree, 0);
+  if (alike <= 1e-3) return 0;
+
+  // Softened right at the meeting surface, which is a place and not a knife.
+  const edge = Math.min(Math.max((mirror - r) / 1.5, 0), 1);
+
+  /**
+   * Thinned by where it IS, not by how far it has been — which is the
+   * opposite of what it looks like it should be, and is why this was so hard
+   * to see.
+   *
+   * The thinning is a shell spread round a growing circle: the same emission
+   * stretched over a longer and longer ring, so it goes as the radius. A
+   * shell coming home sits on a circle exactly the size of an outgoing
+   * shell's at the same radius, and it is CONTRACTING — its charges are being
+   * gathered back onto a shorter and shorter ring, so it gets denser as it
+   * returns rather than fainter.
+   *
+   * Faded by the whole path instead, as it was, a returning wave is dimmed by
+   * twice the distance to the surface while the outgoing wave drawn at the
+   * same place is dimmed by almost nothing. It was in the arithmetic and
+   * underneath the wave it had bounced off, worst of all near the source
+   * where it should have been brightest.
+   *
+   * The path still sets the phase. How far a thing has travelled is when it
+   * left; it is not how spread out it is.
+   */
+  return alike * edge * front * shape * mine / (1 + r / reach);
+};
+
+/**
+ * What is at a place: everything that got there, going out and coming back.
+ *
+ * A plain sum, and it can be, because nothing in it is a wave that should not
+ * be there. A wave stops dead at the first thing it meets — that is `meets`
+ * above, applied to every outgoing term — so two sources' waves never overlap
+ * beyond their meeting surface and there is no crossing to suppress. What is
+ * left to add up is a handful of waves that genuinely coexist, and adding is
+ * the right thing to do with those: where two of them are opposite they
+ * cancel, which is annihilation, drawn.
+ *
+ * Which is why the returning wave puts out the space between a pair without
+ * anything being written to make it. It comes home into shells its own source
+ * threw out later, and a source that turns over threw the opposite charge;
+ * they are opposite terms in a sum, and they go.
+ */
+const MIRRORS: number[] = [];
+
+const fieldAt = (
+  x: number, y: number, t: number, sources: Live[], reach: number,
+) => {
+  let total = 0;
+
+  for (const a of sources) {
+    /**
+     * Measured from where this source WAS when the wave here left it.
+     *
+     * Not from where it is. The two are the same thing only for a source
+     * standing still, and these travel at ninety-nine hundredths of the speed
+     * of what they emit — so the distance to the present source and the
+     * distance the wave actually came differ by most of the picture. Taking
+     * the ray and the radius from the present position while the surface it
+     * is being cut against is worked out from the past one is two different
+     * geometries compared against each other, and what that produces is a
+     * cut at the wrong radius: a hole where a wave was stopped that never met
+     * anything, standing between the pair and following them about.
+     */
+    const when = retard(a, x, y, t);
+
+    was(a, when);
+
+    let dx = x - RETARD[0], dy = y - RETARD[1];
+    const r = Math.hypot(dx, dy) || 1e-9;
+
+    dx /= r; dy /= r;
+
+    // As far as the nearest thing that was in the way when it went past, and
+    // no further.
+    let stop = Infinity;
+    let seen = 0;
+
+    for (const b of sources) {
+      if (b === a) continue;
+
+      const at = meets(a, b, dx, dy, when);
+
+      MIRRORS[seen++] = at;
+      if (at < stop) stop = at;
+    }
+
+    if (r < stop) {
+      // Faded over a cell at the surface, so the end of a wave is a place
+      // rather than an event.
+      const edge = isFinite(stop) ? Math.min((stop - r) / 1.5, 1) : 1;
+
+      total += emit(a, a, x, y, t, reach, when) * edge;
+    }
+
+    // Only where something was in the way. Over most of any of these pictures
+    // nothing is — a ray not aimed at the other source never meets it — and
+    // asking `bounced` anyway means solving a retarded time and a meeting
+    // surface all over again to be told so.
+    seen = 0;
+
+    for (const b of sources) {
+      if (b === a) continue;
+
+      const mirror = MIRRORS[seen++];
+      if (!isFinite(mirror) || r >= mirror) continue;
+
+      total += bounced(a, b, x, y, t, reach, when, mirror);
+    }
+  }
+
+  return total;
+};
+
+/**
+ * Where space is being destroyed, asked of places rather than of pairs.
+ *
+ * This is the piece that adding cosines does not give you, and without it the
+ * continuous version is not the same physics — it is the same picture with
+ * the gravity left out. Two opposite charges meeting in the model do not
+ * average to nothing and stay where they are. They ANNIHILATE, and
+ * annihilating takes the point each of them was on out of the world, which
+ * leaves whatever was on either side of them nearer together. That is the
+ * whole of why two magnets attract here: not a force between them, an ongoing
+ * loss of the space in between.
+ *
+ * The first version of this asked the question of a PAIR — walk the line
+ * joining two named sources, see how much of what meets there is opposite.
+ * It gives the right rate and it is the wrong question, because it is not a
+ * question about anywhere. It needs to know which sources exist and which two
+ * of them are being considered, and it produces one number for the pair
+ * rather than a fact about each place. Nothing built on it can deflect a
+ * third thing, because a third thing is not in the sum.
+ *
+ * Asked of a place, it is local, and everything it needs is at that place.
+ * How much of each charge is here; which way each of them is travelling; and
+ * therefore how much of what is here is meeting head-on rather than crossing.
+ * Two things annihilate when they are opposite in charge AND opposed in
+ * direction — one without the other is a crossing, not a collision — so both
+ * factors are in it, and both are readable on the spot.
+ *
+ * What comes out is the field this model puts where mass usually goes:
+ * annihilation per unit of space per tick. It is not a property anything has.
+ * It is something that happens somewhere.
+ */
+const SITES: number[] = [];                       // x, y, eaten, nx, ny, met — six at a time
+let siteCount = 0;
+
+/**
+ * How much space a tick's worth of meeting destroys, which is the one number
+ * tying the continuous rate to the discrete one.
+ *
+ * A source emits a shell every tick and shells travel a cell a tick, so along
+ * any line between two of them one shell meets one shell every tick, and a
+ * meeting of opposites takes two cells out of the world. That is the whole of
+ * the rate, and it is a COUNT — one meeting, two cells — with nothing in it
+ * about how large the region is where the meeting happens.
+ *
+ * Which is the thing the survey below cannot supply and must not be asked to.
+ * It measures a density, and a density integrated over an area gives a number
+ * that grows with the area: two sources far apart overlap over more of the
+ * picture than two close together, and reading their annihilation off that
+ * integral has them eating faster the further apart they are, which is not
+ * merely wrong but backwards. Everything the survey knows is WHERE the eating
+ * is happening and along what. How MUCH is set here, by the cadence, and
+ * shared out over the places in proportion to what is going on at each.
+ *
+ * So the survey's numbers are a shape and this is the size of it. The one
+ * thing left for the survey to say about magnitude is the share — how much of
+ * what meets is opposite rather than alike — which is dimensionless, is
+ * between nought and one, and is exactly what it should be reporting: a pair
+ * eating all of what they send each other, or half of it, or none.
+ */
+const BITE = 2 * LIGHT;
+
+/**
+ * And how far the loss of a point is felt, which is not far.
+ *
+ * A collision removes the two points its charges were on and joins what was
+ * behind each directly to the other. That shortens the LINE they were on and
+ * does nothing whatever to a point off to the side, which is joined to the
+ * world by paths that never went through the collision. So the influence of
+ * an annihilation is confined to a neighbourhood of it, and this is the size
+ * of that neighbourhood.
+ *
+ * Which is a real claim and an unusual one. Gravity here is not long-range,
+ * and it is not something a mass has and radiates. It acts along the lines
+ * where annihilation is actually happening, which is to say between things
+ * that are cancelling each other's emissions. A body that emits nothing feels
+ * nothing, however much is going on beside it.
+ *
+ * But it must not be smaller than the grid the annihilation was surveyed on,
+ * and that is what it was. A few cells, against sites laid out one every few
+ * cells, gives a field that is a row of separate little pushes with nothing
+ * between them: a body sitting on the axis is either on top of one, where the
+ * transverse falloff is flat because it is at the peak of it, or between two,
+ * where there is nothing at all. Either way it feels no gradient, and a body
+ * that feels no gradient is never turned — which was the whole complaint. The
+ * loss has to be smeared over at least the spacing of the places it was
+ * measured at, or what is being drawn is the grid rather than the field.
+ */
+let LOCAL = 3;                                    // cells, set by the survey
+
+// How far apart the closest pair are, which is the distance the pull has to
+// work over. Also set by the survey.
+let SPREAD = 1;
+
+/**
+ * Survey the framed region for it, once a tick.
+ *
+ * A coarse grid is enough: what is being looked for is where the annihilation
+ * is, and it is spread over the overlap of two fields rather than
+ * concentrated at points. Everything below a fraction of the strongest is
+ * dropped, because most of any of these pictures is space where nothing is
+ * meeting anything and summing a few hundred nothings into every query is the
+ * whole cost of this.
+ */
+const survey = (live: Live[], t: number, reach: number, span: number) => {
+  const STEPS = 22;
+
+  siteCount = 0;
+  SITES.length = 0;
+
+  if (live.length < 2) return;
+
+  // Centred on the sources, since that is where anything is.
+  let mx = 0, my = 0;
+  for (const s of live) { mx += s.at[0] / live.length; my += s.at[1] / live.length; }
+
+  /**
+   * And it looks at the pair, not at the picture.
+   *
+   * The grid was laid across the whole view, so its cells are a couple of
+   * cells of world across — which is fine while the two are far apart and
+   * useless the moment they are not. A pair three cells apart has the whole
+   * of its encounter inside ONE cell of that grid: the survey finds a site or
+   * two in roughly the right place, or none at all, and the pull collapses
+   * exactly as the two are closing on each other. They drifted together,
+   * slowed for no reason in the model, and stopped short.
+   *
+   * Framed on the pair instead, the resolution follows them down. What is
+   * being measured is where annihilation is happening, and that is between
+   * them, wherever they have got to and however little room it now takes.
+   */
+  let nearest = Infinity;
+
+  for (let i = 0; i < live.length; i++)
+    for (let j = i + 1; j < live.length; j++)
+      nearest = Math.min(nearest, Math.hypot(
+        live[j].at[0] - live[i].at[0], live[j].at[1] - live[i].at[1],
+      ));
+
+  const look = Math.min(span, Math.max(isFinite(nearest) ? nearest * 1.6 : span, 5));
+  const step = (2 * look) / STEPS;
+
+  GRID = STEPS;
+  GRID_STEP = step;
+  GRID_X = mx - look + step / 2;
+  GRID_Y = my - look + step / 2;
+
+  // Wide enough that the sites blend into a field rather than staying a row
+  // of separate pushes, which is what gives it a gradient to turn anything
+  // with. See `LOCAL`.
+  LOCAL = Math.max(step * 2, 1.5);
+  SPREAD = Math.max(isFinite(nearest) ? nearest / 4 : step, 0.75);
+
+  const val: number[] = [];
+  const dirX: number[] = [];
+  const dirY: number[] = [];
+
+  let strongest = 0;
+
+  // What the picture is doing as a whole: how much of what meets is opposite,
+  // and how much meets at all. Their ratio is the only thing about magnitude
+  // the survey has any business reporting.
+  let cancelling = 0, meeting = 0;
+
+  for (let gy = 0; gy < STEPS; gy++) {
+    const y = my - look + (gy + 0.5) * step;
+
+    for (let gx = 0; gx < STEPS; gx++) {
+      const x = mx - look + (gx + 0.5) * step;
+
+      for (let i = 0; i < live.length; i++) {
+        val[i] = emit(live[i], live[i], x, y, t, reach);
+        dirX[i] = WAY[0]; dirY[i] = WAY[1];
+      }
+
+      // What is annihilating here, and what is meeting here at all — which
+      // is more, because alike charges meeting head-on turn around rather
+      // than cancelling, and either way they stop going forwards.
+      let rate = 0, here = 0, nx = 0, ny = 0;
+
+      for (let i = 0; i < live.length; i++) {
+        for (let j = i + 1; j < live.length; j++) {
+          const both = val[i] * val[j];
+
+          // How much of what is here is one field against the other at all,
+          // whichever way round — the denominator of the share.
+          const closing = Math.max(-(dirX[i] * dirX[j] + dirY[i] * dirY[j]), 0);
+          if (closing <= 0) continue;             // crossing, not meeting
+
+          here += Math.abs(both) * closing;
+          meeting += Math.abs(both) * closing;
+
+          // Opposite in charge as well as opposed in direction: annihilation
+          // rather than a bounce.
+          const against = Math.max(-both, 0) * closing;
+          if (against <= 0) continue;
+
+          rate += against;
+
+          // The line they are meeting along, which is the line that shortens.
+          nx += (dirX[i] - dirX[j]) * against;
+          ny += (dirY[i] - dirY[j]) * against;
+        }
+      }
+
+      if (here <= 0) continue;
+
+      cancelling += rate;
+
+      const len = Math.hypot(nx, ny) || 1;
+
+      SITES.push(x, y, rate, nx / len, ny / len, here);
+      siteCount++;
+
+      if (here > strongest) strongest = here;
+    }
+  }
+
+  // Note there is no global reading of how much bounces and how much
+  // annihilates. That question is settled at each meeting by what the two
+  // charges there are, in `bounced` above — a share taken over the whole
+  // picture is an average of a decision, and an average of a decision is not
+  // a thing anything experiences.
+
+  if (!strongest) { SITES.length = 0; siteCount = 0; return; }
+
+  // Thinned to what is worth summing over, and the total kept with it so that
+  // what is dropped is not quietly handed to what is not.
+  const floor = strongest * 0.05;
+  let kept = 0, total = 0;
+
+  let seen = 0;
+
+  for (let k = 0; k < siteCount; k++) {
+    if (SITES[k * 6 + 5] < floor) continue;
+
+    for (let c = 0; c < 6; c++) SITES[kept * 6 + c] = SITES[k * 6 + c];
+
+    total += SITES[kept * 6 + 2];
+    seen += SITES[kept * 6 + 5];
+    kept++;
+  }
+
+  SITES.length = kept * 6;
+  siteCount = kept;
+
+  // The meeting is kept as it was measured — a density, per unit of space,
+  // per tick. Normalising it to a share of the whole encounter, which is what
+  // it used to do, is what made the shadow useless: a wave crossing the gap
+  // met "a fifth of the total" however thick the thing it was crossing, so
+  // the attenuation stopped depending on how much was actually in the way.
+  // What a wave loses is a density times a path, and both of those have to
+  // survive to the place that multiplies them.
+
+  /**
+   * Rebuilt whatever else is true of this tick, and before anything can
+   * return early.
+   *
+   * A shadow is a fact about where the sources are NOW. Left over from the
+   * tick before while they have moved on — which is what happened whenever a
+   * pair was bouncing without annihilating, since there was nothing to scale
+   * and the function gave up before reaching this — it darkens places nothing
+   * is crossing any more, and the picture fills with patches of black that
+   * belong to a configuration that has gone.
+   */
+
+  if (!kept || total <= 0) return;
+
+  /**
+   * And the whole of it scaled to what a tick's meeting actually costs.
+   *
+   * The share is how much of the encounter annihilates rather than bounces,
+   * which is between nought and one and says nothing about how big the
+   * encounter is. Multiplied by `BITE`, that is the space a tick destroys.
+   * Divided out over the sites in proportion to what each is doing, the
+   * distribution stays exactly what was measured and the total stops being an
+   * accident of how much of the picture the two fields happen to overlap in.
+   */
+  const share = meeting > 1e-12 ? cancelling / meeting : 0;
+
+  /**
+   * And the size of it is fixed by what the pair actually do to each other,
+   * not by what the sites happen to add up to.
+   *
+   * A meeting costs two cells: the charge arriving is on a point, the charge
+   * it meets is on the next one, and annihilating is both of them ceasing to
+   * be anywhere. One meeting a tick, so two cells a tick, times the share of
+   * the encounter that is opposite rather than alike. That is the whole rate
+   * and it is a count — it does not know or care how the annihilation is
+   * spread about.
+   *
+   * Scaling the SITES to sum to it is not the same thing and was the error.
+   * What a source is moved by is not the sum of the sites, it is the flow it
+   * stands in — the sum after each site's reach has fallen away across the
+   * distance and off to the side. Most of it never arrives. So the sites
+   * summed to two cells a tick and the pair closed at a fifth of one, and
+   * every picture of two things attracting was running at a fraction of the
+   * rate the rule gives, with the fraction set by how the survey's kernels
+   * happened to overlap.
+   *
+   * Measured at the sources instead: lay the sites down at whatever relative
+   * strengths they were found with, ask how fast the gap between the pair is
+   * closing under that, and scale the lot until the answer is two cells a
+   * tick. Then the shape is the survey's and the size is the rule's, which is
+   * the right division of labour between the two.
+   */
+  for (let k = 0; k < kept; k++) SITES[k * 6 + 2] /= total;
+
+  let closes = 0;
+
+  for (let i = 0; i < live.length; i++) {
+    for (let j = i + 1; j < live.length; j++) {
+      const a = live[i], b = live[j];
+
+      let ux = b.at[0] - a.at[0], uy = b.at[1] - a.at[1];
+      const apart = Math.hypot(ux, uy);
+      if (apart < 1e-6) continue;
+
+      ux /= apart; uy /= apart;
+
+      flowAt(a.at[0], a.at[1]);
+      const ain = FLOW[0] * ux + FLOW[1] * uy;
+
+      flowAt(b.at[0], b.at[1]);
+      const bin = -(FLOW[0] * ux + FLOW[1] * uy);
+
+      closes += ain + bin;
+    }
+  }
+
+  if (closes <= 1e-9) return;
+
+  const want = BITE * share;
+
+  for (let k = 0; k < kept; k++) SITES[k * 6 + 2] *= want / closes;
+};
+
+// The optical-depth shadow that used to live here is gone. A wave is not
+// thinned by what it passes through — it stops dead at the first thing it
+// meets, which is `meets` above — so there was nothing left for it to say,
+// and it was still being rebuilt over the whole grid every tick.
+
+/**
+ * The flow of space, which is where gravity actually is.
+ *
+ * Each place that is destroying space draws what is around it inwards along
+ * the line the collision there is happening on: everything on one side comes
+ * one way, everything on the other side comes the other, and a point off to
+ * the side barely moves at all. Summed over everywhere that is doing it, that
+ * is the whole field, and nothing in the sum knows about sources or pairs —
+ * only about places and what is happening at them.
+ *
+ * And there is the deflection, for free and without a force anywhere. The
+ * flow has a gradient, so it does not merely carry a body — it turns it. A
+ * velocity is a displacement per tick, and a displacement in a space that is
+ * being sheared comes out pointing somewhere else. Nothing accelerates: the
+ * body's own motion is untouched and its speed never changes. It is carried,
+ * and what carries it is not uniform.
+ */
+const FLOW: [number, number] = [0, 0];
+
+const flowAt = (x: number, y: number) => {
+  FLOW[0] = 0; FLOW[1] = 0;
+
+  for (let k = 0; k < siteCount; k++) {
+    const sx = SITES[k * 6], sy = SITES[k * 6 + 1];
+    const q = SITES[k * 6 + 2];
+    const nx = SITES[k * 6 + 3], ny = SITES[k * 6 + 4];
+
+    const ex = x - sx, ey = y - sy;
+
+    const on = ex * nx + ey * ny;
+    const off = ex * -ny + ey * nx;
+
+    /**
+     * Everything on one side comes one way and everything on the other comes
+     * the other, so the line through it is shorter by `q` and the place
+     * itself does not move.
+     *
+     * Saturating over the distance the pair are apart, not over the size of
+     * the picture. Tied to the picture, the pull quietly gave out exactly
+     * when it should have been strongest: a pair a few cells apart has every
+     * site a few cells from each of them, and `tanh` of a few cells over a
+     * width set by the whole view is almost nothing — so they drifted
+     * together, slowed, and stopped short of touching for no reason in the
+     * model at all.
+     */
+    const side = Math.tanh(on / SPREAD);
+    const fade = Math.exp(-((off / LOCAL) ** 2));
+
+    FLOW[0] -= (q / 2) * side * fade * nx;
+    FLOW[1] -= (q / 2) * side * fade * ny;
+  }
+};
+
+// A 4x4 ordered pattern, centred on nought and worth about one level of an
+// eight-bit channel. See the use below.
+const DITHER = [
+  0, 8, 2, 10,
+  12, 4, 14, 6,
+  3, 11, 1, 9,
+  15, 7, 13, 5,
+].map(v => (v / 16) - 0.5);
+
+/**
+ * One canvas of it, evaluated rather than simulated.
+ *
+ * Every sample is independent of every other, so there is no state to carry
+ * between frames and nothing to ease: the drawn field IS the field, at
+ * whatever real-valued t the clock has reached. Which is the visible payoff
+ * of having a function rather than a run — the animation above has to walk
+ * towards each tick because the world only exists at whole ones, and this
+ * one is simply continuous, so it moves the way a wave moves.
+ *
+ * Drawn small and stretched. The field has no detail below the scale of its
+ * own bands, so sampling it at every pixel is spending several times over
+ * for a picture that is smooth by construction; a quarter-scale buffer drawn
+ * up with the canvas's own interpolation is the same image for a sixteenth
+ * of the arithmetic.
+ */
+const ContinuousField = ({
+  sources,
+  height = 320,
+  span = 14,
+  rate = 10,
+  cycle = 200,
+}: {
+  sources: Emitter[];
+
+  // How much of the world is on screen, as a radius in cells.
+  span?: number;
+
+  // Ticks a second, and it need not be a whole number of anything.
+  rate?: number;
+
+  // Ticks before it starts again from the beginning. A pair that closes on
+  // each other ends up adjacent and then has nothing left to do — neither is
+  // space, so neither can be moved through, and adjacent is as close as
+  // adjacent gets. Watching that happen is the point; watching it having
+  // happened is not.
+  cycle?: number;
+
+  height?: number;
+}) => {
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+  const latest = useRef({ sources, span, rate, cycle });
+  latest.current = { sources, span, rate, cycle };
+
+  useEffect(() => {
+    const canvas = canvasRef.current!;
+    const ctx = canvas.getContext("2d")!;
+
+    // The small buffer the field is evaluated into, before being drawn up to
+    // the size of the canvas.
+    const buf = document.createElement("canvas");
+    const bufCtx = buf.getContext("2d")!;
+
+    let img: ImageData | null = null;
+
+    let raf = 0;
+    let seen = false;
+    let t = 0;
+    let last = performance.now();
+
+    // Where the sources have got to. The ones handed in say where they start,
+    // and nothing about where they stay.
+    let live: Live[] = [];
+
+    const reset = () => {
+      t = 0;
+      live = latest.current.sources.map(s => ({
+        ...s,
+        at: [...s.at] as [number, number],
+        path: [s.at[0], s.at[1]],
+        vel: [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number],
+      }));
+    };
+
+    // Everywhere each of them has been, kept up to the moment. Filled to the
+    // current time rather than appended to once per frame, so the record is
+    // evenly spaced whatever the frame rate happens to be doing.
+    const remember = () => {
+      for (const s of live) {
+        for (let k = s.path.length / 2; k <= t / TRAIL; k++) {
+          s.path.push(s.at[0], s.at[1]);
+        }
+      }
+    };
+
+    reset();
+
+
+
+    function resize() {
+      const parent = canvas.parentElement!;
+      const w = parent.clientWidth, h = parent.clientHeight;
+      const ratio = window.devicePixelRatio || 1;
+
+      canvas.width = w * ratio;
+      canvas.height = h * ratio;
+      canvas.style.width = w + "px";
+      canvas.style.height = h + "px";
+
+      // Everything below draws in css pixels; the field's own buffer is
+      // coarser than either and gets stretched over the top.
+      ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
+    }
+
+    function draw() {
+      const { span } = latest.current;
+      const sources = live;
+      const w = canvas.clientWidth, h = canvas.clientHeight;
+      if (!w || !h) return;
+
+      /**
+       * Css pixels to a sample, and it cannot be one number.
+       *
+       * What has to be resolved is a band, and a band is `CYCLE/2` cells of
+       * world however the view is set — so how many pixels it covers depends
+       * entirely on how far out the camera is. A single source framed at
+       * fourteen cells gives a band forty-odd pixels and four pixels a sample
+       * is plenty. The same four pixels against a pair framed at sixty gives a
+       * band ten pixels wide and two and a half samples across it, which is
+       * under what it takes to see a wave at all: what gets drawn there is not
+       * a coarse version of the field, it is the moiré of a grid beating
+       * against one, and no amount of smoothing afterwards recovers it.
+       *
+       * So the sampling follows the bands rather than the screen. Five or so to
+       * a band everywhere, which is what the wide views were missing and what
+       * the close ones were spending several times over.
+       */
+      const bandPx = (CYCLE / 2) * (Math.min(w, h) / (2 * Math.max(span, 1)));
+
+      const SAMPLE = Math.max(Math.min(bandPx / 5, 4), 1.4);
+
+      const cols = Math.max(Math.round(w / SAMPLE), 1);
+      const rows = Math.max(Math.round(h / SAMPLE), 1);
+
+      if (buf.width !== cols || buf.height !== rows) {
+        buf.width = cols; buf.height = rows;
+        img = null;
+      }
+
+      // Asked for once and written over ever after. At this sampling it is a
+      // hundred thousand pixels a frame, and handing that back to be
+      // collected sixty times a second is most of what the drawing would
+      // otherwise cost.
+      if (!img) img = bufCtx.createImageData(cols, rows);
+
+      const px = img.data;
+
+      // Cells to the shorter side of the picture, so the same world is framed
+      // whatever shape the canvas is.
+      const scale = Math.min(w, h) / (2 * span);
+      const reach = span * 0.6;
+
+      for (let y = 0; y < rows; y++) {
+        const wy = ((y + 0.5) * (h / rows) - h / 2) / scale;
+
+        for (let x = 0; x < cols; x++) {
+          const wx = ((x + 0.5) * (w / cols) - w / 2) / scale;
+
+          const v = Math.max(Math.min(fieldAt(wx, wy, t, sources, reach), 1), -1);
+
+          /**
+           * Amber one way, cyan the other, and the background where the two
+           * meet — so a seam is a dark channel and needs no line drawn on it.
+           *
+           * Shown at the strength it actually has, which it was not. A gamma
+           * of about a half lifts the faint parts of a picture towards the
+           * bright ones, and here that is a lie with consequences: a wave
+           * thinned to a hundredth of itself by distance and by everything it
+           * has crossed was being drawn at a fifth, so the outer half of
+           * every picture looked like a place where something was happening.
+           * It is not. Gravity here goes as the product of two waves meeting,
+           * so it falls away faster than either of them does — and if the
+           * waves are drawn brighter than they are, the eye is being told the
+           * opposite of the truth about where anything can still act.
+           *
+           * Straight through, then. What is visible is what is there, and
+           * where the picture goes dark is where the two have nothing left to
+           * do to each other.
+           */
+          const k = Math.abs(v);
+          const i = (y * cols + x) * 4;
+
+          /**
+           * And a little noise added before it is rounded to a byte.
+           *
+           * The field is smooth and the colours it maps to are eight bits, so
+           * a gradient that takes two hundred pixels to go from one shade to
+           * the next has a hard edge every two hundred pixels — a set of
+           * contour lines nothing asked for, which read as the picture being
+           * coarse when what is coarse is only the counting. Half a level of
+           * dither, from a fixed pattern rather than from a random number so
+           * that a still frame is stable, turns each of those edges into a
+           * scatter that averages to the right value and has no edge in it.
+           */
+          const d = DITHER[(y & 3) * 4 + (x & 3)];
+
+          px[i] = 6 + (v > 0 ? 249 : 55) * k + d;
+          px[i + 1] = 7 + (v > 0 ? 115 : 213) * k + d;
+          px[i + 2] = 12 + (v > 0 ? 57 : 243) * k + d;
+          px[i + 3] = 255;
+        }
+      }
+
+      bufCtx.putImageData(img, 0, 0);
+
+      ctx.fillStyle = "#06070c";
+      ctx.fillRect(0, 0, w, h);
+
+      ctx.imageSmoothingEnabled = true;
+      ctx.drawImage(buf, 0, 0, w, h);
+
+      // The sources, in the same yellow they are given above.
+      for (const s of sources) {
+        const sx = w / 2 + s.at[0] * scale, sy = h / 2 + s.at[1] * scale;
+
+        const halo = ctx.createRadialGradient(sx, sy, 0, sx, sy, 14);
+        halo.addColorStop(0, "rgba(255,214,66,0.85)");
+        halo.addColorStop(0.35, "rgba(255,186,40,0.3)");
+        halo.addColorStop(1, "rgba(255,186,40,0)");
+
+        ctx.fillStyle = halo;
+        ctx.beginPath();
+        ctx.arc(sx, sy, 14, 0, Math.PI * 2);
+        ctx.fill();
+
+        ctx.fillStyle = "#FFE066";
+        ctx.beginPath();
+        ctx.arc(sx, sy, 2.2, 0, Math.PI * 2);
+        ctx.fill();
+      }
+    }
+
+    /**
+     * And everything is carried by the flow of the space it is in.
+     *
+     * Three things, in this order, and the order says what the model claims.
+     * A source goes on going the way it was going, because nothing here
+     * accelerates anything. The space it is in is carried by `flowAt`,
+     * wherever annihilation is shortening it. And the source's own direction
+     * is turned by the same flow — not by being pushed, but because a
+     * direction is a displacement per tick and the space that displacement
+     * lives in is being sheared underneath it.
+     *
+     * The turning is the gradient of the flow, taken as a difference over
+     * half a cell either side. Nothing about the speed appears in it: a
+     * velocity carried through a shear comes out pointing elsewhere, at
+     * whatever length the shear leaves it, and the drift is renormalised back
+     * to the speed it was given so that this stays a change of direction and
+     * never becomes a change of pace.
+     *
+     * They stop when they are adjacent, which is not a fudge to keep them
+     * apart: a source is not space, so there is nothing left between them to
+     * annihilate and nothing either could move through if there were.
+     */
+    const TOUCH = 1;                              // as close as adjacent gets
+    const NUDGE = 0.5;                            // cells, for reading a gradient
+
+    function pull(dt: number) {
+      const span = latest.current.span;
+      const reach = span * 0.6;
+
+      // Where space is going, worked out once for the whole picture. After
+      // this nothing asks about sources again — only about places.
+      survey(live, t, reach, span);
+
+      // The flow as it stands, before anything has moved in it.
+      const carry = live.map(s => {
+        flowAt(s.at[0], s.at[1]);
+
+        return [FLOW[0], FLOW[1]] as [number, number];
+      });
+
+      const turned = live.map((s, i) => {
+        /**
+         * Turned along the way it is ACTUALLY going, which is its own motion
+         * and the flow carrying it, together.
+         *
+         * Taken along `vel` alone, as it was, this asks how the flow varies
+         * down a line the source is not travelling on. For anything with a
+         * drift that is merely the wrong line; for anything without one it is
+         * no line at all, and the whole thing gave up at the first test —
+         * so a pair set going by nothing but gravity had its direction left
+         * entirely alone, and gravity could displace them but never steer
+         * them. Which is exactly the complaint: the middle alive, and the two
+         * of them never coming round to face each other.
+         */
+        const goX = s.vel[0] + carry[i][0], goY = s.vel[1] + carry[i][1];
+
+        const speed = Math.hypot(s.vel[0], s.vel[1]);
+        const going = Math.hypot(goX, goY);
+        if (going < 1e-9) return s.vel;
+
+        // How the flow differs a little either way along the direction it is
+        // going: that difference, over that distance, is what turns it.
+        const hx = goX / going, hy = goY / going;
+
+        flowAt(s.at[0] + hx * NUDGE, s.at[1] + hy * NUDGE);
+        const ax = FLOW[0], ay = FLOW[1];
+
+        flowAt(s.at[0] - hx * NUDGE, s.at[1] - hy * NUDGE);
+
+        const gx = (ax - FLOW[0]) / (2 * NUDGE), gy = (ay - FLOW[1]) / (2 * NUDGE);
+
+        let vx = s.vel[0] + gx * going * dt;
+        let vy = s.vel[1] + gy * going * dt;
+
+        // Turned, never sped up or slowed down. A source with no drift of its
+        // own has nothing to keep the length of, and stays at nothing.
+        const now = Math.hypot(vx, vy);
+        if (now < 1e-9 || speed < 1e-9) return s.vel;
+
+        return [vx * speed / now, vy * speed / now] as [number, number];
+      });
+
+      for (let i = 0; i < live.length; i++) {
+        const s = live[i];
+
+        s.vel = turned[i];
+
+        s.at[0] += (s.vel[0] + carry[i][0]) * dt;
+        s.at[1] += (s.vel[1] + carry[i][1]) * dt;
+      }
+
+      // Not through one another: a source is not space.
+      for (let i = 0; i < live.length; i++) {
+        for (let j = i + 1; j < live.length; j++) {
+          const a = live[i], b = live[j];
+
+          const dx = b.at[0] - a.at[0], dy = b.at[1] - a.at[1];
+          const gap = Math.hypot(dx, dy);
+          if (gap >= TOUCH || gap < 1e-9) continue;
+
+          const back = (TOUCH - gap) / 2;
+          const ux = dx / gap, uy = dy / gap;
+
+          a.at[0] -= ux * back; a.at[1] -= uy * back;
+          b.at[0] += ux * back; b.at[1] += uy * back;
+        }
+      }
+
+      /**
+       * And the trail is NOT carried with it, which is the whole of what
+       * makes any of this local.
+       *
+       * It was, and the argument for it sounded right: a ring is centred
+       * where its source was when it left, that place is in the space too,
+       * and if the space is going then so is everywhere in it. What that
+       * argument misses is that the trail is not a set of places. It is a
+       * RECORD of where something was at a moment, and a record that gets
+       * amended is not a record of anything.
+       *
+       * Amended every frame, every position in it drifts a little further
+       * from what was actually the case — so `was` gives a different answer
+       * today than it gave yesterday for the same instant, and every wave in
+       * the air, however old, quietly re-centres itself on the answer. Rings
+       * laid down a hundred ticks ago get up and move because their source
+       * has since been pulled somewhere. Nothing that has already happened
+       * may depend on anything that happened after it, and this was the last
+       * place in the model where it did.
+       */
+    }
+
+    function frame(now: number) {
+      const dt = Math.min((now - last) / 1000, 0.05) * latest.current.rate;
+      last = now;
+
+      t += dt;
+
+      if (t >= latest.current.cycle) reset();
+      else pull(dt);
+
+      remember();
+
+      draw();
+
+      raf = requestAnimationFrame(frame);
+    }
+
+    const stop = () => {
+      if (!raf) return;
+
+      cancelAnimationFrame(raf);
+      raf = 0;
+    };
+
+    const show = (visible: boolean) => {
+      if (visible === seen) return;
+      seen = visible;
+
+      if (visible) {
+        resize();
+        reset();
+        last = performance.now();
+        raf = requestAnimationFrame(frame);
+        return;
+      }
+
+      stop();
+
+      // Both buffers handed back, which between them are the whole of what
+      // this holds on to. There is no state in it besides a clock.
+      canvas.width = 0; canvas.height = 0;
+      buf.width = 0; buf.height = 0;
+      img = null;
+    };
+
+    const onResize = () => { if (seen) resize(); };
+    window.addEventListener("resize", onResize);
+
+    const unwatch = whileOnScreen(canvas, show);
+
+    return () => {
+      unwatch();
+      stop();
+      window.removeEventListener("resize", onResize);
+    };
+  }, []);
+
+  return <div style={{ height }}>
+    <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%" }} />
+  </div>;
+};
+
+// A turn per CYCLE ticks, which is the rate the lattice above comes round at:
+// eight directions to a plane and one step of them a tick.
+const SPIN = (Math.PI * 2) / CYCLE;
+
+/**
+ * How far apart a pair starts, and how much of the world is watched.
+ *
+ * Far, now that the closing is at its real rate. A cell a tick is quick
+ * enough that a pair set eight apart — which is what the lattice examples
+ * above can afford — is over in eight ticks, and what there is to see is not
+ * the arrangement but the end of it. Set forty apart there is time for the
+ * two to reach each other, for the fringes between them to establish
+ * themselves, and for the closing to be watched as a thing with a rate rather
+ * than as a fact about the next frame.
+ *
+ * Note also what the first stretch of every one of these is: nothing at all
+ * happening. Neither source knows the other is there until light has crossed
+ * the gap, and until then nothing between them cancels and neither moves.
+ * That is not dead time in the animation. It is the model's whole position on
+ * action at a distance, which is that there is none.
+ */
+const APART = 34;
+const WIDE = 40;
+
+/**
+ * And how many ticks each is given before it starts again.
+ *
+ * Not the same number for both kinds, because they do not have the same
+ * amount to do. A lone source never finishes: it is laying down a pattern
+ * that goes on getting bigger, and every extra turn of it out towards the rim
+ * is another turn there is to see, so it is given a long run. A pair does
+ * finish — they reach each other, and adjacent is as close as adjacent gets —
+ * so what a long run buys there is a great deal of two sources sitting still.
+ * Enough after they arrive to see that they have arrived, and then round
+ * again.
+ */
+/**
+ * And the fly-by's own scale, which is larger than everything else here.
+ *
+ * `FAR` is far enough that light takes a good while to cross — nothing at all
+ * happens for the first fifty-odd ticks of that case, which is the model
+ * being honest about there being no action at a distance — and `MISS` is the
+ * impact parameter, the distance they would pass at if nothing were eaten.
+ * Both are the dials for that one picture: closer or more head-on and it is a
+ * collision, further or wider and they are gone before the gap notices them.
+ */
+// How far out the three sit from their common centre. Their sides are RING
+// times root three, so light takes about that long to cross between any two
+// of them and nothing at all happens before it has.
+const RING = 30;
+
+const FAR = 52;
+const MISS = 34;
+const ROOM = 62;
+
+const ALONE_FOR = 260;
+const PAIR_FOR = 200;
+
+const CONTINUOUS_CASES: {
+  name: string, note: string, sources: Emitter[], span?: number, cycle?: number,
+}[] = [
+  {
+    name: 'one magnet, turning',
+    cycle: ALONE_FOR,
+    note: 'lobes = 1, so the field carries an angle and its zero set winds.',
+    sources: [{ at: [0, 0], lobes: 1, omega: SPIN, phase: 0 }],
+  },
+  {
+    name: 'one source, not turning',
+    cycle: ALONE_FOR,
+    note: 'The same expression with the angle taken out: lobes = 0, and rings.',
+    sources: [{ at: [0, 0], lobes: 0, omega: SPIN, phase: 0 }],
+  },
+  {
+    name: 'two magnets, turning the same way',
+    span: WIDE,
+    cycle: PAIR_FOR,
+    note: 'Two congruent spirals, and the first pair here that closes: what '
+      + 'they eat between them is what brings them together.',
+    sources: [
+      { at: [-APART, 0], lobes: 1, omega: SPIN, phase: 0 },
+      { at: [APART, 0], lobes: 1, omega: SPIN, phase: 0 },
+    ],
+  },
+  {
+    name: 'two magnets, turning opposite ways',
+    span: WIDE,
+    cycle: PAIR_FOR,
+    note: 'Mirrored winding, so along the line between them the two arrive in '
+      + 'step and out of step by turns — and close in bursts rather than '
+      + 'steadily, which is the beat showing up as a rate.',
+    sources: [
+      { at: [-APART, 0], lobes: 1, omega: SPIN, phase: 0 },
+      { at: [APART, 0], lobes: 1, omega: -SPIN, phase: 0 },
+    ],
+  },
+  {
+    name: 'two sources, pulsing in step',
+    span: WIDE,
+    cycle: PAIR_FOR,
+    note: 'Rings launched together. They agree on the midline and cancel in '
+      + 'rings either side of it, and it is the cancelling that closes them.',
+    sources: [
+      { at: [-APART, 0], lobes: 0, omega: SPIN, phase: 0 },
+      { at: [APART, 0], lobes: 0, omega: SPIN, phase: 0 },
+    ],
+  },
+  {
+    name: 'two sources, pulsing against each other',
+    span: WIDE,
+    cycle: PAIR_FOR,
+    note: 'Half a cycle apart: the midline is now where they always cancel, '
+      + 'so the same pair closes faster on the same rules.',
+    sources: [
+      { at: [-APART, 0], lobes: 0, omega: SPIN, phase: 0 },
+      { at: [APART, 0], lobes: 0, omega: SPIN, phase: Math.PI },
+    ],
+  },
+
+  /**
+   * One of them, going somewhere.
+   *
+   * Nothing for it to interact with, so nothing about it changes: it travels
+   * at the one speed a source can, and goes on emitting the whole way. What
+   * that shows is the retardation on its own, with no gravity mixed into it.
+   * Every ring it leaves is centred where it was when that ring left, so the
+   * rings ahead of it are crowded together and the ones behind are stretched
+   * apart — the same shape as a Doppler shift, arrived at by nothing more
+   * than a source outrunning some of its own past.
+   */
+  {
+    name: 'one magnet, turning, and moving',
+    cycle: ALONE_FOR,
+    note: 'No second source, so nothing is eaten and nothing bends. The rings '
+      + 'bunch ahead and stretch behind because each was left where it left '
+      + 'from, and the source has gone on.',
+    sources: [{ at: [-12, 0], lobes: 1, omega: SPIN, phase: 0, drift: [PACE, 0] }],
+  },
+
+  /**
+   * Two of them, set going the same way round.
+   *
+   * The one on the left sent up and the one on the right sent down, so the
+   * pair are circulating about the point between them rather than passing
+   * each other. This is the case the lattice version could not really put to
+   * the question — a hundred ticks of a nine-thousand-point ball is a long
+   * wait to find out — and it is the one worth asking, because it is where
+   * gravity that is only ever a shortening of a gap either does or does not
+   * come out looking like an orbit.
+   *
+   * What to watch is whether the closing keeps up with the carrying. Neither
+   * changes speed, ever; the drift is what it was set to and stays there. So
+   * the only question is whether the space between them is eaten as fast as
+   * their courses take them apart, and the three answers — they wind
+   * together, they part, or they hold — are all legible and none of them is
+   * arranged for.
+   */
+  {
+    name: 'two magnets, turning, with angular momentum',
+    span: WIDE,
+    cycle: PAIR_FOR,
+    note: 'Set going the same way round the middle. Nothing accelerates: what '
+      + 'brings them in is the gap being eaten while they carry on.',
+    sources: [
+      { at: [-APART, 0], lobes: 1, omega: SPIN, phase: 0, drift: [0, PACE] },
+      { at: [APART, 0], lobes: 1, omega: SPIN, phase: 0, drift: [0, -PACE] },
+    ],
+  },
+
+  /**
+   * And two set to miss each other, which is the fly-by, and the one case
+   * here that could come round.
+   *
+   * Given far more room than any of the others, and the room is the point. An
+   * orbit is a thing that needs somewhere to happen: the two have to be far
+   * enough apart that the gap between them survives being eaten for long
+   * enough to be carried round, and close enough passing that there is
+   * anything to carry. Set eight apart, as the lattice examples can afford,
+   * there is no such interval — light crosses, the gap goes, and they are
+   * together before either has been carried anywhere at all.
+   *
+   * The courses are straight and stay straight. Neither source is aimed at
+   * the other; each is sent along x on its own side of the line, so that
+   * left alone they would pass with the whole of `MISS` between them and go
+   * on for ever. What can happen instead is that the ground between them
+   * starts going while they are still crossing it, and the question — a real
+   * one, with a determinate answer nobody has arranged — is whether it goes
+   * fast enough to catch them and slowly enough to leave them anywhere to be
+   * carried to.
+   *
+   * Three outcomes, all legible. They close before they are past each other,
+   * and it is a collision with extra steps. They are past before enough is
+   * gone, and they leave. Or the gap shortens at about the rate their passing
+   * lengthens it, which is the whole of what an orbit is here — noting again
+   * that neither of them ever changes speed, so if this comes round it comes
+   * round without anything being accelerated by anything.
+   */
+  {
+    name: 'two sources, pulsing, passing at a distance',
+    span: ROOM,
+    cycle: PAIR_FOR,
+    note: 'Set to miss each other by a long way. Both courses stay straight; '
+      + 'it is the ground between them that goes.',
+    sources: [
+      { at: [-FAR, -MISS / 2], lobes: 0, omega: SPIN, phase: 0, drift: [PACE, 0] },
+      { at: [FAR, MISS / 2], lobes: 0, omega: SPIN, phase: 0, drift: [-PACE, 0] },
+    ],
+  },
+
+  /**
+   * Three of them, which is where this stops being arithmetic.
+   *
+   * Nothing in the rules changes. Every pair does exactly what a pair does —
+   * meets head-on, annihilates where opposite and turns round where alike,
+   * and loses the space between them at two cells a tick for as much of the
+   * meeting as cancels. Add a third and not one line of that is different.
+   * What is different is that there are now three gaps going at once, each at
+   * its own rate, and no symmetry left holding any of them.
+   *
+   * Which is the point of putting it here. Two of anything is a special case:
+   * whatever they do, they do it along the one line between them, and the
+   * whole configuration is that line's length. Three have a shape, and the
+   * shape can change — so this is the first arrangement in the article where
+   * the question "what happens" does not have an answer that could have been
+   * worked out from a single number.
+   *
+   * Set going the same way round a common centre, so what they carry is
+   * angular momentum rather than three approaches. Whether that survives the
+   * eating is a real question and it is the same one the pair asked, with the
+   * difference that a pair either closes or does not, and three can shed one
+   * and keep the other two. Nothing here is arranged to produce that. It is
+   * arranged to be legible if it happens.
+   *
+   * Worth watching for two things the pairs cannot show. Each source is
+   * eating with BOTH of the others at once, along two different lines, so
+   * what moves it is a sum of two contractions pointing different ways — and
+   * it will not point at either of them. And a wave leaving one of them meets
+   * whichever of the other two it runs into first, so the surface it stops at
+   * is no longer a plane: it is two planes, and which one applies depends on
+   * the direction it left in.
+   */
+  {
+    name: 'three sources, going round',
+    span: ROOM,
+    cycle: PAIR_FOR,
+    note: 'The same pairwise rule, three times over. Nothing is aimed at '
+      + 'anything; each carries on the way it was sent while the space '
+      + 'between all three of them goes.',
+    sources: [0, 1, 2].map(k => {
+      const turn = Math.PI / 2 + k * (Math.PI * 2) / 3;
+
+      return {
+        at: [RING * Math.cos(turn), RING * Math.sin(turn)] as [number, number],
+        lobes: 0 as const,
+        omega: SPIN,
+        phase: 0,
+        // Tangentially, all the same way round, so the three of them carry a
+        // rotation about the middle rather than three separate approaches.
+        drift: [-PACE * Math.sin(turn), PACE * Math.cos(turn)] as [number, number],
+      };
+    }),
+  },
+
+  /**
+   * And the same three aimed straight at one another.
+   *
+   * The other arrangement of three, and the one that isolates what the
+   * turning was doing. There every source was carrying past the other two
+   * while the ground went, and it was never clear how much of what happened
+   * was the eating and how much was the momentum. Here the momentum is
+   * pointed at the same place the eating is pulling, so the two agree, and
+   * whatever comes out is what these rules do when nothing is working against
+   * them.
+   *
+   * Which makes the arithmetic worth stating in advance, because it is
+   * checkable. Each pair loses two cells a tick for as much of what they send
+   * each other as cancels, so a side of the triangle goes at about a cell a
+   * tick from the eating alone; on top of that the two ends of it are already
+   * closing at nearly two cells a tick under their own steam. And every
+   * source is on two sides at once. The three should arrive together, at the
+   * middle, sooner than any pair in this article manages it.
+   *
+   * The thing to watch for is whether they arrive at a POINT. Three bodies
+   * aimed at one place have every reason to miss it — the least asymmetry in
+   * what each is emitting when puts one of the three gaps ahead of the other
+   * two, that pair closes first, and what was a collapse becomes a pair with
+   * a third thing falling towards it. Nothing here decides which. The phases
+   * are identical and the geometry is exact, so if they do not arrive
+   * together it is because the encounter itself is not stable, and that is a
+   * result rather than a fault.
+   */
+  {
+    name: 'three sources, aimed at each other',
+    span: ROOM,
+    cycle: PAIR_FOR,
+    note: 'The same three, sent inwards instead of round. Momentum and the '
+      + 'loss of space now agree, so nothing is holding them apart.',
+    sources: [0, 1, 2].map(k => {
+      const turn = Math.PI / 2 + k * (Math.PI * 2) / 3;
+
+      return {
+        at: [RING * Math.cos(turn), RING * Math.sin(turn)] as [number, number],
+        lobes: 0 as const,
+        omega: SPIN,
+        phase: 0,
+        // Straight at the middle, which is straight at the other two.
+        drift: [-PACE * Math.cos(turn), -PACE * Math.sin(turn)] as [number, number],
+      };
+    }),
+  },
+
+  /**
+   * Three turning magnets, not sent anywhere.
+   *
+   * The other two threes are about momentum — one carrying round, one aimed
+   * in — and both of them have sides that put out the same charge in every
+   * direction. This one takes the momentum away and gives them poles instead.
+   * Nothing is thrown at anything. The only thing that moves them is the
+   * space between them going, so whatever they end up doing is gravity
+   * unaccompanied, which is the thing the article is actually arguing about.
+   *
+   * And it is the first arrangement here where what each of them presents to
+   * the others is CHANGING. A pulsing source is the same all round, so a pair
+   * of them either cancel or they do not and that stays true. A magnet has a
+   * north and a south, and a turning magnet sweeps them past everything —
+   * so each of the three faces each of the others with something different
+   * every tick, and the three gaps go at three rates that are not only
+   * unequal but keep swapping which is largest.
+   *
+   * All three given the same phase, so they start pointing the same way and
+   * come round together. That is deliberate and it is not the same as facing
+   * each other: a pair with matching axes presents opposite poles across the
+   * gap, permanently, which is why the pair above eats so steadily. Three at
+   * the corners of a triangle cannot all do that with all of the others —
+   * there is no way to orient three things so that every pair is opposed —
+   * and what happens instead is the question. Some of the pairs are eating
+   * and some are bouncing, and which is which comes round with the axes.
+   */
+  {
+    name: 'three magnets, turning',
+    span: ROOM,
+    cycle: PAIR_FOR,
+    note: 'Three of them with poles, coming round together, sent nowhere. '
+      + 'Nothing moves them but the space between them going.',
+    sources: [0, 1, 2].map(k => {
+      const turn = Math.PI / 2 + k * (Math.PI * 2) / 3;
+
+      return {
+        at: [RING * Math.cos(turn), RING * Math.sin(turn)] as [number, number],
+        lobes: 1 as const,
+        omega: SPIN,
+        phase: 0,
+      };
+    }),
+  },
+
+  /**
+   * And the same fly-by again, moving as fast and emitting a fifth as often.
+   *
+   * One pulse every fifth tick, and everything else exactly as above: the
+   * same distance, the same miss, the same speed, the same rules. What
+   * changes is only how often the two have anything to say to each other.
+   *
+   * Which is not a small change, because it is the one term that was making
+   * capture inevitable. A source travels at a third of a cell a tick, and a
+   * pair pulsing every tick has a meeting every tick, each meeting taking two
+   * cells out of the gap. Two cells a tick against a third of one: the eating
+   * was six times quicker than the moving, no amount of distance was going to
+   * outrun it, and every pair above ends up together with the only question
+   * being how long it took.
+   *
+   * A pulse every fifth tick is a meeting every fifth tick, so the gap goes
+   * at two fifths of a cell a tick — and nothing has been slowed down to
+   * achieve it. The two are carried exactly as far as they were. For the
+   * first time in any of these the two rates are within reach of each other,
+   * and the outcome stops being obvious.
+   *
+   * It is worth being clear that nothing here is tuned to produce an orbit.
+   * The beat is a property of the source — how often it lets go of a shell —
+   * and the speed is a property of its mass. Two independent facts about a
+   * thing, whose ratio decides whether it falls in, escapes, or comes round.
+   * Which is the shape of the question every orbiting system asks, arrived at
+   * here with no force anywhere in it.
+   *
+   * There is a second thing this makes visible, which the filled field could
+   * not. With four cells of nothing between one ring and the next, most of
+   * the space between the two sources is space where neither of them has
+   * anything, and the eating happens in bursts as the rings pass through each
+   * other rather than continuously. The gap does not shorten smoothly. It
+   * shortens whenever two shells arrive at the same place, and holds still in
+   * between, which is what a discrete rule looks like when it is still
+   * discrete.
+   */
+  {
+    name: 'the same, pulsing every fifth tick',
+    span: ROOM,
+    cycle: PAIR_FOR,
+    note: 'Moving every tick, emitting every fifth one. A fifth as many '
+      + 'meetings, so the gap goes a fifth as fast — and the two are carried '
+      + 'just as far while it does.',
+    sources: [
+      { at: [-FAR, -MISS / 2], lobes: 0, omega: SPIN, phase: 0, drift: [PACE, 0], beat: 5 },
+      { at: [FAR, MISS / 2], lobes: 0, omega: SPIN, phase: 0, drift: [-PACE, 0], beat: 5 },
+    ],
+  },
+];
+
+// The four states one end of a two-point universe can be in: its polarity,
+// and whether its ray moves into the connection or away from it.
+const SIDE_STATES: PairSide[] = [
+  { polarity: Polarity.Positive, moving: 'towards' },
+  { polarity: Polarity.Positive, moving: 'away' },
+  { polarity: Polarity.Negative, moving: 'towards' },
+  { polarity: Polarity.Negative, moving: 'away' },
+];
+
+// Every combination of those two ends. `j >= i` drops mirror images — a
+// universe and its left-right reflection run identically, so listing both
+// would only duplicate the same experiment. Drop the slice for all 16.
+const PAIRS: { a: PairSide, b: PairSide }[] = SIDE_STATES.flatMap((a, i) =>
+  SIDE_STATES.slice(i).map(b => ({ a, b }))
+);
+
+type Pair = { a: PairSide, b: PairSide };
+
+// Identity of a pair up to mirroring: whichever ordering of its two ends
+// sorts first, since a universe and its reflection are the same experiment.
+const pairKey = ({ a, b }: Pair) => {
+  const end = (s: PairSide) => `${s.polarity}${s.moving}`;
+  const [x, y] = [`${end(a)}|${end(b)}`, `${end(b)}|${end(a)}`];
+  return x < y ? x : y;
+};
+
+// The anti-universe: every polarity flipped, every movement direction kept.
+const anti = ({ a, b }: Pair): Pair => {
+  const flip = (s: PairSide): PairSide => ({
+    polarity: s.polarity === Polarity.Positive ? Polarity.Negative : Polarity.Positive,
+    moving: s.moving,
+  });
+
+  return { a: flip(a), b: flip(b) };
+};
+
+// Pairs grouped with their own anti-pair, so the two sit one above the other.
+// Head-on opposite polarities (and away-from-each-other opposite polarities)
+// are their own anti up to mirroring, so those groups hold a single pair.
+const ANTI_GROUPS: Pair[][] = (() => {
+  const byKey = new Map(PAIRS.map(p => [pairKey(p), p]));
+  const taken = new Set<string>();
+  const groups: Pair[][] = [];
+
+  for (const pair of PAIRS) {
+    const key = pairKey(pair);
+    if (taken.has(key)) continue;
+    taken.add(key);
+
+    const group = [pair];
+
+    const opposite = pairKey(anti(pair));
+    if (!taken.has(opposite) && byKey.has(opposite)) {
+      taken.add(opposite);
+      group.push(byKey.get(opposite)!);
+    }
+
+    groups.push(group);
+  }
+
+  return groups;
+})();
+
+// The same four states a side of a pair can be in, named against the line
+// rather than against a partner.
+const LINE_STATES: LineSide[] = [
+  { polarity: Polarity.Positive, moving: 'right' },
+  { polarity: Polarity.Positive, moving: 'left' },
+  { polarity: Polarity.Negative, moving: 'right' },
+  { polarity: Polarity.Negative, moving: 'left' },
+];
+
+// Every arrangement of n charges in a row: each of them either polarity, each
+// of them going either way. 4ⁿ of them before the symmetries are taken out.
+const linesOf = (n: number): LineSide[][] =>
+  n === 0
+    ? [[]]
+    : linesOf(n - 1).flatMap(rest => LINE_STATES.map(side => [side, ...rest]));
+
+// Read back to front with every direction reversed, a line is the same
+// experiment watched from the other end.
+const mirrored = (line: LineSide[]): LineSide[] =>
+  [...line].reverse().map(s => ({
+    polarity: s.polarity,
+    moving: s.moving === 'left' ? 'right' : 'left',
+  }));
+
+const opposite = (p: Polarity): Polarity =>
+  p === Polarity.Positive ? Polarity.Negative : Polarity.Positive;
+
+// Every polarity flipped, every direction kept: the anti-line.
+const antiLine = (line: LineSide[]): LineSide[] =>
+  line.map(s => ({ polarity: opposite(s.polarity), moving: s.moving }));
+
+// Identity up to mirroring: whichever way round the line reads first.
+const lineKey = (line: LineSide[]): string => {
+  const read = (l: LineSide[]) => l.map(s => `${s.polarity}${s.moving}`).join(",");
+  const [x, y] = [read(line), read(mirrored(line))];
+
+  return x < y ? x : y;
+};
+
+/**
+ * The distinct lines among the given ones, each grouped with its anti-line so
+ * the two sit one above the other — the same experiment run on matter and on
+ * antimatter. A line that is its own anti up to mirroring is a group of one.
+ */
+const antiGroups = (lines: LineSide[][]): LineSide[][][] => {
+  const byKey = new Map<string, LineSide[]>();
+  for (const line of lines) {
+    const key = lineKey(line);
+    if (!byKey.has(key)) byKey.set(key, line);
+  }
+
+  const taken = new Set<string>();
+  const groups: LineSide[][][] = [];
+
+  for (const [key, line] of byKey) {
+    if (taken.has(key)) continue;
+    taken.add(key);
+
+    const group = [line];
+
+    const opposite = lineKey(antiLine(line));
+    if (!taken.has(opposite) && byKey.has(opposite)) {
+      taken.add(opposite);
+      group.push(byKey.get(opposite)!);
+    }
+
+    groups.push(group);
+  }
+
+  return groups;
+};
+
+// Every arrangement of n charges, grouped with its anti.
+const lineGroups = (n: number): LineSide[][][] => antiGroups(linesOf(n));
+
+/**
+ * One side of a head-on collision: `size` charges all going the same way,
+ * their polarity flipping from one to the next. `inner` is the polarity of
+ * the one at the interface, and the block alternates outward from there —
+ * so what a block is doing at the meeting point is what names it, and the
+ * rest of it follows.
+ */
+const alternatingBlock = (size: number, inner: Polarity, moving: 'left' | 'right'): LineSide[] => {
+  const outward = Array.from({ length: size }, (_, i) => ({
+    polarity: i % 2 === 0 ? inner : opposite(inner),
+    moving,
+  }));
+
+  // Written from the interface outward. A block moving right sits to the left
+  // of the interface, so it reads the other way round along the line.
+  return moving === 'right' ? outward.reverse() : outward;
+};
+
+/**
+ * Two alternating blocks run at each other. Once the alternation is fixed the
+ * only freedom left is the phase of each block — which polarity it presents
+ * at the interface — so these four are all of them:
+ *
+ *   ..0101 → ← 1010..  the alternation carries straight through the meeting
+ *                      point; the line is one alternating line, cut in two and
+ *                      told to move at itself.
+ *   ..1010 → ← 1010..  both blocks in the same phase; the alternation breaks
+ *                      exactly where they meet, and the two innermost charges
+ *                      are alike rather than opposite.
+ *
+ * and the anti of each. Head-on opposites annihilate and head-on likes turn
+ * around, so the phase decides whether the interface eats the line or reflects
+ * it — and after the first tick the block behind is one step further in, with
+ * its own phase to present.
+ */
+const COLLISION_PHASES: [Polarity, Polarity][] = [
+  [Polarity.Positive, Polarity.Negative],
+  [Polarity.Negative, Polarity.Positive],
+  [Polarity.Positive, Polarity.Positive],
+  [Polarity.Negative, Polarity.Negative],
+];
+
+const collision = (size: number, [left, right]: [Polarity, Polarity]): LineSide[] => [
+  ...alternatingBlock(size, left, 'right'),
+  ...alternatingBlock(size, right, 'left'),
+];
+
+// The distinct collisions of two alternating blocks of `size`, grouped with
+// their antis. Mirroring identifies the two through-alternating phases, so
+// what is left is: alternation-through, and alternation-broken with its anti.
+const collisionGroups = (size: number): LineSide[][][] =>
+  antiGroups(COLLISION_PHASES.map(phases => collision(size, phases)));
+
+/**
  * A block with no phase to it: `size` charges all going the same way, each
  * polarity drawn on its own. There is nothing to name such a block by — every
  * draw is a different block — so what it says about an interface is only what
@@ -7249,6 +9267,26 @@ const RayCalculiAndPhysics = () => {
           </Fragment>
         ))}
 
+        {/* And the same dynamics again, written down instead of run.
+
+            Everything above this is the model: points, a local rule, and a
+            field reconstructed afterwards from where the points ended up.
+            What follows is the closed form of what that model makes — one
+            cosine per source, evaluated at every pixel, with no simulation
+            behind it and nothing to reconstruct. It is not a cheaper way of
+            getting the pictures above; it is a different claim, and the value
+            of it is in where the two disagree.
+
+            Cheap, though, and that shows: there is no state carried between
+            frames and no tick, so t is a real number and the waves travel
+            smoothly rather than a cell at a time. */}
+        {CONTINUOUS_CASES.map(({ name, note, sources, span, cycle }) => (
+          <div key={`continuous-${name}`} style={{ marginBottom: '1.5rem' }}>
+            <ContinuousField sources={sources} span={span} cycle={cycle} height={320} />
+            <Caption>{name} — {note}</Caption>
+          </div>
+        ))}
+
         {ANTI_GROUPS.map((group, i) => (
           <div key={i} style={{ marginBottom: '1.5rem' }}>
             {group.map((pair, j) => (

From 9f03605175b2c29235ff868b415121dae0a0338b Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Fri, 7 Aug 2026 20:31:56 +0200
Subject: [PATCH 13/47] Orbiting examples

---
 .../archive/2026.RayCalculiAndPhysics.tsx     | 539 ++++++++++++++++--
 1 file changed, 497 insertions(+), 42 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
index 86f018c..81f3e53 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
@@ -7646,6 +7646,243 @@ const survey = (live: Live[], t: number, reach: number, span: number) => {
  * body's own motion is untouched and its speed never changes. It is carried,
  * and what carries it is not uniform.
  */
+/**
+ * The space itself, kept between ticks, and how fast it is going.
+ *
+ * Everything before this treated gravity as a speed: work out where
+ * annihilation is happening, work out how fast that drags each source, move
+ * it that far, throw the answer away and do it again next tick. Which cannot
+ * be right, and the discrete rule says why. `annihilate` does not push
+ * anything. It rewires — the point behind one dying charge is spliced
+ * directly onto the point behind the other — and it STAYS rewired. The state
+ * is in the space, not in the bodies, and a speed recomputed from scratch
+ * every tick is precisely a model with no state in the space at all.
+ *
+ * So the space gets a displacement of its own, `h`, which is how far each
+ * place has been carried from where it started, and it is kept. Annihilation
+ * adds to it and nothing takes it away: once the ground between two things
+ * has gone, it has gone, and they are nearer whether or not anything is still
+ * eating.
+ *
+ * And `h` is given a wave equation rather than being applied where it is
+ * made. A contraction here has to reach a place over there, and it has to
+ * take the time light takes — so the field obeys
+ *
+ *     d²h/dt² = c² ∇²h + S
+ *
+ * with S the annihilation. Ripples in `h` then travel outward at exactly c,
+ * which is what a gravitational wave is: not a thing added to the model, but
+ * what persistence and a finite speed give you together the moment you stop
+ * applying the answer instantly and everywhere. Neither alone produces one.
+ *
+ * A grid fixed for the whole run, unlike the survey's, which re-frames on the
+ * pair every tick. A field that is carried from one tick to the next cannot
+ * be resampled onto a moving grid without smearing everything it remembers.
+ */
+type Warp = {
+  hx: Float32Array; hy: Float32Array;             // where each place has got to
+  vx: Float32Array; vy: Float32Array;             // and how fast it is going
+  sx: Float32Array; sy: Float32Array;             // what is driving it this tick
+  n: number; x0: number; y0: number; step: number;
+};
+
+const warp = (span: number): Warp => {
+  // Forty across is enough to carry a wave and cheap enough to ask the
+  // calibrated flow at every one of its places, once a tick.
+  const n = 40;
+  const step = (2 * span) / n;
+
+  return {
+    hx: new Float32Array(n * n), hy: new Float32Array(n * n),
+    vx: new Float32Array(n * n), vy: new Float32Array(n * n),
+    sx: new Float32Array(n * n), sy: new Float32Array(n * n),
+    n, x0: -span, y0: -span, step,
+  };
+};
+
+// Read between the grid's places, since it is asked at arbitrary points.
+const WARP: [number, number] = [0, 0];
+
+const warpAt = (w: Warp, a: Float32Array, b: Float32Array, x: number, y: number) => {
+  const fx = Math.min(Math.max((x - w.x0) / w.step, 0), w.n - 1.001);
+  const fy = Math.min(Math.max((y - w.y0) / w.step, 0), w.n - 1.001);
+
+  const i = Math.floor(fx), j = Math.floor(fy);
+  const u = fx - i, v = fy - j;
+
+  const k = j * w.n + i;
+
+  WARP[0] = (a[k] * (1 - u) + a[k + 1] * u) * (1 - v)
+    + (a[k + w.n] * (1 - u) + a[k + w.n + 1] * u) * v;
+  WARP[1] = (b[k] * (1 - u) + b[k + 1] * u) * (1 - v)
+    + (b[k + w.n] * (1 - u) + b[k + w.n + 1] * u) * v;
+};
+
+/**
+ * One step of it.
+ *
+ * The annihilation found this tick is laid down as the source term — the same
+ * shape `flowAt` used to hand straight to the sources, put into the field
+ * instead — and then the field is left to carry it. The Laplacian is the
+ * plain five-point one, which is all a wave equation on a grid needs, and the
+ * time step is a fraction of a cell against a speed of one, so it is nowhere
+ * near the limit where that would misbehave.
+ *
+ * A little damping, because nothing here should ring for ever: an annihilation
+ * that has finished leaves its displacement behind, which is the point, but
+ * the SPEED it left the space with has to die away or the picture keeps
+ * sloshing long after anything is happening.
+ */
+const warpStep = (w: Warp, dt: number) => {
+  const { hx, hy, vx, vy, sx, sy, n, step } = w;
+
+  /**
+   * What the space would be doing here if the annihilation acted at once,
+   * which is what the survey has already been calibrated to give.
+   *
+   * Used as the speed the field is DRAWN TOWARDS rather than as a force added
+   * to it — which keeps the one number that ties this to the discrete rule.
+   * `survey` scales the sites so that a pair whose every meeting cancels
+   * would close at two cells a tick, and if that were integrated as an
+   * acceleration the speed would simply grow past it and the calibration
+   * would mean nothing. Relaxed towards, the near field settles at exactly
+   * the rate the rule gives, and everything the wave equation adds is what
+   * happens on the way there and further out.
+   */
+  for (let j = 0; j < n; j++) {
+    for (let i = 0; i < n; i++) {
+      const k = j * n + i;
+
+      flowAt(w.x0 + i * step, w.y0 + j * step);
+
+      sx[k] = FLOW[0]; sy[k] = FLOW[1];
+    }
+  }
+
+  // A step of the wave equation: the Laplacian carries it, at exactly the
+  // speed of light in the units everything else here is in.
+  const c2 = LIGHT * LIGHT / (step * step);
+  const pull = 2.5;
+
+  for (let j = 1; j < n - 1; j++) {
+    for (let i = 1; i < n - 1; i++) {
+      const k = j * n + i;
+
+      const lx = hx[k - 1] + hx[k + 1] + hx[k - n] + hx[k + n] - 4 * hx[k];
+      const ly = hy[k - 1] + hy[k + 1] + hy[k - n] + hy[k + n] - 4 * hy[k];
+
+      vx[k] += (c2 * lx + (sx[k] - vx[k]) * pull) * dt;
+      vy[k] += (c2 * ly + (sy[k] - vy[k]) * pull) * dt;
+    }
+  }
+
+  // And the displacement keeps what the speed has given it. Nothing takes it
+  // back: once the ground has gone it has gone.
+  for (let k = 0; k < hx.length; k++) { hx[k] += vx[k] * dt; hy[k] += vy[k] * dt; }
+};
+
+/**
+ * How steeply the ground falls away here.
+ *
+ * The flow has exactly one scalar in it — how fast the space is going — and
+ * the slope of half its square is where everything else comes from. That is
+ * not a choice: a flow which is the gradient of something obeys
+ * `(u . grad) u = grad(|u|^2 / 2)`, and `(u . grad) u` is what a thing sitting
+ * still in the coordinates is carried by as the flow it is standing in
+ * accelerates. So the slope of `|u|^2 / 2` IS the free-fall acceleration, and
+ * it is the same quantity Newton called the gradient of a potential — a river
+ * running in at `sqrt(2M/r)` has half its square equal to `M/r` exactly.
+ *
+ * Which means nothing here is imported. The rule is still that annihilation
+ * takes two cells out of the space between whatever is annihilating. The flow
+ * is what that does to the space. And a falloff nobody put in — the whole
+ * inverse-square of it — is sitting in that flow already, waiting to be
+ * differentiated.
+ *
+ * Read over three quarters of a cell either side, which is wide enough to see
+ * past the survey's own grid and narrow enough to still be local.
+ */
+const NUDGE = 0.75;
+
+const river = (w: Warp, x: number, y: number) => {
+  warpAt(w, w.vx, w.vy, x, y);
+
+  return (WARP[0] * WARP[0] + WARP[1] * WARP[1]) / 2;
+};
+
+const FALL: [number, number] = [0, 0];
+
+const fallAt = (w: Warp, x: number, y: number) => {
+  FALL[0] = -(river(w, x + NUDGE, y) - river(w, x - NUDGE, y)) / (2 * NUDGE);
+  FALL[1] = -(river(w, x, y + NUDGE) - river(w, x, y - NUDGE)) / (2 * NUDGE);
+};
+
+/**
+ * What movement itself does to the space it is moving through.
+ *
+ * `consumeAhead` is a SWAP: the ray takes the point in front of it and that
+ * point ends up behind. So anything going anywhere is laying space down
+ * behind itself at exactly the rate it takes it up in front, one cell for
+ * every cell it goes — and the space it crosses is not merely crossed, it is
+ * carried from one end of the thing to the other.
+ *
+ * Which is the other half of what happens between two sources. The
+ * annihilation between them takes space OUT and draws them together. The
+ * motion of each puts space BACK, behind it, and pushes them apart. Where
+ * those balance is where a pair neither closes nor escapes.
+ *
+ * Two things about how this is written, and both were got wrong first.
+ *
+ * It is never its own. A thing does not feel its own wake: the taking in
+ * front and the laying behind are not two forces on it that happen to cancel
+ * — they are what its moving IS, and `vel` already counts them. Put on the
+ * grid with everything else, where there is no way to ask whose wake a place
+ * is in, each source read its own and got a shove forward of about two thirds
+ * of its own pace on top of its own pace, every tick, compounding through the
+ * field. That is a rocket, and it showed as sources tearing away in the
+ * direction they were already going.
+ *
+ * And it is retarded, off the same trail `emit` uses. A wake is news, and
+ * news travels at one cell a tick like everything else here.
+ */
+const WAKE: [number, number] = [0, 0];
+
+// How far in front the taking happens and how far behind the laying: one
+// point either side, in a lattice whose points are one apart.
+const SWAP = 0.5;
+
+const wakeAt = (s: Live, x: number, y: number, t: number) => {
+  WAKE[0] = 0; WAKE[1] = 0;
+
+  const when = retard(s, x, y, t);
+  if (!isFinite(when)) return;
+
+  wasGoing(s, when);
+
+  const px = RETARD[0], py = RETARD[1];
+  const pace = Math.hypot(CARRY[0], CARRY[1]);
+  if (pace < 1e-9) return;
+
+  const ax = CARRY[0] / pace, ay = CARRY[1] / pace;
+
+  // A point of space being made pushes what is around it away; a point being
+  // taken up draws it in. Movement is one of each, half a cell apart, and far
+  // off the two very nearly cancel — which is exactly right, and is why a
+  // swap is not a source of anything. Near to, they do not.
+  for (let k = 0; k < 2; k++) {
+    const side = k ? -SWAP : SWAP;
+    const sign = k ? 1 : -1;
+
+    const ex = x - (px + ax * side), ey = y - (py + ay * side);
+
+    const r = Math.hypot(ex, ey);
+    if (r < SWAP) continue;
+
+    WAKE[0] += sign * pace * ex / (r * 2 * Math.PI * r);
+    WAKE[1] += sign * pace * ey / (r * 2 * Math.PI * r);
+  }
+};
+
 const FLOW: [number, number] = [0, 0];
 
 const flowAt = (x: number, y: number) => {
@@ -7680,6 +7917,29 @@ const flowAt = (x: number, y: number) => {
     FLOW[0] -= (q / 2) * side * fade * nx;
     FLOW[1] -= (q / 2) * side * fade * ny;
   }
+
+  /**
+   * And no place of space goes faster than light, whatever the sites add up
+   * to.
+   *
+   * Not a safety rail — it is the same rule everything else here obeys, and
+   * without it the calibration in `survey` has a hole in it. That divides by
+   * how fast the sites it found happen to close the pair, and when the two
+   * are nearly touching, or arranged so that what is being eaten is mostly
+   * off to the side of the line between them, the measured closing goes to
+   * almost nothing while the rate the rule asks for does not. The quotient
+   * runs away. Measured on the fly-by that pulses every fifth tick, the flow
+   * carrying a source reached three hundred and fifty thousand cells a tick
+   * and the pair were flung four hundred cells apart in forty.
+   *
+   * Held to light, the same arrangement simply closes as fast as anything can
+   * close and no faster. The pair still meet, the gap still goes at two cells
+   * a tick between them, and the number that used to be unbounded is now the
+   * one bound this whole model has.
+   */
+  const going = Math.hypot(FLOW[0], FLOW[1]);
+
+  if (going > LIGHT) { FLOW[0] *= LIGHT / going; FLOW[1] *= LIGHT / going; }
 };
 
 // A 4x4 ordered pattern, centred on nought and worth about one level of an
@@ -7755,8 +8015,11 @@ const ContinuousField = ({
     // and nothing about where they stay.
     let live: Live[] = [];
 
+    let field = warp(latest.current.span);
+
     const reset = () => {
       t = 0;
+      field = warp(latest.current.span);
       live = latest.current.sources.map(s => ({
         ...s,
         at: [...s.at] as [number, number],
@@ -7930,23 +8193,19 @@ const ContinuousField = ({
      * A source goes on going the way it was going, because nothing here
      * accelerates anything. The space it is in is carried by `flowAt`,
      * wherever annihilation is shortening it. And the source's own direction
-     * is turned by the same flow — not by being pushed, but because a
-     * direction is a displacement per tick and the space that displacement
-     * lives in is being sheared underneath it.
+     * is turned by how steeply that flow falls away — not by being pushed,
+     * but because a straight line through ground that is running downhill
+     * across it does not stay straight.
      *
-     * The turning is the gradient of the flow, taken as a difference over
-     * half a cell either side. Nothing about the speed appears in it: a
-     * velocity carried through a shear comes out pointing elsewhere, at
-     * whatever length the shear leaves it, and the drift is renormalised back
-     * to the speed it was given so that this stays a change of direction and
-     * never becomes a change of pace.
+     * The turning is `fallAt`, taken across the direction of travel only, so
+     * that a change of direction is all it can ever be. Nothing here changes
+     * speed.
      *
      * They stop when they are adjacent, which is not a fudge to keep them
      * apart: a source is not space, so there is nothing left between them to
      * annihilate and nothing either could move through if there were.
      */
     const TOUCH = 1;                              // as close as adjacent gets
-    const NUDGE = 0.5;                            // cells, for reading a gradient
 
     function pull(dt: number) {
       const span = latest.current.span;
@@ -7956,51 +8215,76 @@ const ContinuousField = ({
       // this nothing asks about sources again — only about places.
       survey(live, t, reach, span);
 
-      // The flow as it stands, before anything has moved in it.
+      // What the annihilation does to the space, carried forward and let
+      // travel. See `warpStep` — this is where gravity now lives.
+      warpStep(field, dt);
+
+      /**
+       * And what each source is carried by is the SPEED of the space it is
+       * standing in, not the annihilation happening elsewhere at this moment.
+       *
+       * Which is the whole difference. A contraction over there reaches here
+       * when the wave carrying it does, and having arrived it leaves this
+       * place displaced for good — so a source goes on being where the space
+       * put it after the eating has stopped, and feels nothing at all from an
+       * annihilation whose news has not yet arrived.
+       */
       const carry = live.map(s => {
-        flowAt(s.at[0], s.at[1]);
+        warpAt(field, field.vx, field.vy, s.at[0], s.at[1]);
+
+        let cx = WARP[0], cy = WARP[1];
 
-        return [FLOW[0], FLOW[1]] as [number, number];
+        // And what the others have laid down behind them. Never its own —
+        // see `wakeAt`.
+        for (const o of live) {
+          if (o === s) continue;
+
+          wakeAt(o, s.at[0], s.at[1], t);
+
+          cx += WAKE[0]; cy += WAKE[1];
+        }
+
+        return [cx, cy] as [number, number];
       });
 
-      const turned = live.map((s, i) => {
+      const turned = live.map(s => {
         /**
-         * Turned along the way it is ACTUALLY going, which is its own motion
-         * and the flow carrying it, together.
+         * Turned by the slope of the ground, and only across the way it is
+         * going.
          *
-         * Taken along `vel` alone, as it was, this asks how the flow varies
-         * down a line the source is not travelling on. For anything with a
-         * drift that is merely the wrong line; for anything without one it is
-         * no line at all, and the whole thing gave up at the first test —
-         * so a pair set going by nothing but gravity had its direction left
-         * entirely alone, and gravity could displace them but never steer
-         * them. Which is exactly the complaint: the middle alive, and the two
-         * of them never coming round to face each other.
+         * The part of that slope pointing along the direction of travel is
+         * dropped before anything is added, which is what keeps this a
+         * turning and not a pull. Renormalising afterwards would have hidden
+         * the difference and did: what used to be here took the flow's change
+         * along the line of travel, which for a river running straight in is
+         * a change of length and no change of angle at all, and then handed
+         * that length to the renormalisation to be thrown away. Measured, it
+         * delivered a hundredth of what an orbit needs and most of that
+         * parallel — so a pair sent past each other flew past each other, the
+         * line between them swung forty degrees the way any two things
+         * passing would, and stopped. Which is exactly the complaint: no
+         * orbit, just a flyby with the arithmetic of one.
+         *
+         * Across the direction of travel there is nothing to throw away.
+         * `fallAt` is the free-fall acceleration and a component of it
+         * perpendicular to a velocity can only rotate that velocity — so the
+         * speed is left exactly alone by construction, and the
+         * renormalisation below is now just tidying the second-order error of
+         * a finite step rather than doing the work.
          */
-        const goX = s.vel[0] + carry[i][0], goY = s.vel[1] + carry[i][1];
-
         const speed = Math.hypot(s.vel[0], s.vel[1]);
-        const going = Math.hypot(goX, goY);
-        if (going < 1e-9) return s.vel;
-
-        // How the flow differs a little either way along the direction it is
-        // going: that difference, over that distance, is what turns it.
-        const hx = goX / going, hy = goY / going;
+        if (speed < 1e-9) return s.vel;
 
-        flowAt(s.at[0] + hx * NUDGE, s.at[1] + hy * NUDGE);
-        const ax = FLOW[0], ay = FLOW[1];
+        fallAt(field, s.at[0], s.at[1]);
 
-        flowAt(s.at[0] - hx * NUDGE, s.at[1] - hy * NUDGE);
+        const hx = s.vel[0] / speed, hy = s.vel[1] / speed;
+        const along = FALL[0] * hx + FALL[1] * hy;
 
-        const gx = (ax - FLOW[0]) / (2 * NUDGE), gy = (ay - FLOW[1]) / (2 * NUDGE);
+        const vx = s.vel[0] + (FALL[0] - along * hx) * dt;
+        const vy = s.vel[1] + (FALL[1] - along * hy) * dt;
 
-        let vx = s.vel[0] + gx * going * dt;
-        let vy = s.vel[1] + gy * going * dt;
-
-        // Turned, never sped up or slowed down. A source with no drift of its
-        // own has nothing to keep the length of, and stays at nothing.
         const now = Math.hypot(vx, vy);
-        if (now < 1e-9 || speed < 1e-9) return s.vel;
+        if (now < 1e-9) return s.vel;
 
         return [vx * speed / now, vy * speed / now] as [number, number];
       });
@@ -8163,6 +8447,25 @@ const WIDE = 40;
 // How far out the three sit from their common centre. Their sides are RING
 // times root three, so light takes about that long to cross between any two
 // of them and nothing at all happens before it has.
+/**
+ * How fast a pair has to be going to go round rather than into each other.
+ *
+ * Measured, and the measurement is the only reason this number is what it is.
+ * Sent past each other from twenty-four cells out and run for three hundred
+ * and twenty ticks, the line between the pair turns:
+ *
+ *     0.45c    644 degrees, and then it is gone — the gap reaches 123
+ *     0.40c    971 degrees, gap 22 to 53, drifting slowly outwards
+ *     0.35c   1088 degrees, gap 16 to 52, three full turns and still going
+ *
+ * So there is an interval, it is narrow, and this is inside it. Faster and
+ * the two are never caught; slower and they are caught at once. Nothing was
+ * solved for to find it — the rates that fix it are the source's own pace,
+ * the annihilation's two cells a meeting, and what the motion lays back down
+ * behind itself, and where those cross is where an orbit is possible.
+ */
+const ORBIT = 0.35 * LIGHT;
+
 const RING = 30;
 
 const FAR = 52;
@@ -8323,6 +8626,158 @@ const CONTINUOUS_CASES: {
     ],
   },
 
+  /**
+   * Two of them pulsing slowly, which is the one that shows how they move.
+   *
+   * Every other pair here emits without pause, so the space between them is
+   * being eaten continuously and they slide together smoothly. Smooth is the
+   * worst possible thing to watch if the question is HOW gravity gets from
+   * one of them to the other, because a smooth pull looks exactly like a
+   * force reaching across the gap, which is what this model says there is no
+   * such thing as.
+   *
+   * Set far apart and pulsing slowly, what it shows instead is the delay,
+   * and it shows it as plainly as anything here can. Nothing whatever
+   * happens for the first thirty-odd ticks — measured, the gap does not move
+   * by a hundredth of a cell — and then the two begin to close. That pause is
+   * not the model waiting for anything. It is light crossing half the gap to
+   * the meeting, and the news of what happened there crossing back, and there
+   * being no other way for either to travel. A force would have started at
+   * once.
+   *
+   * And what arrives does not slide back. The displacement is kept rather
+   * than recomputed, so what the space has given up stays given up: they hold
+   * wherever the last wave left them. Two things are visible in that which no
+   * instantaneous pull can show — that gravity here is CARRIED, and that it
+   * is carried at exactly the speed of the light these things emit.
+   *
+   * What it does not show, and it is worth saying so, is a staircase. The
+   * beat is twelve ticks and the field follows the annihilation more quickly
+   * than that, so the closing comes out smooth rather than as a series of
+   * kicks. Whether the space between two things should shorten in steps or
+   * continuously is a real question about the model, and this arrangement
+   * does not answer it — it only shows that whichever it is, it starts late.
+   */
+  {
+    name: 'two sources, pulsing slowly',
+    span: 34,
+    cycle: PAIR_FOR,
+    note: 'Nothing at all for thirty ticks, and then they close. The pause '
+      + 'is light crossing to the middle and back — a force would not wait.',
+    sources: [
+      { at: [-26, 0], lobes: 0, omega: SPIN, phase: 0, beat: 12 },
+      { at: [26, 0], lobes: 0, omega: SPIN, phase: 0, beat: 12 },
+    ],
+  },
+
+  /**
+   * Two of them that actually go round each other.
+   *
+   * Every other pair in this article either falls together or leaves, and the
+   * reason is a ratio. A source at `PACE` travels at ninety-nine hundredths
+   * of the speed of its own light, so two of them sent past one another part
+   * at nearly two cells a tick — and the space between them goes at two cells
+   * a tick at the very most, when every single thing that arrives cancels.
+   * Set that fast, nothing is ever caught. Set slow with nothing else
+   * changed, everything is caught at once.
+   *
+   * Between the two there is an interval, and `ORBIT` is in it. Run for three
+   * hundred and twenty ticks the pair go round 1088 degrees — three full
+   * turns and part of a fourth — with the gap between them running from 16 at
+   * the tightest to 52 at the widest and neither of them ever leaving the
+   * frame.
+   *
+   * Two things hold it up and they pull opposite ways.
+   *
+   * The annihilation between them takes space out, and that is what draws
+   * them in. Measured with a pair held still and the field let settle, what
+   * it comes to at each of them is 0.03 cells a tick at a gap of 8, 0.16 at
+   * 24 and 0.40 at 32 — which is worth stopping on, because it goes the wrong
+   * way round. This is not Newton's pull, getting weaker with distance. It
+   * gets STRONGER with distance, like a spring, and that is a consequence of
+   * the rule rather than a choice: a meeting costs two cells however far
+   * apart the two things meeting are, so what varies with the gap is not the
+   * cost but how much of each field is in the other's way. A pull shaped like
+   * that has bound orbits everywhere and unbound ones nowhere, which is
+   * exactly what these runs do.
+   *
+   * And the motion puts space BACK. `consumeAhead` is a swap — a cell taken
+   * in front is a cell laid down behind — so anything going anywhere is
+   * refilling the space it leaves at the rate it leaves it, and that pushes
+   * outwards against the eating. See `WAKE`. It is the smaller of the two by
+   * a long way, and it is not nothing: with it the tightest the pair get is
+   * 22 cells rather than 20, so the floor of the orbit is set by the swap and
+   * the ceiling by the eating.
+   *
+   * What is worth being clear about is what is NOT holding it up. Neither of
+   * these ever changes speed. There is no force here in the sense of a thing
+   * that could push something faster — each carries on at exactly the pace it
+   * was sent, for ever, and `turned` takes the component of the fall ACROSS
+   * the way it is going and throws the rest away before adding anything. What
+   * comes round is the DIRECTION. An orbit here is not a balance of a pull
+   * against an inertia. It is a straight line through ground that keeps
+   * turning under it.
+   *
+   * And that ground takes time to hear about anything, so this is an orbit
+   * with a delay in it — which is why the first thing the two do is get
+   * FURTHER apart, 48 out to 50. They are already moving when the run starts
+   * and nothing can act on them until light has crossed the gap and come
+   * back. They part first, and are caught afterwards.
+   */
+  {
+    name: 'two sources, in orbit',
+    span: 34,
+    cycle: 320,
+    note: 'Sent past each other at a third of light, and they go round — '
+      + 'nearly three times. Neither ever changes speed; only the direction '
+      + 'comes round, because the ground it is crossing falls away.',
+    sources: [
+      { at: [-24, 0], lobes: 0, omega: SPIN, phase: 0, drift: [0, ORBIT] },
+      { at: [24, 0], lobes: 0, omega: SPIN, phase: 0, drift: [0, -ORBIT] },
+    ],
+  },
+
+  /**
+   * The same thing, but nothing about it set up to work.
+   *
+   * The pair above is a construction: two identical sources, mirrored, sent
+   * exactly across the line between them at exactly the same pace, so that
+   * whatever holds them has a symmetry to hold. That is the honest way to
+   * show a mechanism and a poor way to show that it is real, because a
+   * balance which only exists on the axis of a symmetry is usually the
+   * symmetry and not the balance.
+   *
+   * So: magnets rather than plain sources, which means `lobes = 1` and a
+   * field that carries an angle and winds. Turning opposite ways, so there is
+   * no rotational symmetry either. Different paces — one at `ORBIT` and one
+   * half again as fast — and different distances out, so the centre of the
+   * thing is nowhere in particular. And neither of them aimed across the line
+   * between them: both are sent off at an angle to it.
+   *
+   * Nothing here is solved for. What it has in common with the pair above is
+   * only that both speeds are in the interval `ORBIT` names, and that is the
+   * whole claim being made — that the interval is a property of the rules and
+   * not of the arrangement.
+   */
+  {
+    name: 'two magnets, mixed speeds, in orbit',
+    span: 40,
+    cycle: 320,
+    note: 'Different speeds, different distances out, winding opposite ways '
+      + 'and neither sent square to the line between them. It still goes '
+      + 'round, which is the point.',
+    sources: [
+      {
+        at: [-20, -6], lobes: 1, omega: SPIN, phase: 0,
+        drift: [ORBIT * 0.34, ORBIT * 0.94] as [number, number],
+      },
+      {
+        at: [26, 4], lobes: 1, omega: -SPIN, phase: Math.PI / 3,
+        drift: [-ORBIT * 1.5 * 0.42, -ORBIT * 1.5 * 0.91] as [number, number],
+      },
+    ],
+  },
+
   /**
    * Three of them, which is where this stops being arithmetic.
    *

From 12cea764e0b1ee69327db281ecfd6accfa24bce0 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sat, 8 Aug 2026 14:17:00 +0200
Subject: [PATCH 14/47] Break apart the file

---
 orbitmines.com/app/archive/[item]/page.tsx    |    2 +-
 .../archive/2026.RayCalculiAndPhysics.tsx     | 9831 -----------------
 .../2026.RayCalculiAndPhysics/GraphCanvas.tsx | 2390 ++++
 .../2026.RayCalculiAndPhysics/canvas.tsx      |  214 +
 .../2026.RayCalculiAndPhysics/continuous.tsx  | 1792 +++
 .../2026.RayCalculiAndPhysics/discrete.ts     | 3237 ++++++
 .../2026.RayCalculiAndPhysics/index.tsx       |   44 +
 .../2026.RayCalculiAndPhysics/lattice.ts      |  304 +
 .../2026.RayCalculiAndPhysics/lines.ts        |  160 +
 .../2026.RayCalculiAndPhysics/model.ts        |  199 +
 .../2026.RayCalculiAndPhysics/models.ts       |  790 ++
 .../2026.RayCalculiAndPhysics/paint.ts        |  111 +
 .../2026.RayCalculiAndPhysics/views.tsx       |  257 +
 .../2026.RayCalculiAndPhysics/visible.ts      |   35 +
 14 files changed, 9534 insertions(+), 9832 deletions(-)
 delete mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/canvas.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lines.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/visible.ts

diff --git a/orbitmines.com/app/archive/[item]/page.tsx b/orbitmines.com/app/archive/[item]/page.tsx
index 4c3699d..6791dd9 100644
--- a/orbitmines.com/app/archive/[item]/page.tsx
+++ b/orbitmines.com/app/archive/[item]/page.tsx
@@ -13,7 +13,7 @@ export const ITEM_SOURCES: Record<string, string> = {
   'on-orbits-equivalence-and-inconsistencies': 'src/routes/archive/2023.OnOrbits.tsx',
   'towards-a-universal-language': 'src/routes/archive/2025.TowardsAUniversalLanguage.tsx',
   'the-orbitmines-minecraft-server': 'src/routes/archive/2026.MinecraftArchive.tsx',
-  'ray-calculi-and-physics': 'src/routes/archive/2026.RayCalculiAndPhysics.tsx',
+  'ray-calculi-and-physics': 'src/routes/archive/2026.RayCalculiAndPhysics/index.tsx',
 };
 
 // Reads the reference object's `title` literal so the static <title> is owned
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
deleted file mode 100644
index 81f3e53..0000000
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics.tsx
+++ /dev/null
@@ -1,9831 +0,0 @@
-import { ON_INTELLIGIBILITY, RAY_CALCULI_AND_PHYSICS } from "../references";
-import REFERENCES from "../profiles/fadi-shawki/fadi_shawki";
-
-import { useNavigate } from "react-router-dom";
-import Post, {
-  BR,
-  PaperProps,
-  Reference,
-  Section,
-  useCounter,
-  CodeBlock,
-  Row,
-  JetBrainsMono, BlueprintIcons20, BlueprintIcons16,
-  Arc,
-  Block
-} from "../../lib/post/Post";
-import { Fragment, useEffect, useMemo, useRef, useState } from "react";
-import { Button } from "@blueprintjs/core";
-
-// A boundary now carries a polarity instead of an annihilation/creation op.
-// Neutral is what space is when nothing has happened to it yet: it is what
-// gets instantiated as something moves — ahead of it at a boundary of the
-// structure, and behind it as it goes — rather than a charge drawn at random.
-enum Polarity {
-  Positive,
-  Negative,
-  Neutral
-}
-
-// One end of a two-point universe: the polarity of its boundaries, and
-// whether its ray moves into the connection or away from it.
-type PairSide = {
-  polarity: Polarity;
-  moving: 'towards' | 'away';
-};
-
-// One charge in a line of them: its polarity, and which way along the line it
-// goes. With more than two there is no "towards each other" to name a
-// direction by, so the line itself is what they are named against.
-type LineSide = {
-  polarity: Polarity;
-  moving: 'left' | 'right';
-};
-
-// One source in a space with directions to spare: what it emits, which of
-// those directions it is itself going in, and whether it starts turned the
-// same way round as the other one or the other way.
-//
-// `moving` is a lattice step, not a named side. With twenty-six ways out of a
-// point there is no "left" to mean anything, so a direction has to be said in
-// full — and saying it in full is what lets the two be set going across each
-// other rather than only at each other.
-type MagnetSide = {
-  emits: Polarity;
-  moving?: number[];
-  phase?: number;
-
-  /**
-   * Which way round it is, if it is a magnet rather than a lamp.
-   *
-   * Without this a source puts the same charge out in all twenty-six
-   * directions and turns the lot over together — something that alternates,
-   * but with no sides to it. A magnet has sides: `emits` goes out of the half
-   * pointing along this, its opposite out of the half pointing against, and
-   * the ring exactly across it puts out nothing at all. Turning it over swaps
-   * the two, which is what `spin` was always meant to be doing to something.
-   *
-   * It matters for two magnets facing each other because it decides what
-   * arrives. Both given the same axis, the face of one that looks at the
-   * other is its north and the face looking back is the other's south — so
-   * what crosses the gap is opposite to what it meets, every tick, and
-   * opposite charges meeting is the one event that destroys space.
-   */
-  axis?: number[];
-
-  /**
-   * Which way round it turns, if it turns: +1 or −1, and nothing for a magnet
-   * held still.
-   *
-   * `spin` flips a source's poles over on the spot — north becomes south,
-   * south becomes north, and nothing has moved. Turning is the other thing,
-   * and the one a magnet actually does: the axis itself comes round, so north
-   * is somewhere else than it was, and a direction that was looking at the
-   * north pole is looking at the equator a moment later and at the south pole
-   * after that.
-   *
-   * Which means a turning magnet needs no `spin` at all. Standing anywhere
-   * off its axis you are swept by north, then nothing, then south, then
-   * nothing — an alternation that is a consequence of the thing going round
-   * rather than a property stipulated of it. That is where the waves come
-   * from here, and unlike flipping in place it has a handedness: two magnets
-   * can turn the same way or against each other, and what crosses the gap
-   * between them depends on which.
-   */
-  turning?: 1 | -1;
-
-  // The plane it turns in, as the two directions it turns between. Anything
-  // in three dimensions, not only the one the code happens to be written
-  // around — two magnets can be set turning in different planes, which is a
-  // thing only a 3D world can be asked.
-  plane?: [number[], number[]];
-};
-
-/**
- * A turn, in a space that has eight directions to a plane.
- *
- * These are the in-plane directions in order round the circle, so stepping
- * along the list by one is a rotation of an eighth of a turn and stepping by
- * eight is back where it started. It is the whole of what "rotating" can mean
- * on a lattice: there is no angle between neighbouring directions to subdivide
- * further, and a magnet whose axis moved by less than this would not have
- * moved at all.
- */
-/**
- * The eight of them, in whatever plane is asked for.
- *
- * A turn is only ever a turn in a plane, and a plane is two directions to
- * turn between. Given those, this walks the circle they span in eighths and
- * rounds each step onto the nearest direction the lattice actually has — so a
- * magnet can come round in the xy-plane, or the xz, or about any diagonal,
- * and the axis it sweeps is the axis it was given rather than the one the
- * code was written with.
- *
- * The default is x towards y, which is the plane the two sources are laid out
- * in, so a pair of them turn in the plane they face each other across.
- */
-function turnRing(u: number[] = [1, 0, 0], v: number[] = [0, 1, 0]): number[][] {
-  const out: number[][] = [];
-
-  for (let k = 0; k < 8; k++) {
-    const a = (k / 8) * Math.PI * 2;
-    const c = Math.cos(a), s = Math.sin(a);
-
-    const dir = u.map((x, i) => x * c + (v[i] ?? 0) * s);
-    const step = latticeStep(dir.map(x => (Math.abs(x) < 0.3827 ? 0 : x)));
-
-    if (step) out.push(step);
-  }
-
-  return out;
-}
-
-const TURN = turnRing();
-
-/**
- * How many ticks a source takes to come back to what it was doing.
- *
- * The same for every kind of source, which is the whole point of it. A
- * rotation through the eight directions of a plane and a flip held half the
- * time each way are both one cycle, and both lay their structure down at the
- * same spacing: a wave advances a cell a tick, so a cycle of this many ticks
- * puts the same charge every this many cells — bands half that wide with the
- * same again between them, whether those bands come out as rings or as
- * spirals.
- */
-const CYCLE = TURN.length;
-
-/**
- * How much harder a source is to move than the charges it emits: a multiple
- * of the step's own length, paid out of the same one-per-tick everything else
- * is paid (see the movement half of `tick`). It is mass, arrived at from the
- * only direction this model offers — the cost of going somewhere.
- *
- * A source at mass m covers 1/m cells a tick. Two conditions decide whether a
- * moving pair can interact at all, and both are arithmetic rather than
- * judgement:
- *
- *  - One step a tick is this model's top speed — a ray moves at most once per
- *    tick, so nothing goes faster and the field cannot be sped up to keep
- *    pace. Two sources heading opposite ways separate at 2/m, and their light
- *    closes at 1, so anything each emits can only ever reach the other while
- *    2/m < 1. At m = 1 they are outrunning their own field from the first
- *    tick; at m = 2 the light exactly keeps pace and never gains. It takes
- *    m > 2 before a pulse can cross from one to the other at all.
- *
- *  - And a source can only emit onto a point it is connected to. Once it has
- *    travelled out of the seeded ball it is in territory `grow` laid down one
- *    node at a time as it went, with nothing on the far side of its other
- *    twenty-five directions, so it stops radiating in all but the one it is
- *    heading in. Over a 60-tick run it moves 60/m, and starting 8 out along x
- *    it stays inside the absorbing edge at 11 while √(8² + (60/m)²) ≤ 11 —
- *    which wants m ≥ 8.
- *
- * Eight, then. Not a tuned number: it is the smaller mass the two conditions
- * allow, and below it a moving pair stops interacting partway through for one
- * of those two reasons rather than for any reason to do with the physics.
- */
-const MAGNET_MASS = 3;
-
-class Universe {
-  static _2D = () => Universe.nD_Expanding(2);
-  static _3D = () => Universe.nD_Expanding(3);
-  static nD_Expanding = (d: number) => { }
-
-  //TODO Should probably be something occilating instead of random
-  static random<T>(arr: T[]): T {
-    return arr[Math.floor(Math.random() * arr.length)];
-  }
-
-  static randomPolarity() {
-    return Math.random() < 0.5 ? Polarity.Positive : Polarity.Negative;
-  }
-
-  // A fresh order, so that what interacts with what is a draw rather than an
-  // artefact of the order things happen to sit in.
-  static shuffle<T>(arr: T[]): T[] {
-    const out = arr.slice();
-
-    for (let i = out.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [out[i], out[j]] = [out[j], out[i]];
-    }
-
-    return out;
-  }
-}
-
-// Two rays meeting head-on, over the connection whose mutual boundaries are
-// `a` and `b`. Opposite charges cancel; like ones turn around. Movement isn't
-// here because it isn't an interaction: it is what a ray does when nothing is
-// coming the other way.
-type Interaction = {
-  kind: 'annihilate' | 'turn';
-  r: Ray; a: Boundary;
-  r2: Ray; b: Boundary;
-};
-
-// World units per lattice step. Shared by the layout and by the renderer,
-// which needs it to place boundaries that have a direction but no neighbour.
-const LATTICE_STEP = 50;
-
-// How far along its connection a boundary is drawn, as a fraction. Both ends
-// draw one, so they meet with a gap of 1 - 2×this in between. The viewport
-// fit uses it too, so that what it measures is what gets drawn.
-const BOUNDARY_STUB = 0.25;
-
-function stepAway(from: number[], to: number[]): number[] {
-  return from.map((v, i) =>
-    v + Math.sign(to[i] - v)
-  );
-}
-
-/**
- * The direction a lattice offset names, as the shortest step that goes that
- * way: every component in {-1, 0, 1}.
- *
- * (1,0,0) is already one step. (3,0,0) is the same direction, three steps at
- * a time — which is what a connection looks like once the space it used to
- * pass through has been annihilated out of it. (2,2,0) is the diagonal
- * (1,1,0).
- *
- * This is what keeps a direction a direction rather than a distance. It is
- * also what a boundary with no neighbour has to hold: `outward` is a way to
- * go, and a way to go is one step, however far apart the last two points that
- * went that way happened to end up.
- */
-function latticeStep(offset: number[]): number[] | undefined {
-  const norm = Math.max(...offset.map(Math.abs));
-  if (!norm) return undefined;
-
-  return offset.map(v => Math.round(v / norm));
-}
-
-/**
- * Every way out of a point: all 3^d − 1 non-zero offsets with components in
- * {-1, 0, 1}. In 2D that is the eight directions of a compass rose; in 3D the
- * twenty-six ways off a cell — six through a face, twelve through an edge,
- * eight through a corner.
- *
- * This is what "360°" is when space is discrete. Not a circle cut into 360
- * pieces: a lattice has exactly as many directions as a point has neighbours,
- * and the honest thing is to take all of them rather than the six that happen
- * to line up with the axes. A point wired only to its faces cannot be moved
- * through diagonally, so a wave leaving it can only ever go six ways, and
- * anything built on that is a cross rather than a sphere.
- *
- * The price is that the directions are not the same length — a face step
- * covers 1, an edge step √2, a corner step √3 — so a pulse emitted into all
- * of them at once, one step per tick, is a cube shell and not a round one.
- * That IS the sphere of this space: the set of points one move away.
- */
-// The subset of those that lie along an axis: the 2d faces of a cell. A
-// lattice wired only with these is the one everything up to here has run on.
-function axes(dims: number): number[][] {
-  const out: number[][] = [];
-
-  for (let axis = 0; axis < dims; axis++)
-    for (const dir of [-1, 1]) {
-      const v = new Array(dims).fill(0);
-      v[axis] = dir;
-      out.push(v);
-    }
-
-  return out;
-}
-
-function directions(dims: number): number[][] {
-  const out: number[][] = [];
-
-  (function build(prefix: number[]) {
-    if (prefix.length === dims) {
-      if (prefix.some(v => v !== 0)) out.push(prefix);
-      return;
-    }
-
-    for (const v of [-1, 0, 1]) build([...prefix, v]);
-  })([]);
-
-  return out;
-}
-
-class Graph {
-  buffer: node[] = []
-
-  nodes: node[] = []
-
-  coords = new Map<node, number[]>()
-
-  gridPos = new Map<node, number[]>();
-
-  // gridPos read the other way round, so that "what is at this coordinate"
-  // isn't a scan over the whole universe. Positions are real-valued and two
-  // points can briefly share one, so this is last-writer-wins: it is an
-  // index, and `gridPos` above is the truth it indexes.
-  private at = new Map<string, node>();
-
-  private static posKey(pos: number[]): string {
-    return pos.map(v => Math.round(v * 1e6)).join(",");
-  }
-
-  // Every write to a position goes through these, so the index can never
-  // fall behind the thing it indexes.
-  private setPos(nd: node, pos: number[]) {
-    this.unindex(nd);
-    this.gridPos.set(nd, pos);
-    this.at.set(Graph.posKey(pos), nd);
-  }
-
-  private delPos(nd: node) {
-    this.unindex(nd);
-    this.gridPos.delete(nd);
-  }
-
-  private unindex(nd: node) {
-    const was = this.gridPos.get(nd);
-    if (!was) return;
-
-    const key = Graph.posKey(was);
-    if (this.at.get(key) === nd) this.at.delete(key);
-  }
-
-  // Lattice dimensionality and the seed's initial radius (used only by the
-  // cube→sphere layout morph now).
-  dims = 3;
-  ringRadius = 0;
-
-  /**
-   * What the camera is for, if it isn't for everything: a radius in grid
-   * coordinates, and everything inside it is the subject.
-   *
-   * A universe that grows has no fixed size to frame, and framing whatever is
-   * currently furthest out means the picture zooms out to chase whichever
-   * charge has got the furthest — so the thing being watched shrinks away in
-   * the middle while nothing much happens at the edges.
-   *
-   * It has to be a region rather than a list of the points that were there at
-   * the start, because those points do not stay. Moving is a swap with space:
-   * every charge that goes anywhere eats a point of the original ball and
-   * leaves a new one behind it. Name the seed's points and within a few ticks
-   * you are framing a handful of survivors; name the seed's extent and you
-   * are framing the same place throughout, whatever is currently in it.
-   */
-  focus?: number;
-
-  inFocus(nd: node): boolean {
-    if (this.focus === undefined) return true;
-
-    const pos = this.gridPos.get(nd);
-
-    return !!pos && Math.hypot(...pos) <= this.focus;
-  }
-
-  /**
-   * How often a ray takes one of the ways its direction is made of, instead
-   * of the direction itself. Nought is movement strictly conserved, which is
-   * what everything before this ran on.
-   *
-   * A direction like (1,1,1) is not one thing: it is three axial steps taken
-   * at once, and a point that can go that way can also go any of the three
-   * separately, or any of them backwards. So at each move a ray either
-   * carries on along the whole diagonal or takes one of the pieces it is
-   * composed of — chosen at random, with the pieces' opposites in the draw
-   * too, so it can give ground on an axis as well as gain it.
-   *
-   * What that buys is the thing a field made of travelling charges needs and
-   * did not have: a path that can curve. Movement conserved exactly means a
-   * ray leaves its source in one of twenty-six directions and is committed to
-   * it forever, so two streams either coincide or never touch, and no line
-   * can go looking for anything. Wandering makes a trajectory a random walk
-   * with a drift down its original direction, which spreads it over the space
-   * between — and since annihilation removes exactly those that find their
-   * opposite, what survives to be seen is selected by what met. The lines
-   * find each other by searching and being culled where they succeed, rather
-   * than by being aimed.
-   *
-   * The drift is what keeps it a field rather than a fog: the whole diagonal
-   * is one option among its pieces, and the pieces' opposites cancel in the
-   * average, so the mean step still points the way it set out.
-   */
-  wander = 0;
-
-  /**
-   * No holes, ever.
-   *
-   * A direction with nothing on the far side of it is a way out of the
-   * lattice. In a line that is exactly right — the end of a line is where you
-   * can walk off it, and growing the structure by moving into nothing is how
-   * these universes expand. In a closed lattice it is a tear, and every rule
-   * that removes a point has been quietly making them: hundreds a tick, tens
-   * of thousands over a run, all of them in the region where the two fields
-   * are trying to reach each other.
-   *
-   * Sealed, a direction is a direction TO something. Take away what it
-   * pointed at and it is not a direction any more — it is dropped, and
-   * whatever else the vanished point joined stays joined (`closeUp`). Nothing
-   * is ever left facing nowhere, so nothing can leak out through a face that
-   * was never there, and the space contracts instead of coming apart.
-   *
-   * Off by default: the line and grid seeds are open worlds with real edges,
-   * and they need to be able to grow.
-   */
-  sealed = false;
-
-  // A direction that is not one any more.
-  private drop(bd: Boundary) {
-    bd.target = undefined;
-    bd.outward = undefined;
-    bd.at.boundaries = bd.at.boundaries.filter(x => x !== bd);
-  }
-
-  // Left pointing at nothing — dropped in a sealed world, kept as a bare way
-  // out in an open one.
-  private loose(bd: Boundary) {
-    if (this.sealed) { this.drop(bd); return; }
-
-    const d = this.bare(bd);
-    bd.target = undefined;
-    bd.outward = d;
-  }
-
-  // Whether the drawn positions are the coordinates, or the structure.
-  //
-  // Off, a point is drawn where its coordinate says it is, and space that has
-  // been annihilated out of the world leaves a hole in the picture. On, the
-  // picture is relaxed against the connections that actually exist, so a
-  // connection that has closed up over destroyed space pulls its two ends
-  // together — which is the whole of what attraction is here.
-  relax = false;
-
-  // Monotonic tick counter.
-  _tickId = 0;
-
-  /**
-   * What just happened, and where.
-   *
-   * Every interaction in this model is over in the tick it occurs in: two
-   * charges cancel and the points they were are gone, or two turn round and
-   * are indistinguishable a moment later from two that were always going that
-   * way. Drawn only as the state they leave behind, the events themselves are
-   * invisible — the picture shows a field that is quietly a bit smaller than
-   * it was, and never shows the cancelling that made it so.
-   *
-   * So each one is noted as it happens, at the place it happened, and kept
-   * for a tick or two afterwards. Nothing in the dynamics reads this; it is
-   * the record, not the thing.
-   */
-  events: { at: Vec, kind: 'annihilate' | 'turn', tick: number }[] = [];
-
-  /**
-   * A count of what the last tick consisted of.
-   *
-   * A universe of a dozen points can be read off the picture. One of several
-   * thousand cannot: "nothing seems to be happening any more" has half a
-   * dozen quite different causes — the sources have stopped emitting, or
-   * everything has jammed and nothing can move, or things are moving fine and
-   * simply never meeting — and they look identical from outside. These are
-   * the numbers that tell them apart.
-   */
-  stats = { emitted: 0, moved: 0, blocked: 0, annihilated: 0, turned: 0, path: 0, holes: 0 };
-
-  // How far apart the two sources have been, tick by tick.
-  history: number[] = [];
-
-  // And the way between them as it currently runs.
-  route: node[] = [];
-
-  /**
-   * How far it is from one source to the other — in steps through the
-   * structure, not in coordinates.
-   *
-   * This is the measurement the whole thing is for, and it is the only one
-   * that answers the question without argument. Coordinates say nothing: the
-   * sources sit at the coordinates they were seeded at and will do forever,
-   * whether or not anything has happened between them. The picture is
-   * suggestive but it is a solve, and a solve can be stiff, or slow, or
-   * simply drawn small.
-   *
-   * The number of points you have to pass through to get from one to the
-   * other is neither. It starts at whatever the seed made it, and it goes
-   * down when and only when the space between them is annihilated. If two
-   * things gravitate in this model, THIS is what it means, and if it doesn't
-   * fall then nothing else on screen is attraction however much it looks
-   * like it.
-   */
-  shortestPath(): node[] {
-    const sources: node[] = [];
-    for (const nd of this.nodes) if (nd.some(r => r.magnet)) sources.push(nd);
-    if (sources.length < 2) return [];
-
-    const [from, to] = sources;
-    const cameFrom = new Map<node, node>([[from, from]]);
-
-    let frontier = [from];
-
-    while (frontier.length) {
-      const next: node[] = [];
-
-      for (const nd of frontier) {
-        for (const ray of nd) {
-          for (const bd of ray.boundaries) {
-            const other = bd.target?.at.node;
-            if (!other || cameFrom.has(other)) continue;
-
-            cameFrom.set(other, nd);
-
-            if (other === to) {
-              const route = [other];
-              while (route[0] !== from) route.unshift(cameFrom.get(route[0])!);
-
-              return route;
-            }
-
-            next.push(other);
-          }
-        }
-      }
-
-      frontier = next;
-    }
-
-    return []; // no way from one to the other at all
-  }
-
-  private mark(kind: 'annihilate' | 'turn', ...rays: Ray[]) {
-    const at: Vec[] = [];
-
-    for (const ray of rays) {
-      const p = this.relaxed?.at.get(ray.node) ?? this.layoutCache?.get(ray.node);
-      if (p) at.push(p);
-    }
-
-    if (!at.length) return;
-
-    const centre = new Array(at[0].length).fill(0);
-    for (const p of at)
-      for (let k = 0; k < centre.length; k++) centre[k] += p[k] / at.length;
-
-    this.events.push({ at: centre, kind, tick: this._tickId });
-  }
-
-  // Something the seed has arranged for the world to go on doing, run at the
-  // start of every tick before the rules get their say. Nothing in the rules
-  // needs one — it is how a source that is never itself an event gets to be
-  // one, which is the only way to ask what a thing that keeps emitting does
-  // to the space around it.
-  onTick?: (graph: Graph) => void;
-
-  get edges(): [node, node][] {
-    const seen = new Set<string>();
-    const edges: [node, node][] = [];
-
-    for (const a of this.nodes) {
-      for (const ray of a) {
-        for (const boundary of ray.boundaries) {
-          const target = boundary.target;
-          if (!target) continue;
-
-          const b = target.at.node;
-          if (a === b) continue;
-
-          const ia = this.nodes.indexOf(a);
-          const ib = this.nodes.indexOf(b);
-
-          const key =
-            ia < ib
-              ? `${ia},${ib}`
-              : `${ib},${ia}`;
-
-          if (!seen.has(key)) {
-            seen.add(key);
-            edges.push([a, b]);
-          }
-        }
-      }
-    }
-
-    return edges;
-  }
-
-  connect(a: node, b: node) {
-    // Connect every boundary in a to the first boundary in b.
-    const target = b[0].boundaries[0];
-
-    for (const ray of a)
-      for (const boundary of ray.boundaries)
-        boundary.target = target;
-  }
-
-  // How far and which way a boundary reaches, in grid units. A bare direction
-  // says so itself; a connection is the offset from the point it is on to the
-  // point on the other side, which after an annihilation can be several steps
-  // rather than one.
-  private offset(bd: Boundary): number[] | undefined {
-    if (bd.outward) return bd.outward;
-
-    const from = this.gridPos.get(bd.at.node);
-    const to = bd.target && this.gridPos.get(bd.target.at.node);
-    if (!from || !to) return undefined;
-
-    return to.map((v, i) => v - from[i]);
-  }
-
-  // Which way a boundary points, as a unit vector — for comparing directions
-  // against each other, where only the way they face matters.
-  private direction(bd: Boundary): number[] | undefined {
-    const offset = this.offset(bd);
-    if (!offset) return undefined;
-
-    const length = Math.hypot(...offset);
-
-    return length ? offset.map(v => v / length) : undefined;
-  }
-
-  /**
-   * The same direction as one step of the lattice — components in {-1, 0, 1}.
-   *
-   * This is what goes into a position (a new point is put down one step over,
-   * not a unit distance over, which off the axes is not the same thing) and
-   * what a boundary with nothing on the far side is left holding. A unit
-   * vector would be neither: in a 360° discrete space the corner directions
-   * have length √3, and normalising them puts new points at coordinates the
-   * lattice doesn't have.
-   */
-  private bare(bd: Boundary): number[] | undefined {
-    const offset = this.offset(bd);
-
-    return offset && latticeStep(offset);
-  }
-
-  // The boundary of `ray` pointing most nearly along `dir` (`sign` of -1 for
-  // most nearly opposite). Movement is conserved rather than reselected, so
-  // whenever a ray has to change which boundary it moves along, it does the
-  // thing closest to carrying straight on — or, turning around, closest to
-  // coming straight back.
-  private along(ray: Ray, dir: number[] | undefined, sign: 1 | -1, exclude?: Boundary): Boundary | undefined {
-    const options = ray.boundaries.filter(b => b !== exclude);
-    if (!options.length) return undefined;
-    if (!dir) return options[0];
-
-    let best: Boundary | undefined;
-    let bestDot = -Infinity;
-
-    for (const option of options) {
-      const d = this.direction(option);
-      if (!d) continue;
-
-      const dot = sign * d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
-      if (dot > bestDot) { bestDot = dot; best = option; }
-    }
-
-    return best ?? options[0];
-  }
-
-  /**
-   * Which way is behind us: the boundary pointing most nearly opposite to the
-   * one we are moving along. Only a genuinely backward direction counts — a
-   * perpendicular one is beside us, not behind us — so a ray with nothing
-   * behind it gets `undefined` and the space it sheds into has to be made.
-   */
-  private behind(ray: Ray, dir: number[] | undefined, exclude: Boundary): Boundary | undefined {
-    if (!dir) return undefined;
-
-    let best: Boundary | undefined;
-    let bestDot = 0.1; // has to actually point back, not sideways
-
-    for (const option of ray.boundaries) {
-      if (option === exclude) continue;
-
-      const d = this.direction(option);
-      if (!d) continue;
-
-      const dot = -d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
-      if (dot > bestDot) { bestDot = dot; best = option; }
-    }
-
-    return best;
-  }
-
-  // The point sitting at a grid position, if there is one. Positions are
-  // real-valued (space instantiated between two points lands at their
-  // midpoint), so this is a tolerance match rather than a key lookup.
-  private nodeAt(pos: number[]): node | undefined {
-    const found = this.at.get(Graph.posKey(pos));
-    if (!found) return undefined;
-
-    const p = this.gridPos.get(found);
-
-    return p && p.length === pos.length && p.every((v, i) => Math.abs(v - pos[i]) < 1e-6)
-      ? found
-      : undefined;
-  }
-
-  /**
-   * The directions of a point that lie ACROSS the way we are going.
-   *
-   * The axis we are travelling on never changes hands: it is the thing being
-   * travelled, and taking it would tear the line we are moving along in two.
-   * Everything else is what a point IS as opposed to where it is, and it is
-   * exactly what gets handed over as something moves through.
-   */
-  private transverse(rays: Ray[], dir: number[] | undefined, exclude?: Boundary): Boundary[] {
-    if (!dir) return [];
-
-    const out: Boundary[] = [];
-
-    for (const ray of rays) {
-      for (const bd of ray.boundaries) {
-        if (bd === exclude) continue;
-
-        const d = this.direction(bd);
-        if (!d) continue;
-
-        const along = Math.abs(d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0));
-        if (along < 0.9) out.push(bd);
-      }
-    }
-
-    return out;
-  }
-
-  // The same directions, held by somewhere else now.
-  private hand(taken: Boundary[], onto: Ray) {
-    for (const bd of taken) {
-      bd.at.boundaries = bd.at.boundaries.filter(x => x !== bd);
-      bd.at = onto;
-      onto.boundaries.push(bd);
-    }
-  }
-
-  /**
-   * Two opposite charges meeting head-on: they cancel, and the space they
-   * were goes with them.
-   *
-   * Not by being destroyed — space is never destroyed here, it is handed
-   * backwards. Everything each of them held across the line they met on goes
-   * to the point behind it, the two of them are spliced out of that line, and
-   * what was behind them closes up directly onto what was behind the other.
-   * Nothing comes apart: there is simply less space than there was, and what
-   * that space was carrying is still carried.
-   *
-   * With nothing behind either of them there is nowhere backwards to hand
-   * anything to, so the two collapse onto each other instead — one neutral
-   * point left holding everything both of them held. A row of charges
-   * annihilating pair by pair therefore ends as exactly that one point.
-   */
-  private annihilate(r: Ray, a: Boundary, r2: Ray, b: Boundary, removed: Set<node>) {
-    const dirA = this.direction(a), dirB = this.direction(b);
-
-    const backA = this.behind(r, dirA, a), backB = this.behind(r2, dirB, b);
-
-    // What was behind each — but never a source. A source is not somewhere
-    // space can be put down; it is the thing space is coming out of. Handing
-    // it what a dying charge was carrying leaves it holding connections to
-    // half the world, which it then radiates down, and every one of those
-    // comes back to leave more. Treated as nothing behind, the structure goes
-    // to the other side, or the two collapse onto each other as they do when
-    // there is nowhere behind either.
-    const behindA = backA?.target?.at;
-    const behindB = backB?.target?.at;
-
-    const homeA = behindA?.magnet ? undefined : behindA;
-    const homeB = behindB?.magnet ? undefined : behindB;
-
-    /**
-     * The connection between the two of them, severed first of all.
-     *
-     * It is the one thing this event actually destroys, and it has to go
-     * before anything else is decided — both of its ends are on points that
-     * are about to stop existing, so any rule that tries to preserve it later
-     * preserves a connection to a corpse. Done here, every branch below is
-     * dealing only with connections that genuinely survive.
-     *
-     * Meeting head-on that is `a` and `b`. Arriving at the same place from
-     * different directions there is no such connection at all — `a` leads to
-     * the point they were both making for, which is somebody else and stays.
-     */
-    for (const bd of [a, b]) {
-      const partner = bd.target;
-      if (!partner || (partner.at !== r && partner.at !== r2)) continue;
-
-      partner.target = undefined;
-      bd.target = undefined;
-    }
-
-    if (homeA || homeB) {
-      /**
-       * Everything each of them held goes to the point behind it.
-       *
-       * Not just what it held across its line of travel — everything, bar the
-       * two that this event is actually about: the connection between the two
-       * of them, which is what they were approaching each other along and is
-       * the one thing here that genuinely ceases to exist, and the connection
-       * to the point behind, which is where all of it is going and so becomes
-       * internal to that.
-       *
-       * Handing only the transverse part is what leaves the rest to be
-       * guessed at, and every version of that guess loses something: a
-       * direction with no readable heading gets dropped, two that lead to the
-       * same neighbour refuse to pair, and the point on the other end of them
-       * quietly loses a connection it never gave up. Measured, that is
-       * hundreds of points falling below three connections and some to none
-       * at all, cut out of the world by an event two cells away.
-       *
-       * Handed wholesale, nothing has to be decided and nothing can be lost.
-       * The point stops existing; what it was holding is held by the place
-       * behind it; and every point that was connected to it is still
-       * connected to exactly as much as it was.
-       */
-      // Everything either of them is still joined to, bar the way back —
-      // which is where all of it is going, and so becomes internal to that.
-      // The approach between them is already severed, so it cannot be here.
-      const inherit = (dying: Ray, back: Boundary | undefined, onto: Ray) =>
-        this.hand(dying.boundaries.filter(bd => bd !== back && bd.target), onto);
-
-      inherit(r, backA, homeA ?? homeB!);
-      inherit(r2, backB, homeB ?? homeA!);
-
-      // The line closes up: what was behind one is now directly onto what was
-      // behind the other.
-      const pa = backA?.target, pb = backB?.target;
-
-      if (pa && pb) {
-        pa.target = pb;
-        pb.target = pa;
-      } else for (const p of [pa, pb]) {
-        if (!p) continue;
-
-        // Nothing on the far side to close onto, so the direction is all that
-        // is left of what used to be there — and in a sealed world, not even
-        // that.
-        this.loose(p);
-      }
-
-      this.discard(r, homeA ?? homeB!, removed);
-      this.discard(r2, homeB ?? homeA!, removed);
-
-      return;
-    }
-
-    // Nowhere behind either of them: everything the two were carrying ends up
-    // on one point, which is all that is left of both — and here that one
-    // point is the place behind, there being no other.
-    this.hand(r2.boundaries.filter(bd => bd.target), r);
-
-    r.boundaries = r.boundaries.filter(x => x !== a);
-    this.discard(r2, r, removed);
-
-    r.moving = undefined;
-    for (const bd of r.boundaries) bd.polarity = Polarity.Neutral;
-  }
-
-  /**
-   * A point that is no longer anywhere.
-   *
-   * Whatever it was carrying has already gone wherever it was going; this is
-   * only the removal. Anything still pointing at it is left holding the bare
-   * direction — the way is still that way, there is just nothing there — and
-   * anything still sitting on it goes wherever its structure went.
-   */
-  /**
-   * A point stops being anywhere, and every way through it closes up.
-   *
-   * Whatever was on one side of it and whatever was on the other are now
-   * directly connected — the connection still exists, it is simply shorter
-   * now by the point that is no longer in it. Done for all thirteen axes
-   * through the point rather than only the one something happened to be
-   * travelling along, because a point in a lattice is in the middle of
-   * thirteen lines at once and every one of them has to survive losing it.
-   *
-   * Only a direction with nothing coming the other way is left bare, and that
-   * is a genuine edge of the world rather than a tear in it.
-   */
-  private closeUp(boundaries: Boundary[], of: Ray) {
-    const facing = new Map<string, Boundary>();
-    const waiting: Boundary[] = [];
-
-    const join = (x: Boundary, y: Boundary) => {
-      x.target = y;
-      x.outward = undefined;
-      y.target = x;
-      y.outward = undefined;
-    };
-
-    for (const bd of boundaries) {
-      const partner = bd.target;
-
-      // Only if it is still pointing back at us: a connection that has
-      // already been closed up onto something else is not ours to break.
-      if (!partner || partner.target !== bd) continue;
-
-      const step = this.bare(bd);
-      if (!step) { waiting.push(partner); continue; }
-
-      const key = step.join(",");
-      const opposite = step.map(v => -v).join(",");
-      const back = facing.get(opposite);
-
-      // Straight through: the two that were either side of us are now either
-      // side of nothing, so they are next to each other.
-      if (back && back !== partner && back.at.node !== partner.at.node) {
-        join(back, partner);
-        facing.delete(opposite);
-
-        continue;
-      }
-
-      if (facing.has(key)) waiting.push(partner);
-      else facing.set(key, partner);
-    }
-
-    /**
-     * And whatever had nothing coming the other way is joined up anyway.
-     *
-     * Every one of these was a neighbour of the point that has gone, so they
-     * are all within a step of where it was and so within two of each other:
-     * joining them is contraction, the same as the straight-through case, not
-     * a shortcut between places that were never near. What it is not is a
-     * hole. A direction left pointing at nothing is a way out of the lattice
-     * that was not there before, and thousands of them are what stop a wave
-     * ever crossing the middle — which is measurable, and was the whole of
-     * why two magnets stopped interacting after a dozen ticks.
-     *
-     * A point removed from a line leaves its two ends facing each other. A
-     * point removed from a lattice leaves twenty-six neighbours facing each
-     * other, and all of them staying connected is what "the space contracts"
-     * has to mean when there is more than one way through.
-     */
-    const left = [...facing.values(), ...waiting]
-      .filter(p => p.target?.at === of);
-
-    for (let i = 0; i + 1 < left.length; i += 2)
-      if (left[i].at.node !== left[i + 1].at.node) join(left[i], left[i + 1]);
-
-    // An odd one out: joined to whoever it was just beside, rather than left
-    // facing nowhere.
-    if (left.length % 2) {
-      const last = left[left.length - 1];
-      const mate = left.find(p => p !== last && p.at.node !== last.at.node);
-
-      if (mate) {
-        const spare = new Boundary(mate.at, this);
-        spare.polarity = Polarity.Neutral;
-        mate.at.boundaries.push(spare);
-        join(last, spare);
-      } else this.loose(last);
-    }
-  }
-
-  private discard(ray: Ray, onto: Ray, removed: Set<node>) {
-    const nd = ray.node;
-
-    /**
-     * Everything that was connected to us is now connected to where our
-     * structure went.
-     *
-     * This used to leave them holding a bare direction — the way is still
-     * that way, there is just nothing there — which is right for a line and
-     * catastrophic for a lattice. On a line a point has two neighbours, the
-     * two ends get spliced onto each other by the caller, and nothing is left
-     * dangling. Here a point has twenty-six, one of them gets the splice, and
-     * the other twenty-five are left pointing at nowhere.
-     *
-     * That is a hole, and every annihilation punches two dozen of them. They
-     * accumulate exactly where the action is, the lattice between the sources
-     * comes apart into fragments joined by fewer and fewer connections, and
-     * the way from one source to the other has to start going round. Which
-     * is why the distance between them falls for a while and then stops
-     * falling: it is not that they have finished coming together, it is that
-     * the space they were coming together through has been shredded.
-     *
-     * Following the structure instead keeps the lattice whole. The point is
-     * gone and its structure is at `onto`, so its neighbours are neighbours
-     * of `onto` now — which is the same rule the annihilation itself runs on,
-     * applied to every direction rather than only to the one behind.
-     */
-    /**
-     * The space closes up across itself, direction by direction.
-     *
-     * Two earlier versions of this were wrong in opposite ways. Leaving every
-     * neighbour holding a bare direction tears two dozen holes per removal.
-     * Reconnecting them all to wherever the structure went does keep the
-     * lattice joined — but `onto` can be anywhere, so every removal welds a
-     * couple of dozen points to one distant point, and after a few thousand
-     * of them the lattice is a mass of long-range shortcuts. That is
-     * measurable rather than theoretical: the shortest way from one source to
-     * the other ends up running (−8,0,0) → (−9,0,0) → (−1,9,9) → (7,0,0) →
-     * (8,0,0), hopping through a point in the far corner of the world, and it
-     * stops changing at all. Both sources still have their whole
-     * neighbourhood; what has gone is any relation between being connected
-     * and being near, and with it any sense in which the two are approaching.
-     *
-     * What a point actually is, to its neighbours, is the thing between them:
-     * take it away and the two on opposite sides of it are what close up.
-     * That is the same rule the annihilation uses along its own line, applied
-     * to every direction through the point rather than only that one — so the
-     * ways through survive, and none of them reaches anywhere the two ends
-     * were not already either side of.
-     */
-    this.closeUp(ray.boundaries, ray);
-
-    ray.boundaries = [];
-
-    for (const other of [...nd]) {
-      if (other === ray) continue;
-
-      other.node = onto.node;
-      onto.node.push(other);
-    }
-
-    nd.length = 0;
-
-    this.delPos(nd);
-    // Taken out of the world at the end of the tick rather than here: `nodes`
-    // is scanned by everything, and cutting one point out of it costs a pass
-    // over all of them, which with a few thousand points and a few thousand
-    // of them moving is the whole frame. `removed` is what everything in the
-    // tick actually consults, so the array can be caught up with once.
-    removed.add(nd);
-  }
-
-  /**
-   * Two like charges meeting head-on: neither cancels the other and neither
-   * can move through the other, so each simply turns itself around.
-   *
-   * Movement is conserved rather than reselected — it comes back the way it
-   * came instead of setting off somewhere new — and if there is no way back
-   * yet then the way back is something it has to have, so it gets one.
-   */
-  private turnAround(ray: Ray, a: Boundary) {
-    const dir = this.direction(a);
-
-    let back = this.behind(ray, dir, a);
-
-    // Nothing behind it at all, so the way back is something it has to have —
-    // except in a sealed world, where a direction it hasn't got is not a
-    // direction it may invent. There it comes back along whichever of its own
-    // ways points most nearly backwards, and if it truly has only the one, it
-    // stays where it is rather than tearing a way out to leave by.
-    if (!back) {
-      if (this.sealed) {
-        back = this.along(ray, dir, -1, a);
-
-        if (back) ray.moving = back;
-
-        return;
-      }
-
-      const step = this.bare(a);
-
-      back = new Boundary(ray, this);
-      back.polarity = a.polarity;
-      if (step) back.outward = step.map(v => -v);
-      ray.boundaries.push(back);
-    }
-
-    ray.moving = back;
-
-    // It is genuinely going somewhere else now, so the way it was going is
-    // not a detour from anything. Taken up afresh from wherever it now
-    // points.
-    ray.heading = undefined;
-  }
-
-  /**
-   * Whether there is anywhere to go.
-   *
-   * Space can be moved through. So can a point that is itself moving out of
-   * our way, because by the time we get there it will have put down the space
-   * it left behind, and that space is what we move through. Anything else is
-   * in the way — including something on its way somewhere that is itself
-   * blocked, which is why this is asked of a whole queue at once rather than
-   * of one point in isolation.
-   */
-  private canMove(ray: Ray, a: Boundary, blocked: Set<Ray>): boolean {
-    // An actual boundary of the structure: we make our own way — as long as
-    // there is a way to make. A direction we can't name is one we can't grow
-    // into, and setting off into it means putting down the space we are
-    // leaving and then not leaving.
-    if (!a.target) return !!this.bare(a);
-
-    const dir = this.direction(a);
-
-    for (const other of a.target.at.node) {
-      // A source is never space, whether or not it happens to be going
-      // anywhere. Without this a charge arriving at a standing magnet reads
-      // it as somewhere to be, walks into it, and finds it can't — having
-      // already put down the space it was leaving, which is space made out of
-      // nothing, every tick, forever.
-      if (other.magnet) return false;
-
-      if (!other.moving) continue; // space: ours to move through
-
-      /**
-       * It is going somewhere, so its place will be free — whichever way it
-       * happens to be going. What it leaves behind is one point of space,
-       * spliced in on its way out, and that point is what we move into.
-       *
-       * Only one of us can have it, and which one is settled by the claim
-       * below rather than by geometry: a point being moved out of typically
-       * has several things coming up behind it at various angles, and if
-       * whoever is actually following has to also be the one lying exactly
-       * opposite the direction of travel, then in a field where directions
-       * change from tick to tick almost nobody qualifies and almost
-       * everything is stuck waiting on a queue that is moving fine.
-       *
-       * So: it is leaving, therefore it can be followed. Whoever claims the
-       * place gets it (`claimed`), and `emitBehind` puts the space it leaves
-       * on that one's connection rather than on whichever happens to be
-       * behind.
-       */
-      if (blocked.has(other)) return false; // not leaving after all
-    }
-
-    return true;
-  }
-
-  /**
-   * The space something leaves behind it.
-   *
-   * We never move ourselves — a point is what "where" is made of, and has
-   * nowhere to go. What moves is space: a fresh point is put behind us,
-   * spliced in between us and whatever was already back there, and everything
-   * we were carrying across our direction of travel is handed to it. It is
-   * neutral and has no direction of its own; nothing has happened to it yet,
-   * and giving it a charge at random would be an event this model didn't
-   * have.
-   */
-  private emitBehind(ray: Ray, a: Boundary, vacated: Map<node, number[]>, heir?: Ray) {
-    const dir = this.direction(a);
-    const step = this.bare(a);
-    const here = this.gridPos.get(ray.node);
-
-    // The space we leave goes to whoever is actually moving into our place,
-    // if anyone is — spliced in on the connection they are coming along, so
-    // that what they find in front of them next is it. Failing that (nobody
-    // following), it goes behind us in the geometric sense, which is where it
-    // would have gone anyway.
-    let back = heir
-      && ray.boundaries.find(bd => bd !== a && bd.target?.at.node === heir.node);
-
-    if (!back) back = this.behind(ray, dir, a);
-    const was = back?.target;
-    const there = was && this.gridPos.get(was.at.node);
-
-    const nd: node = [];
-    const fresh = new Ray(nd, this);
-    fresh.boundaries = []; // drop the constructor's default
-
-    const facing = new Boundary(fresh, this);
-    facing.polarity = Polarity.Neutral;
-    fresh.boundaries.push(facing);
-
-    // Nothing behind us at all, not even a bare direction, so the way back is
-    // itself something we have to have.
-    if (!back) {
-      back = new Boundary(ray, this);
-      back.polarity = Polarity.Neutral;
-      ray.boundaries.push(back);
-    }
-
-    back.outward = undefined;
-    back.target = facing;
-    facing.target = back;
-
-    const onward = new Boundary(fresh, this);
-    onward.polarity = Polarity.Neutral;
-
-    // Whatever was behind us is behind the point we just put there — and if
-    // there was nothing behind us at all, then the point we put down has
-    // nothing behind it either. In an open world that is a way out, and it
-    // gets one; sealed, it is simply a point with one fewer direction, which
-    // is not a hole because there was never anything there to lose.
-    if (was) {
-      onward.target = was;
-      was.target = onward;
-      fresh.boundaries.push(onward);
-    } else if (!this.sealed) {
-      if (step) onward.outward = step.map(v => -v);
-      fresh.boundaries.push(onward);
-    }
-
-    this.nodes.push(nd);
-
-    // Where it ends up is where we are: we are about to be one step further
-    // on, and this is what we will have left at the place we were. It can't
-    // be put there yet, though — until we have actually gone, that place is
-    // still occupied by us, and two points sharing one position have no
-    // direction between them for anything else to read. So it waits between
-    // us and what is behind us, and is put down properly once the moving is
-    // over.
-    this.setPos(nd, !here ? []
-      : there ? here.map((v, i) => (v + there[i]) / 2)
-        : step ? here.map((v, i) => v - step[i])
-          : here.slice());
-
-    if (here) vacated.set(nd, here.slice());
-
-    this.hand(this.transverse([ray], dir, back), fresh);
-  }
-
-  /**
-   * Moving through the space in front of us: it comes onto us, and stops
-   * being anywhere.
-   *
-   * This is the half of movement that makes it movement rather than drift.
-   * Its structure becomes ours, its place becomes our place, and the
-   * connection we came in on is rewired straight through to whatever lay
-   * beyond it, so nothing comes apart. One point is consumed here for the one
-   * emitted behind, so space is conserved: a thing moving is a thing swapping
-   * places with the space in front of it while everything else stays where it
-   * was.
-   *
-   * Only space is ever consumed. Anything with a direction of its own is
-   * somebody rather than somewhere.
-   */
-  private consumeAhead(ray: Ray, a: Boundary, removed: Set<node>, vacated: Map<node, number[]>) {
-    // Nothing in front of us at all: we assume we can go that way anyway, and
-    // make what we are moving into.
-    if (!a.target) this.grow(ray, a);
-
-    const ahead = a.target;
-    if (!ahead) return;
-
-    const nd = ahead.at.node;
-    if (nd === ray.node || removed.has(nd)) return;
-
-    // Only space is ever eaten. Anything going somewhere is somebody — and so
-    // is a magnet, which is a somebody that happens to be standing still: it
-    // is the source of everything happening here, and a source that its own
-    // first pulse can swallow is not a source.
-    for (const other of nd)
-      if (other.moving || other.magnet) return;
-
-    const dir = this.direction(a);
-    const bareA = this.bare(a);
-
-    // Where it is going to be, which is not yet where it is if it is space
-    // something else has just put down on its way out.
-    const there = vacated.get(nd) ?? this.gridPos.get(nd);
-
-    /**
-     * What lies beyond it the way we are going — carrying on, rather than
-     * across. Our own direction of travel is rewired onto that, so the line
-     * we are moving along stays a line.
-     *
-     * And this is where gravity is, which is worth saying plainly because
-     * nothing here looks like it.
-     *
-     * "The way we are going" is not a remembered vector. It is `dir`, the
-     * direction of the connection we are moving along, measured between the
-     * two points it currently joins — so it is a fact about the lattice as it
-     * stands rather than about where we set out. What continues it is
-     * likewise chosen from the connections the point ahead actually has, now.
-     * Nothing in this reads an absolute frame, and nothing in it remembers
-     * anything.
-     *
-     * So when an annihilation somewhere nearby splices two points together
-     * that were not joined before, the fan of directions at this point is a
-     * different fan, and the best continuation of our line is a connection
-     * that was not there and does not lead where the old one led. The ray
-     * does exactly what it always does — carry on — and arrives somewhere it
-     * would not have. That is a path bending with nothing bending it, which
-     * is the whole of what a geodesic is.
-     *
-     * What used to prevent it was asking for a continuation within about
-     * twenty-five degrees of dead ahead, and taking nothing at all otherwise.
-     * That is a fine rule in a lattice that is still square, and it is
-     * precisely wrong where one is not: exactly where the space has been bent
-     * by an annihilation, the ray would find nothing straight enough, give up
-     * its line, and either stop having a direction or walk out of a bare one.
-     * The deflection was there to be had and was being thrown away for not
-     * being small.
-     *
-     * Best available, then, and forwards. A ray follows the straightest thing
-     * this point has got, whatever that has become — which in flat lattice is
-     * the same connection it would have taken anyway, and near a collision is
-     * the one that has been moved.
-     */
-    let onward: Boundary | undefined;
-    let onwardStep: number[] | undefined;
-    let straightest = 0;
-
-    for (const other of nd) {
-      for (const bd of other.boundaries) {
-        if (bd === ahead) continue;
-
-        const d = this.direction(bd);
-        if (!d || !dir) continue;
-
-        const dot = d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
-
-        // Forwards, at least. A connection at right angles or behind is not a
-        // continuation of anything, it is a different journey.
-        if (dot <= straightest) continue;
-
-        straightest = dot;
-        onward = bd;
-        onwardStep = this.bare(bd);
-      }
-    }
-
-    // Everything it held across our path is ours now.
-    this.hand(this.transverse(nd, dir, ahead), ray);
-
-    const beyond = onward?.target;
-
-    if (beyond) {
-      a.target = beyond;
-      beyond.target = a;
-    } else {
-      // Nothing beyond it: what we are moving along is a bare direction
-      // again, and growing into it is the next thing we do. Sealed, there is
-      // no growing into anything, so it simply stops being one of our
-      // directions.
-      if (this.sealed) this.drop(a);
-      else {
-        a.target = undefined;
-        a.outward = onwardStep ?? bareA;
-      }
-    }
-
-    // And everything else it was holding is held by us, since we are where it
-    // was. Same rule as annihilation: the point stops existing and the place
-    // behind takes what it had — here the place behind is the mover, which
-    // has just arrived. Anything left out of this is a connection whose far
-    // end is still pointing at a point that no longer exists.
-    for (const other of nd) {
-      this.hand(
-        other.boundaries.filter(bd => bd !== ahead && bd !== onward && bd.target !== a),
-        ray,
-      );
-
-      other.boundaries = [];
-    }
-
-    // Its place is our place: we have moved.
-    if (there) this.setPos(ray.node, there.slice());
-
-    this.delPos(nd);
-    // Taken out of the world at the end of the tick rather than here: `nodes`
-    // is scanned by everything, and cutting one point out of it costs a pass
-    // over all of them, which with a few thousand points and a few thousand
-    // of them moving is the whole frame. `removed` is what everything in the
-    // tick actually consults, so the array can be caught up with once.
-    removed.add(nd);
-    vacated.delete(nd);
-  }
-
-  /**
-   * An actual boundary of the structure: there is nothing in front of us at
-   * all. We assume we can go that way anyway, and make what we are going
-   * into — a new point, connected to what we are connected to, so that what
-   * grows is more of the same lattice rather than a spur hanging off it.
-   *
-   * Neutral, like anything else instantiated: it is somewhere to be, not
-   * something to be. It is space, so the move that made it consumes it in the
-   * same tick, which is what moving into nothing amounts to.
-   */
-  private grow(ray: Ray, a: Boundary) {
-    const step = this.bare(a);
-    const here = this.gridPos.get(ray.node);
-    if (!step || !here) return;
-
-    const pos = here.map((v, i) => v + step[i]);
-
-    const nd: node = [];
-    const fresh = new Ray(nd, this);
-    fresh.boundaries = []; // drop the constructor's default
-
-    const facing = new Boundary(fresh, this);
-    facing.polarity = Polarity.Neutral;
-    facing.target = a;
-    fresh.boundaries.push(facing);
-
-    a.outward = undefined; // a connection now, not a bare direction
-    a.target = facing;
-
-    this.nodes.push(nd);
-    this.setPos(nd, pos);
-
-    // Connected to what we are connected to: one direction for each of ours,
-    // a real connection where a point is already there and a bare direction
-    // where there isn't one yet, so the frontier can keep going.
-    for (const boundary of ray.boundaries) {
-      if (boundary === a) continue;
-
-      const d = this.bare(boundary);
-      if (!d) continue;
-
-      const neighbour = this.nodeAt(pos.map((v, i) => v + d[i]));
-      if (neighbour === ray.node || neighbour === nd) continue; // back at us
-
-      // Nowhere there yet: an open world gets a bare direction so the
-      // frontier can keep going, a sealed one simply doesn't have that
-      // direction.
-      if (!neighbour && this.sealed) continue;
-
-      const side = new Boundary(fresh, this);
-      side.polarity = Polarity.Neutral;
-
-      if (neighbour) {
-        const facingBack = new Boundary(neighbour[0], this);
-        facingBack.polarity = Polarity.Neutral;
-        facingBack.target = side;
-        side.target = facingBack;
-        neighbour[0].boundaries.push(facingBack);
-      } else {
-        side.outward = d;
-      }
-
-      fresh.boundaries.push(side);
-    }
-  }
-
-  /**
-   * One tick. Every ray acts, and each acts on one thing only: the boundary
-   * it is moving towards. There is nothing else it consults.
-   *
-   * Two of them meeting head-on is the one thing that isn't movement, and
-   * what it is depends only on the two charges that met:
-   *
-   *  - opposite → they cancel, leaving the space they were still connected
-   *    and still there, just neutral and still;
-   *  - alike → neither can cancel and neither can pass, so each turns itself
-   *    around.
-   *
-   * Everything else moves, and moving is a trade with space: put a point down
-   * behind, take the point in front. Space is conserved by it, which is what
-   * makes a column of things moving in step actually travel — the space each
-   * one leaves is the space the one behind it moves into.
-   */
-  tick() {
-    this._tickId++;
-
-    // Zeroed before the sources get their say, so what they emit this tick is
-    // counted against this tick.
-    this.stats = { emitted: 0, moved: 0, blocked: 0, annihilated: 0, turned: 0, path: 0, holes: 0 };
-
-    this.onTick?.(this);
-
-    // Snapshot the rays first, so structural changes don't disturb iteration.
-    const rays: Ray[] = [];
-    for (const node of this.nodes)
-      for (const ray of node)
-        rays.push(ray);
-
-    /**
-     * Before anything is read off: whoever is wandering, wanders.
-     *
-     * Done here rather than at the point of moving, because a change of
-     * direction has to be settled before it is asked who is meeting whom —
-     * otherwise a ray is judged to be about to collide on a heading it has
-     * already given up, and half the interactions in the tick are worked out
-     * against a world nobody is in any more.
-     */
-    /*
-     * Age is counted in the movement phase below, in steps actually taken
-     * rather than in ticks lived through.
-     *
-     * It is read as a distance everywhere it is used — how far out a charge
-     * has got, for fanning and for the range at which it gives up being one —
-     * and for anything moving at a cell a tick the two are the same number.
-     * For anything slower they are not: a charge held to a cell every third
-     * tick ages three times as fast as it travels, so it expires a third of
-     * the way out and the field never reaches the edge of the world.
-     */
-
-    if (this.wander > 0) {
-      for (const r of rays) {
-        if (!r.moving || r.magnet) continue;
-
-        // Where it is going, remembered — not where it went last time.
-        const head = r.heading ?? this.bare(r.moving);
-        if (!head) continue;
-
-        r.heading = head;
-
-        // The ways this direction is made of. Its own pieces only: a step of
-        // (1,1,1) is (1,0,0) and (0,1,0) and (0,0,1) taken at once, and those
-        // three are the whole of what taking it apart can mean. Their
-        // opposites are not detours down the same road, they are a different
-        // road — a ray that takes them is not going where it was going, and
-        // the direction stops meaning anything.
-        const ways: number[][] = [head];
-
-        for (let axis = 0; axis < head.length; axis++) {
-          if (!head[axis]) continue;
-
-          const one = new Array(head.length).fill(0);
-          one[axis] = head[axis];
-
-          ways.push(one);
-        }
-
-        // Straight on unless it draws otherwise, and always the whole
-        // direction if there is nothing it can be broken into — an axial
-        // heading has no longer way round.
-        const way = ways.length > 2 && Math.random() < this.wander
-          ? ways[1 + Math.floor(Math.random() * (ways.length - 1))]
-          : head;
-
-        const length = Math.hypot(...way) || 1;
-
-        const chosen = this.along(r, way.map(v => v / length), 1);
-        if (chosen) r.moving = chosen;
-      }
-    }
-
-    // Which way each ray was headed when the tick began. Read once, so that
-    // acting in some order doesn't let the earlier actions decide what the
-    // later ones are — head-on is head-on as of the start of the tick.
-    const headed = new Map<Ray, Boundary | undefined>();
-    for (const r of rays) headed.set(r, r.moving);
-
-    // 1. Who is meeting whom head-on. Both ends of such a pair have had their
-    // tick: turning around, or cancelling, is the whole of what they do in
-    // it.
-    const collisions: Interaction[] = [];
-    const reflections: { r: Ray, a: Boundary }[] = [];
-    const met = new Set<Ray>();
-
-    for (const r of rays) {
-      if (met.has(r)) continue;
-
-      const a = headed.get(r);
-      if (!a) continue;
-
-      const ahead = a.target?.at.node;
-      if (!ahead || ahead === r.node) continue;
-
-      // Arriving at a source. It carries no charge, so there is nothing to
-      // cancel with, and it is never space, so there is no moving through it
-      // — which leaves the only other thing anything does here: it turns
-      // around. A source reflects what reaches it, and it does so whether or
-      // not it is itself going anywhere, which is what makes it different
-      // from every other head-on case.
-      if (ahead.some(x => x.magnet)) {
-        met.add(r);
-        reflections.push({ r, a });
-        continue;
-      }
-
-      /**
-       * Whoever over there is coming back at us.
-       *
-       * Not necessarily along the same connection. On a line there is only
-       * one way to be coming the other way, and "head-on" can be checked by
-       * asking whether the far side is moving along this very boundary. With
-       * twenty-six directions two things can be moving into each other
-       * without being anywhere near opposite — one going along an edge, one
-       * through a corner — and by that test neither of them is meeting
-       * anything.
-       *
-       * Which is worse than a missed case: neither can move, because the
-       * other is in the way and isn't leaving, so two fronts that should pass
-       * through each other (cancelling as they go) instead stop dead against
-       * each other and stay there. Nothing happens, and nothing goes on
-       * happening.
-       *
-       * So the test is the thing itself: I am moving into where you are, and
-       * you are moving into where I am.
-       */
-      let r2: Ray | undefined;
-      let b: Boundary | undefined;
-
-      for (const other of ahead) {
-        if (met.has(other)) continue;
-
-        // Not against itself: two charges of the same source are two parts of
-        // one field, and a field arriving where it already is is not an
-        // event. See the arriving-together case below.
-        if (r.source !== undefined && r.source === other.source) continue;
-
-        const bd = headed.get(other);
-        if (!bd || bd.target?.at.node !== r.node) continue;
-
-        r2 = other;
-        b = bd;
-        break;
-      }
-
-      if (!r2 || !b) continue;
-
-      met.add(r); met.add(r2);
-
-      // Only two actual charges, one of each, cancel. Neutral space has no
-      // charge to cancel with, so anything else that meets head-on turns
-      // around instead.
-      const opposed =
-        (a.polarity === Polarity.Positive && b.polarity === Polarity.Negative) ||
-        (a.polarity === Polarity.Negative && b.polarity === Polarity.Positive);
-
-      collisions.push({ kind: opposed ? 'annihilate' : 'turn', r, a, r2, b });
-    }
-
-    /**
-     * Two charges arriving at the same point.
-     *
-     * Everything above asks whether two things are moving into each other,
-     * which is to say whether they are next to each other and pointed the
-     * opposite way. On a line that is the only way two things can meet, and
-     * it is where this rule came from.
-     *
-     * In three dimensions it is the exceptional way. Two shells sweeping
-     * through each other are made of rays coming in at all angles, and what
-     * those rays overwhelmingly do is converge on the SAME cell from
-     * different directions — never becoming neighbours, never pointed at each
-     * other, both pointed at the same third place. By the test above neither
-     * of them is meeting anything. They are resolved as traffic instead: one
-     * takes the place, the other waits, and two fields pass straight through
-     * one another with nothing to show for it.
-     *
-     * Which is the answer to why the fields overlap and never attract. It was
-     * never that the shells missed each other; it is that arriving together
-     * was not on the list of ways to meet.
-     *
-     * So it is now, and it is the same event: two opposite charges cancel,
-     * their points go, and what was behind each closes onto what was behind
-     * the other — the whole of it exactly as for two that met head-on, since
-     * `annihilate` cares about what is BEHIND the two rather than about how
-     * they came to be in the same place. Alike charges arriving together are
-     * left to traffic, as before: they cannot cancel, and nothing about
-     * wanting the same cell makes them turn around.
-     */
-    const arriving = new Map<node, Ray>();
-
-    for (const r of rays) {
-      if (met.has(r) || r.magnet) continue;
-
-      const a = headed.get(r);
-      const there = a?.target?.at.node;
-      if (!a || !there || there === r.node) continue;
-
-      const other = arriving.get(there);
-
-      if (!other) { arriving.set(there, r); continue; }
-
-      const b = headed.get(other)!;
-
-      /**
-       * A field does not interact with itself.
-       *
-       * Two charges thrown out by the same source are two parts of one thing
-       * it is doing, and one part of a field arriving where another part of
-       * the same field already is has never been an event. Left to interact,
-       * they are a disaster: a source that turns puts consecutive shells out
-       * at an eighth of a turn from each other, so where one shell's north
-       * lobe overtakes the next one's south they are opposite, and they
-       * cancel — the field eats itself as fast as it is made. What survives
-       * blocks, stalls, and is overtaken, and the shells lose their order.
-       * Measured: waves emitted fourteen, twelve, nine and eight pulses ago
-       * all sitting at the same radius, each pointing a different way, their
-       * lobes averaging out to nothing in particular.
-       *
-       * Each shell is a clean two-lobed thing on its own — that much is
-       * emitted correctly and always was. It is only in being allowed to
-       * annihilate against its own neighbours that the order is lost.
-       *
-       * Charges from DIFFERENT sources still meet in the ordinary way, which
-       * is the whole of what two magnets do to each other.
-       */
-      if (r.source !== undefined && r.source === other.source) continue;
-
-      const opposed =
-        (a.polarity === Polarity.Positive && b.polarity === Polarity.Negative) ||
-        (a.polarity === Polarity.Negative && b.polarity === Polarity.Positive);
-
-      met.add(r); met.add(other);
-
-      /**
-       * Alike, and both wanting the same place: they turn around.
-       *
-       * This used to be left to traffic — one takes the place, the other
-       * waits — and that is why two sources turning in step do nothing at
-       * all. They emit the same charge on the same tick, so their shells are
-       * the same polarity, so the two that meet in the middle are always
-       * alike. Never opposite, so nothing ever cancelled there; and merely
-       * queued rather than turned, so nothing ever came back either. The
-       * whole interaction between them was one of them waiting a tick.
-       *
-       * Turning is what actually happens: neither can cancel the other and
-       * neither can pass through it, which is the same situation as meeting
-       * head-on and has the same answer. And it is what makes the two spin
-       * cases the same thing in the end — each of them comes back into the
-       * opposite-charged shell following behind it, and cancels against that.
-       * The space between the two still gets eaten; it takes one more step
-       * about it.
-       */
-      if (!opposed) {
-        arriving.delete(there); // both going back the way they came
-
-        collisions.push({ kind: 'turn', r, a, r2: other, b });
-
-        continue;
-      }
-
-      arriving.delete(there); // both gone; the place is free again
-
-      collisions.push({ kind: 'annihilate', r, a, r2: other, b });
-    }
-
-    const removed = new Set<node>();
-
-    // Only the last couple of ticks' worth is kept: an event is a thing that
-    // happened, not a thing that is there.
-    this.events = this.events.filter(e => e.tick > this._tickId - 2);
-
-    /**
-     * Whether an interaction worked out at the top of the tick is still an
-     * interaction by the time we get to it.
-     *
-     * They were all found against the world as it was when the tick began,
-     * and then they are carried out one after another — so each one is
-     * carried out against a world the ones before it have been changing.
-     * Annihilating splices two points out and hands what they were carrying
-     * to whatever was behind them, which can pick a ray up off the node it
-     * was on and leave it holding none of the boundaries it had.
-     *
-     * With one interface between two waves there is only ever one of these a
-     * tick and it cannot happen. With a field full of shells there are
-     * hundreds, and the ones that are stale get carried out anyway: rewiring
-     * `target`s across connections that have already been spliced, in exactly
-     * the region where everything is happening. What comes of it is a
-     * knot — points connected to points that no longer exist, rays that can
-     * no longer move, nothing more able to reach anything else — which looks
-     * from outside like the first wave interacting beautifully and every
-     * wave after it doing nothing at all.
-     *
-     * Every other phase of the tick already checks this (see `movers`). This
-     * one didn't.
-     */
-    const alive = (r: Ray, bd: Boundary) =>
-      !removed.has(r.node) && r.boundaries.includes(bd);
-
-    for (const it of collisions) {
-      if (!alive(it.r, it.a) || !alive(it.r2, it.b)) continue;
-
-      // Noted before it is carried out — an annihilation removes both of the
-      // points it happened between, and afterwards there is nowhere to say it
-      // happened at.
-      this.mark(it.kind, it.r, it.r2);
-
-      if (it.kind === 'annihilate') {
-        this.stats.annihilated++;
-        this.annihilate(it.r, it.a, it.r2, it.b, removed);
-      } else {
-        this.stats.turned++;
-        this.turnAround(it.r, it.a);
-        this.turnAround(it.r2, it.b);
-      }
-    }
-
-    /**
-     * What arrives at a source is taken back into it.
-     *
-     * This used to turn around, on the grounds that a source can neither
-     * cancel a charge nor be moved through, so the only thing left was to
-     * come back the way it came. True as far as it goes, and it silts the
-     * source up: a reflected charge is still a charge, still sitting in one
-     * of the couple of dozen cells its source has to emit into, and free to
-     * wander straight back. A handful of them and the source is walled in by
-     * its own output — emitting nothing, ever again.
-     *
-     * A thing that writes charge onto space can take it off again; a source
-     * is a sink for the same reason it is a source. So the charge is simply
-     * undone — its polarity goes, it stops going anywhere, and it is space
-     * once more. No point is created or destroyed by it, and the source is
-     * left with somewhere to emit next tick, which is the whole condition of
-     * it going on being a source at all.
-     */
-    for (const { r, a } of reflections) {
-      if (!alive(r, a)) continue;
-
-      r.moving = undefined;
-      r.wave = undefined;
-      r.age = 0;
-      r.fanned = false;
-      r.heading = undefined;
-
-      for (const bd of r.boundaries) bd.polarity = Polarity.Neutral;
-    }
-
-    // 2. Everything else moves — read off the world as the collisions have
-    // left it, so that space that has just closed up behind an annihilation
-    // is gone before anything tries to move through it.
-    const movers = rays.filter(r =>
-      !met.has(r)
-      && r.moving
-      && !removed.has(r.node)
-      && r.boundaries.includes(r.moving));
-
-    const blocked = new Set<Ray>();
-
-    /**
-     * One step, one tick, whichever way it goes.
-     *
-     * Everything moves away every tick, and that is the whole of it: a cell
-     * emptied this tick is available the next, so a source is never waiting
-     * on its own last pulse and every shell leaves complete.
-     *
-     * The alternative is to charge a step its own length — √2 through an
-     * edge, √3 through a corner — so that every direction covers the same
-     * DISTANCE per tick and a shell stays a round shell. It is the tidier
-     * geometry and it costs too much: the corner directions then take nearly
-     * two ticks a step, the cells they occupy are still occupied when the
-     * next pulse is due, and what leaves is fourteen of the twenty-six
-     * directions with holes in the same places every time.
-     *
-     * A step per tick makes the front a cube rather than a sphere — the
-     * corners of it run out at 1.73 times the speed of the faces — and that
-     * is simply the true shape of "one move a tick" in a space with
-     * twenty-six directions. It is a coherent front either way: shell k is
-     * the points k steps out, all of them, and no shell ever overtakes
-     * another.
-     */
-    const cost = new Map<Ray, number>();
-
-    for (const r of movers) {
-      const price = r.mass ?? 1;
-
-      cost.set(r, price);
-      r.credit = (r.credit ?? 0) + 1;
-
-      // Not yet paid for. It is still going where it was going, and anything
-      // queued up behind it is still behind something that isn't leaving —
-      // which is exactly what `blocked` means, so it goes in there and the
-      // settling below carries it back down the queue.
-      if (r.credit + 1e-9 < price) blocked.add(r);
-    }
-
-    /**
-     * Who is actually going anywhere.
-     *
-     * Two conditions, settled together rather than one after the other,
-     * because each can undo the other's answer: something cleared to follow a
-     * mover has to be reconsidered if that mover turns out not to be going
-     * after all, whatever the reason it isn't.
-     *
-     * The first is traffic — being behind something that is leaving is fine,
-     * being behind something that only looked like it was leaving is not.
-     *
-     * The second is that a place can only be taken by one thing. Two points
-     * can both be moving into the same empty cell — on a line they can't, but
-     * with twenty-six directions to come from it is the ordinary case — and
-     * both are clear to go by every other test, since every other test is
-     * about whether the way ahead is clear and for both of them it is. Then
-     * they go: both put down the space they are leaving, the first to arrive
-     * consumes the cell, and the second finds the place it was moving to no
-     * longer exists and stops, having already emitted. One point made out of
-     * nothing, and one charge that has not moved.
-     *
-     * So the place is claimed before anything sets off, and whoever doesn't
-     * get it waits — which is what being behind something else amounts to,
-     * arrived at sideways.
-     */
-    const order = Universe.shuffle(movers);
-    const claimed = new Map<node, Ray>();
-
-    for (let pass = 0; pass < movers.length; pass++) {
-      let changed = false;
-
-      for (const r of order) {
-        if (blocked.has(r)) continue;
-        if (this.canMove(r, r.moving!, blocked)) continue;
-
-        blocked.add(r);
-        changed = true;
-      }
-
-      claimed.clear();
-
-      for (const r of order) {
-        if (blocked.has(r)) continue;
-
-        const there = r.moving!.target?.at.node;
-        if (!there) continue; // making its own way: nowhere yet to be claimed
-
-        const holder = claimed.get(there);
-
-        if (!holder) { claimed.set(there, r); continue; }
-
-        blocked.add(r);
-        changed = true;
-      }
-
-      if (!changed) break;
-    }
-
-    const going = order.filter(r => !blocked.has(r));
-
-    // Paid on going, not on being ready to: something held up in traffic
-    // keeps what it has saved and leaves the moment the way is clear.
-    for (const r of going) {
-      r.credit = (r.credit ?? 0) - (cost.get(r) ?? 1);
-
-      // One cell older, because it is one cell further on.
-      if (!r.magnet) r.age = (r.age ?? 0) + 1;
-    }
-
-    this.stats.moved = going.length;
-    this.stats.blocked = movers.length - going.length;
-
-    // Two passes over the same rays. Everything puts down the space it is
-    // leaving before anything goes anywhere, because the space one of them
-    // leaves is what the one behind it moves through — done one ray at a time
-    // instead, the one behind would find its way blocked by a neighbour that
-    // hasn't left yet.
-    const vacated = new Map<node, number[]>();
-
-    // `claimed` says who is taking each place, so for anything leaving it
-    // also says who is coming up behind it — which is who its space goes to.
-    for (const r of going) this.emitBehind(r, r.moving!, vacated, claimed.get(r.node));
-    for (const r of going) this.consumeAhead(r, r.moving!, removed, vacated);
-
-    // Everything has gone where it was going, so the space left behind can
-    // take the places that were left.
-    for (const [nd, pos] of vacated)
-      if (!removed.has(nd)) this.setPos(nd, pos);
-
-    // And everything that stopped being anywhere during the tick stops being
-    // in the world, in one pass rather than one pass each.
-    if (removed.size) this.nodes = this.nodes.filter(n => !removed.has(n));
-
-    // Directions with nothing on the far side of them. A handful at the rim
-    // of the world is the world having a rim; a number that climbs tick after
-    // tick is the lattice being torn apart from the inside, which is what a
-    // path that stops shortening usually means.
-    this.stats.holes = 0;
-    for (const nd of this.nodes)
-      for (const ray of nd)
-        for (const bd of ray.boundaries)
-          if (!bd.target) this.stats.holes++;
-
-    this.route = this.shortestPath();
-    this.stats.path = Math.max(this.route.length - 1, 0);
-    this.history.push(this.stats.path);
-    if (this.history.length > 240) this.history.shift();
-
-    this.invalidateLayout();
-  }
-
-  /**
-   * Seed an initial "expanding universe": a small connected patch of nodes,
-   * each a single ray with one boundary per orthogonal neighbour. Every
-   * boundary gets a random polarity, and every ray a random `moving`
-   * direction (one of its boundaries). From there the tick rules —
-   * annihilation (opposite polarities meeting head-on), merging (like
-   * polarities meeting head-on), and movement (everything else) — drive the
-   * evolution.
-   *
-   * The patch is small because everything in it moves, and everything that
-   * moves instantiates the space it leaves behind: the population grows by
-   * roughly one point per moving ray per tick, so what you seed is what you
-   * pay for on every tick thereafter.
-   */
-  static expandingGrid(dims: number, size = 5): Graph {
-    const graph = new Graph();
-    graph.dims = dims;
-    const center = Math.floor(size / 2);
-
-    const coords: number[][] = [];
-    (function build(prefix: number[]) {
-      if (prefix.length === dims) {
-        coords.push(prefix);
-        return;
-      }
-      for (let i = 0; i < size; i++)
-        build([...prefix, i]);
-    })([]);
-
-    const { nodes } = Graph.wire(graph, coords.map(c => c.map(v => v - center)), () => Universe.randomPolarity());
-
-    // Give every ray an initial movement direction — a random one of its
-    // boundaries. This is an initial condition, not a choice the dynamics
-    // ever make again: from here on movement is conserved.
-    for (const node of nodes) {
-      const ray = node[0];
-      if (ray.boundaries.length)
-        ray.moving = ray.boundaries[Math.floor(Math.random() * ray.boundaries.length)];
-    }
-
-    graph.ringRadius = center;
-
-    return graph;
-  }
-
-  /**
-   * Lay a patch of points out on a lattice: one point per coordinate, each a
-   * single ray carrying one boundary per neighbour present in the patch,
-   * wired to that neighbour's boundary facing back.
-   *
-   * `neighbourhood` is which neighbours those are, and it is the whole of
-   * what "how many ways out of here are there" means. The default is the
-   * axes — the six faces of a cell in 3D — which is all anything moving along
-   * a line ever needs. Passing `directions(dims)` instead gives a point all
-   * 3^d − 1 of them, and that is what a source radiating in every direction
-   * at once requires: it can only emit into directions the space it is
-   * sitting in actually has.
-   *
-   * Returns everything a caller needs to say which way things move: the
-   * points in coordinate order, a lookup by coordinate, and, per point, which
-   * of its boundaries faces which neighbour.
-   */
-  private static wire(
-    graph: Graph,
-    coords: number[][],
-    polarity: (coord: number[]) => Polarity,
-    neighbourhood?: number[][],
-  ) {
-    const key = (c: number[]) => c.join(",");
-
-    const nodes: node[] = [];
-    const byCoord = new Map<string, node>();
-    const coordOf = new Map<node, number[]>();
-
-    for (const coord of coords) {
-      const nd: node = [];
-      const ray = new Ray(nd, graph);
-      ray.boundaries = []; // drop the constructor's default boundary
-
-      graph.nodes.push(nd);
-      graph.setPos(nd, coord);
-
-      nodes.push(nd);
-      byCoord.set(key(coord), nd);
-      coordOf.set(nd, coord);
-    }
-
-    const facing = new Map<node, Map<node, Boundary>>();
-    for (const nd of nodes) {
-      const coord = coordOf.get(nd)!;
-      const ray = nd[0];
-      const m = new Map<node, Boundary>();
-      facing.set(nd, m);
-
-      const around = neighbourhood ?? axes(coord.length);
-
-      for (const step of around) {
-        const neighbour = byCoord.get(key(coord.map((v, i) => v + step[i])));
-        if (!neighbour) continue;
-
-        const b = new Boundary(ray, graph);
-        b.polarity = polarity(coord);
-        ray.boundaries.push(b);
-        m.set(neighbour, b);
-      }
-    }
-
-    // Mutual targets: this point's boundary facing a neighbour points at that
-    // neighbour's boundary facing back.
-    for (const nd of nodes) {
-      for (const [neighbour, b] of facing.get(nd)!) {
-        const back = facing.get(neighbour)!.get(nd);
-        if (back) b.target = back;
-      }
-    }
-
-    return { nodes, byCoord, facing, key };
-  }
-
-  /**
-   * Two solid blocks of points, side by side along x, every point in each one
-   * moving into the other. Each block's boundaries all carry that block's
-   * polarity, so the whole of the interface between them meets head-on at
-   * once — and the three ways two polarities can be arranged (opposite, both
-   * positive, both negative) are three different things happening to a whole
-   * surface rather than to a single pair.
-   *
-   * Opposite: the interface annihilates a column at a time, each annihilation
-   * throwing what it was carrying out behind it, so the two blocks come apart
-   * backwards. Like polarities can't annihilate, so the interface merges
-   * instead and the two blocks become one.
-   *
-   * Interior points are moving into their own block, which isn't head-on (the
-   * point ahead is moving the same way, not back), so behind the interface
-   * every column is simply moving.
-   */
-  static blocks(left: Polarity, right: Polarity, size = 3): Graph {
-    return Graph.facingBlocks(size, coord => coord[0] < 0 ? left : right);
-  }
-
-  /**
-   * The same two blocks with nothing uniform about either of them: every
-   * point's charge is drawn on its own, so the interface is not one thing
-   * happening to a surface but a different thing happening at every row of
-   * it. Opposite pairs cancel and take their space with them, like pairs turn
-   * around and start heading back out through their own block — at the same
-   * moment, along the same surface.
-   *
-   * What a block is, then, isn't decided by the block. It is decided pair by
-   * pair, and the two of them come apart along a line neither of them had.
-   */
-  static mixedBlocks(size = 3): Graph {
-    // `wire` asks per boundary, but a point is one thing: the draw is
-    // remembered by coordinate so every boundary of a point carries the same
-    // charge, and it is the point that is positive or negative.
-    const drawn = new Map<string, Polarity>();
-
-    return Graph.facingBlocks(size, coord => {
-      const key = coord.join(",");
-
-      if (!drawn.has(key)) drawn.set(key, Universe.randomPolarity());
-
-      return drawn.get(key)!;
-    });
-  }
-
-  // Two solid blocks side by side along x, each point charged by `polarity`
-  // and every one of them moving into the other block. So the two innermost
-  // columns meet head-on, and every column behind them is moving into the
-  // back of the one in front.
-  private static facingBlocks(size: number, polarity: (coord: number[]) => Polarity): Graph {
-    const graph = new Graph();
-    graph.dims = 2;
-    graph.ringRadius = size;
-
-    const half = Math.floor(size / 2);
-
-    const coords: number[][] = [];
-    for (let x = -size; x < size; x++)
-      for (let y = -half; y <= half; y++)
-        coords.push([x, y]);
-
-    const { nodes, byCoord, facing, key } = Graph.wire(graph, coords, polarity);
-
-    for (const nd of nodes) {
-      const coord = graph.gridPos.get(nd)!;
-      const towards = byCoord.get(key([coord[0] + (coord[0] < 0 ? 1 : -1), coord[1]]));
-      if (towards) nd[0].moving = facing.get(nd)!.get(towards);
-    }
-
-    return graph;
-  }
-
-  /**
-   * The same two blocks, but not touching: a wide field of neutral space
-   * between them, and neither of them moving. Nothing here is told to fall
-   * towards anything.
-   *
-   * What they do instead is emit. Every tick each block writes a charge onto
-   * the space at its face and points it across the gap — alternating, so a
-   * charged pulse goes out every other tick and a neutral one in between. A
-   * pulse is not a new thing added to the world: it is a point of the space
-   * that was already there, told what it is and which way it is going. It
-   * crosses by trading places with the space in front of it, so the field
-   * stays the same size while something travels through it.
-   *
-   * The two streams meet in the middle, and what they do there is the whole
-   * experiment:
-   *
-   *  - opposite charges annihilate, and annihilation is the one rule that
-   *    takes space out of the world. The two points that cancelled are gone
-   *    and what was behind each closes directly onto what was behind the
-   *    other, so every meeting leaves the two blocks fewer points apart than
-   *    they were. Nothing moved them. The distance between them is just
-   *    smaller — which is what it would mean, here, for them to be falling
-   *    towards each other. Once the first pair meets there is a meeting every
-   *    tick, each eating the two columns that met, and it runs until the field
-   *    is gone and the two blocks are directly connected.
-   *  - like charges can't cancel, so they turn around and go home instead.
-   *    The field is exactly as wide as it was — and what comes back is a
-   *    charge arriving at a block that isn't moving, which the block has no
-   *    way to refuse, so the blocks end up being driven apart by their own
-   *    emissions rather than drawn together.
-   *
-   * So `left` and `right` are what each block emits, and that alone is the
-   * difference between attraction and repulsion.
-   *
-   * What is drawn is still where each point was put down, and annihilation
-   * doesn't move what it leaves behind: the field empties from the middle
-   * outwards and the blocks stay where they were drawn, joined across the
-   * emptied part by the connection that closed up over it. The gap in the
-   * picture is the space that no longer exists.
-   *
-   * `every` is how many ticks apart the emissions are, and `spin` flips what
-   * each block is emitting between one emission and the next — a magnet being
-   * turned over and over rather than held still. `left` and `right` are then
-   * only what each side starts as, and what matters is whether the two are
-   * turning together or against each other.
-   */
-  static emitters(
-    left: Polarity,
-    right: Polarity,
-    {
-      size = 2,
-      gap = 16,
-      height = 3,
-      every = 2,
-      spin = false,
-    }: {
-      size?: number, gap?: number, height?: number,
-      every?: number, spin?: boolean,
-    } = {},
-  ): Graph {
-    const graph = new Graph();
-    graph.dims = 2;
-    graph.ringRadius = 1; // a flat lattice: nothing here wants rounding off
-
-    const half = Math.floor(height / 2);
-
-    // The field is an even number of columns wide, so that the two streams
-    // end up adjacent and meet each other rather than both arriving at the
-    // same empty cell — which is two things trying to be in one place, and
-    // not a meeting at all.
-    const width = gap + (gap % 2);
-    const l0 = -width / 2, r0 = width / 2 - 1; // the two columns at the faces
-
-    const coords: number[][] = [];
-    for (let x = l0 - size; x <= r0 + size; x++)
-      for (let y = -half; y <= half; y++)
-        coords.push([x, y]);
-
-    // Only the blocks are charged. The field between them is what space is
-    // when nothing has happened to it yet.
-    const { byCoord, key } = Graph.wire(graph, coords, coord =>
-      coord[0] < l0 ? left
-        : coord[0] > r0 ? right
-          : Polarity.Neutral);
-
-    // The two faces: the innermost column of each block, and the way out of
-    // it. Blocks never move, so these stay the points they are.
-    const faces: { at: node, dir: number[], polarity: Polarity }[] = [];
-
-    for (let y = -half; y <= half; y++) {
-      const l = byCoord.get(key([l0 - 1, y]));
-      const r = byCoord.get(key([r0 + 1, y]));
-
-      if (l) faces.push({ at: l, dir: [1, 0], polarity: left });
-      if (r) faces.push({ at: r, dir: [-1, 0], polarity: right });
-    }
-
-    graph.onTick = g => {
-      // Ticks are counted from the first one, so `every = 2` puts a step of
-      // untouched space between one pulse and the next — the tick in between
-      // emits neutral, and emitting neutral is emitting what the space at the
-      // face already is, which is to say nothing leaves. `every = 1` is a
-      // block that never stops: one pulse directly behind the last, with no
-      // space in between for either of them to move through.
-      if ((g._tickId - 1) % every !== 0) return;
-
-      // Which way round the magnet is by now.
-      const turned = spin && Math.floor((g._tickId - 1) / every) % 2 === 1;
-
-      for (const face of faces) {
-        const here = g.gridPos.get(face.at);
-        if (!here) continue;
-
-        const ahead = g.nodeAt(here.map((v, i) => v + face.dir[i]));
-        const ray = ahead?.[0];
-
-        // Only space can be told what to be. Anything already going somewhere
-        // is somebody, and the face waits rather than overwriting it.
-        if (!ray || ray.moving) continue;
-
-        const polarity = !turned ? face.polarity
-          : face.polarity === Polarity.Positive ? Polarity.Negative : Polarity.Positive;
-
-        for (const bd of ray.boundaries)
-          bd.polarity = polarity;
-
-        ray.moving = g.along(ray, face.dir, 1);
-      }
-    };
-
-    return graph;
-  }
-
-  /**
-   * The same two magnets, in three dimensions, radiating in every direction
-   * there is.
-   *
-   * `emitters` above is a flat experiment: two walls facing each other across
-   * a corridor, each writing a charge onto the one column of space in front
-   * of it. Everything that happens there happens along one axis, which is
-   * exactly why it is legible — and exactly why it can't answer the question
-   * it raises. Two things pulling on each other along the line between them
-   * can only ever move along that line. Nothing can go round anything.
-   *
-   * So: a ball of neutral space wired with all twenty-six directions (see
-   * `directions`), and in it two sources, each of which every `every` ticks
-   * writes its charge onto every point it is connected to and sends each one
-   * outward along the direction it was written in. With `spin` it puts out
-   * the opposite of what it put out last time, so what fills the ball is
-   * alternating shells rather than one thing over and over — and `phase` says
-   * whether the two sources are doing that in step or against each other,
-   * which decides whether the shells meeting in the middle are alike (and
-   * bounce) or opposite (and cancel, taking the space between the two
-   * sources with them).
-   *
-   * A pulse is a shell rather than a beam, and it stays one: see the Huygens
-   * step in `onTick`, without which it is twenty-six bullets that get further
-   * apart the further they go and almost never meet anything.
-   *
-   * Three things had to be decided to make this work at all, and each one is
-   * a claim rather than a convenience:
-   *
-   *  - A direction is one step of the lattice, not a unit of distance. Off
-   *    the axes those differ (`latticeStep`), and using the second is what
-   *    puts points at coordinates the lattice hasn't got.
-   *
-   *  - The body of a magnet is NEUTRAL. A charged one is cancelled by the
-   *    first opposite pulse that reaches it, and two magnets that annihilate
-   *    each other on contact have no chance to orbit anything. Neutral, it
-   *    can't cancel and can't be cancelled: a charge arriving head-on turns
-   *    it round instead, which is the only way anything here is ever pushed.
-   *
-   *  - What is drawn is the structure, not the coordinates (`relax`). Two
-   *    magnets attract in this model by the space between them being
-   *    annihilated and the connection closing up over the gap — which, drawn
-   *    by coordinate, is two bodies sitting exactly where they were with a
-   *    hole between them. Drawn by structure, a connection that now spans
-   *    three cells of nothing pulls its ends together, and attraction is
-   *    something you can watch instead of something you have to be told.
-   *
-   * `a.moving` and `b.moving` are each an initial direction — any of the
-   * twenty-six — and they are the interesting knob: head-on, apart, both the
-   * same way, opposite ways across the line between them. `phase` offsets one
-   * magnet's turning against the other's, so the two are spinning together or
-   * against each other.
-   */
-  static magnets(
-    a: MagnetSide,
-    b: MagnetSide,
-    {
-      // Far enough apart to have somewhere to go.
-      //
-      // Every direction counts as a step here, diagonals included, so two
-      // points `sep` either side of the origin are only 2·sep steps apart
-      // however far that is in coordinates — at four, eight steps, which the
-      // first few pulses eat through before there is anything to watch. What
-      // is left afterwards is two sources sitting next to each other not
-      // moving into one another, which is not them failing to attract, it is
-      // them having finished: neither is space, so neither can be moved
-      // through, and adjacent is as close as adjacent gets.
-      radius = 13,
-      sep = 8,
-      every = 1,
-      spin = true,
-      alone = false,
-
-      /**
-       * How many dimensions the space has, and two is not a lesser version
-       * of three.
-       *
-       * The turn is flat — the axis comes round in one plane and stays in it
-       * — so everything a turning source does happens in that plane, and the
-       * third dimension contributes nothing to it but the rest of a sphere
-       * for the same arms to be seen through. A picture of the 3D case is a
-       * projection: the arms are there, and so is every part of the ball that
-       * is neither in front of them nor behind them, laid over the top.
-       *
-       * Flat, the plane of the turn IS the picture. There is nothing in front
-       * of the spiral and nothing behind it, so what is on screen is the
-       * thing itself at last, rather than the thing plus the depth it was
-       * looked at through. Which makes the two worth having side by side: the
-       * flat one says what the arrangement does, and the round one says what
-       * survives being embedded in a world with a spare direction in it.
-       */
-      dims = 3,
-
-      /**
-       * Ticks per eighth of a turn, and one is as fast as turning goes.
-       *
-       * Not a tuning choice: an eighth of a turn is the smallest rotation
-       * this space has, because there are eight directions to a plane and
-       * nothing between neighbouring ones to move through. So one step per
-       * tick is a magnet coming round as fast as anything here does anything.
-       * Anything quicker is not a faster rotation but a coarser one — two
-       * steps a tick is the axis jumping a quarter turn and never facing the
-       * directions in between, which is a magnet being teleported round
-       * rather than turned.
-       *
-       * A full revolution is therefore eight ticks, and with a pulse leaving
-       * every tick that is exactly one pulse per direction: the emission
-       * sweeps the plane once per revolution, laying down a spiral rather
-       * than a stack of shells.
-       */
-      turnEvery = 1,
-      // Half the moves taken as one of the pieces the direction is made of:
-      // enough that a stream genuinely searches the space around it, while
-      // the whole diagonal being one option among its pieces keeps the drift
-      // pointing the way it set out.
-      wander = 0.5,
-
-      /**
-       * How many moves a charge lasts before it is space again.
-       *
-       * Without this the field has no way of losing anything except by
-       * cancelling or by reaching the rim, and both are far too slow: a
-       * source puts fifty charges a tick into a finite ball, the fan
-       * multiplies each of them, and nothing takes them out again. The space
-       * between the two fills — measurably, two hundred and thirty-three
-       * charges in a box of two hundred and twenty-five cells — and then
-       * every single thing in the model stops at once, because moving is
-       * trading places with space and there is no space left to trade with.
-       * Not a slowdown: the population, the distance between the sources and
-       * the connections of both of them go constant on the same tick and
-       * never change again.
-       *
-       * A range fixes the population instead of letting it climb: emitted per
-       * tick times how long each lasts, which is a number that can be kept
-       * well under what the ball holds. And it is the right shape of rule —
-       * a pulse spreading over a bigger and bigger shell is thinning as it
-       * goes, and at some distance it is no longer anything the space it is
-       * crossing can tell from space.
-       */
-      range = 14,
-      spread = 0.45,
-      // Far enough out that a shell has room for its fan, and close enough in
-      // that it has fanned before it gets to the other source — which is at
-      // `sep` from one and `sep` from the other, so halfway there.
-      fanAt = Math.max(Math.floor(sep / 2), 2),
-    }: {
-      radius?: number, sep?: number, every?: number,
-      spin?: boolean, alone?: boolean, turnEvery?: number, wander?: number,
-      spread?: number, fanAt?: number, range?: number, dims?: number,
-    } = {},
-  ): Graph {
-    const graph = new Graph();
-    graph.dims = dims;
-    graph.ringRadius = 1; // the lattice is the picture; nothing to round off
-    graph.relax = true;
-    graph.wander = wander;
-    graph.sealed = true; // a closed ball: no edges to walk off, no tears
-
-    // A ball rather than a cube, so that "the same in every direction" is
-    // true of the space as well as of what is emitted into it. A disc, in two
-    // dimensions, for the same reason and by the same test.
-    const coords: number[][] = [];
-
-    (function fill(at: number[]) {
-      if (at.length === dims) {
-        if (at.reduce((r, v) => r + v * v, 0) <= radius * radius) coords.push(at);
-        return;
-      }
-
-      for (let v = -radius; v <= radius; v++) fill([...at, v]);
-    })([]);
-
-    // Nothing is charged to begin with. Every charge in this universe comes
-    // out of one of the two sources, so there is nothing to confuse a pulse
-    // with — what you see moving was emitted.
-    const { byCoord, key } = Graph.wire(
-      graph, coords, () => Polarity.Neutral, directions(dims),
-    );
-
-    // The camera is for the part of the ball that anything ever happens in,
-    // which is the part inside the absorbing edge below. Framing the whole
-    // ball instead leaves a fifth of the picture as lattice nothing can reach
-    // — and makes the shells look as though they vanish well short of the
-    // edge, when in fact they are running the whole way to it.
-    graph.focus = radius - 2;
-
-    // One source at the middle, or two facing each other across the gap,
-    // laid out along x in however many dimensions there are.
-    const at = (x: number) => new Array(dims).fill(0).map((v, i) => (i === 0 ? x : v));
-
-    const sides: [number[], MagnetSide][] = alone
-      ? [[at(0), a]]
-      : [[at(-sep), a], [at(sep), b]];
-
-    sides.forEach(([coord, side], source) => {
-      const nd = byCoord.get(key(coord));
-      if (!nd) return;
-
-      const ray = nd[0];
-      ray.magnet = true;
-      ray.source = source;
-      ray.emits = side.emits;
-      ray.phase = side.phase ?? 0;
-      ray.mass = MAGNET_MASS;
-      ray.axis = side.axis;
-      ray.turning = side.turning;
-      if (side.plane) ray.ring = turnRing(side.plane[0], side.plane[1]);
-
-      // An initial direction is named as a lattice step and resolved to the
-      // boundary that actually goes that way, so a direction the point hasn't
-      // got lands on the nearest one it has rather than on nothing.
-      if (side.moving) {
-        const length = Math.hypot(...side.moving) || 1;
-        ray.moving = graph.along(ray, side.moving.map(v => v / length), 1);
-      }
-    });
-
-    graph.onTick = g => {
-      /**
-       * The edge of the world absorbs.
-       *
-       * Left to itself this universe does not run: it fills. Every pulse
-       * charges more space than the last, nothing ever gives its charge back
-       * (a charge only stops being one by meeting its opposite head-on), and
-       * within a dozen ticks every point in the ball is a charge going
-       * somewhere. At which point the sources have nothing left to emit
-       * into — a source can only write onto space, and there isn't any — so
-       * the pulsing stops, and what is left is a ball of stuff drifting
-       * outwards, dragging the frame after it as it goes.
-       *
-       * So a charge that reaches the edge is simply undone: its polarity goes
-       * and it stops going anywhere, which is to say it becomes space again.
-       * Space is neither created nor destroyed by it — the point is still
-       * there, it is just nobody. The ball stays the size it was, the
-       * frame stays where it was, and there is always somewhere for the next
-       * pulse to go, so the pulsing is continuous rather than a burst that
-       * silts the world up.
-       *
-       * It is a boundary condition and not a rule: it says what happens at
-       * the edge of the part we are looking at, which in a universe that
-       * didn't have an edge would be nothing at all.
-       */
-      // How far out the world is still live. Ordinarily the seeded ball —
-      // held two in from its edge, since the longest step here is a corner
-      // one at √3 ≈ 1.74 and nothing may step over the edge before it is
-      // reached. But sources that travel take the experiment with them:
-      // absorbing at a fixed distance from where they STARTED would undo
-      // their field the moment they had gone anywhere, and framing there
-      // would leave them sailing off the edge of a picture of the space they
-      // had left.
-      let reach = radius - 2;
-
-      for (const nd of g.nodes) {
-        if (!nd.some(r => r.magnet)) continue;
-
-        const pos = g.gridPos.get(nd);
-        if (pos) reach = Math.max(reach, Math.hypot(...pos) + 4);
-      }
-
-      g.focus = reach;
-
-      // Spent, or out at the rim: either way it stops being a charge and goes
-      // back to being somewhere. No point is made or destroyed by it — see
-      // `range` for why the second condition alone is not enough.
-      for (const nd of g.nodes) {
-        const pos = g.gridPos.get(nd);
-        if (!pos) continue;
-
-        const out = Math.hypot(...pos) >= reach;
-
-        for (const ray of nd) {
-          if (ray.magnet) continue;
-          if (!out && (ray.age ?? 0) < range) continue;
-
-          ray.moving = undefined;
-          ray.wave = undefined;
-          ray.heading = undefined;
-          ray.age = 0;
-          ray.fanned = false;
-          for (const bd of ray.boundaries) bd.polarity = Polarity.Neutral;
-        }
-      }
-
-      /**
-       * Huygens: every point of a front is itself a source of the front to
-       * come.
-       *
-       * Without this a pulse is twenty-six bullets. Moving is a swap with
-       * space, so the number of charges in a pulse is fixed at the number of
-       * directions the source had — while the shell they are supposed to make
-       * up needs more points the bigger it gets. Twenty-six points on a shell
-       * of radius one is a shell; twenty-six on a shell of radius ten is
-       * twenty-six rays with nothing in between, and two of those crossing
-       * almost never meet.
-       *
-       * So a charge in flight writes its polarity onto the neutral space
-       * around it that lies AHEAD — `spread` is how far round the front
-       * counts as ahead, as a dot product against where it is going — and
-       * each of those goes on in the direction it was written in. Nothing is
-       * created by this: a point that was space becomes a point that is a
-       * charge, and the population is what it was. What grows is how much of
-       * the space the wave passes through it is actually in.
-       */
-      const since = g._tickId - 1;
-
-      // Which way round the magnets are by now. `phase` is what makes this a
-      // property of each one rather than of the clock they share.
-      const pulse = Math.floor(since / every);
-
-      /*
-       * There was a rule here that cleared every cell touching a source, on
-       * the grounds that the space around a source belongs to it. It kept the
-       * sources emitting, and it is why the distance between them stops
-       * falling.
-       *
-       * A cell that is wiped clean every tick can never be holding a charge,
-       * so it can never be one of two that cancel, so it can never be
-       * destroyed. Each source was therefore wrapped in a shell of
-       * indestructible space, and two such shells with the sources inside
-       * them are a floor under how close the two can get — around six steps,
-       * which is exactly where it stopped. Nothing was wrong with the
-       * attraction; it had eaten everything it was allowed to eat.
-       *
-       * What the sources actually needed was not to be silted up by charges
-       * arriving back at them, and that is handled where it happens: a charge
-       * that moves into a source is absorbed by it (see `reflections` in
-       * `tick`). One rule, at the point of contact, and no protected region
-       * anywhere.
-       */
-
-      /**
-       * The sources emit FIRST, before the front below spreads.
-       *
-       * This is not a detail of ordering, it is what decides whether there is
-       * more than one pulse at all. A source can only write onto space, and
-       * the only space it ever has is the shell of points immediately around
-       * it — which is fresh every tick, because last tick's pulse moved off
-       * it and left new space behind. Spread the existing front first and
-       * that shell is claimed by the pulse that has just left it, tagged with
-       * the pulse before's name; the source then looks round, finds itself
-       * walled in by its own last emission, and emits nothing.
-       *
-       * What comes of that is one blob rather than a train of shells: a
-       * single wave id filling outwards, whose middle radius climbs much
-       * faster than one step a tick because it is thickening as well as
-       * travelling.
-       */
-      if (since % every === 0) {
-        for (const nd of [...g.nodes]) {
-          for (const ray of [...nd]) {
-            if (!ray.magnet) continue;
-
-            const here = g.gridPos.get(nd);
-            if (!here) continue;
-
-            // One point per place, and only places next door.
-            //
-            // A source emits onto the space AROUND it, which is the couple of
-            // dozen points a step away. What it must not do is emit down
-            // every connection it happens to hold: annihilation hands what
-            // the dying points were carrying to whatever was behind them, and
-            // a charge that turns round and cancels next to its own source
-            // leaves all of it there. The source accumulates connections
-            // reaching right across the world, emits down all of them, and
-            // each emission makes more charges to come back and leave more —
-            // which is a few dozen a tick becoming a few thousand, and a
-            // universe several times the size it was seeded at.
-            const written = new Set<node>();
-
-            // A magnet that turns is somewhere else by now. Its axis steps
-            // round the plane an eighth of a turn every `turnEvery` ticks,
-            // one way or the other, and everything below reads it as it
-            // stands rather than as it was set.
-            if (ray.turning) {
-              const ring = ray.ring ?? TURN;
-              const step = Math.floor(since / turnEvery) * ray.turning + (ray.phase ?? 0);
-
-              ray.axis = ring[((step % ring.length) + ring.length) % ring.length];
-            }
-
-            const emits = ray.emits ?? Polarity.Positive;
-
-            /**
-             * One turn of a source takes a turn's worth of ticks, whatever
-             * kind of turning it does.
-             *
-             * A source that rotates comes round through the eight directions
-             * of its plane, one a tick, and is back where it started after
-             * eight. A source that only flips over has two states rather than
-             * eight — and flipping between them every tick made its cycle
-             * four times shorter than the other's, which is not a difference
-             * in kind between the two sources but an accident of counting.
-             *
-             * What it cost was space. Each ring a wave lays down is one
-             * tick's emission, and a wave advances a cell a tick, so a cycle
-             * of two ticks puts the same charge every other cell: bands one
-             * cell wide with one cell between them, which no drawing can
-             * separate and which average to nothing the moment they are
-             * smoothed. Held for half a cycle each way, the same source lays
-             * down bands four cells wide with four cells between them, and
-             * they are bands you can see.
-             *
-             * The two then differ only in what the state is FOR. A flip is
-             * the same everywhere at once, so what it writes is rings. A
-             * rotation points somewhere, so what it writes is spirals. Same
-             * clock, same wave, same spacing — the difference is whether the
-             * source's state has a direction in it.
-             */
-            const beat = ray.turning ? TURN.length : CYCLE;
-            const turn = pulse + (ray.phase ?? 0) * (beat / 2);
-            const turned = spin && ((turn % beat) + beat) % beat >= beat / 2;
-
-            const polarity = !turned ? emits
-              : emits === Polarity.Positive ? Polarity.Negative : Polarity.Positive;
-
-            // Every direction at once: the pulse is written onto everything
-            // the source is connected to, and each point of it leaves along
-            // the direction it was written in. A boundary with nothing on the
-            // far side is a direction with nowhere yet to put anything, so it
-            // waits — the frontier grows by things moving into it, not by the
-            // source shouting past the end of the world.
-            for (const bd of [...ray.boundaries]) {
-              const facing = bd.target;
-              if (!facing) continue;
-
-              const there = facing.at.node;
-              if (there === nd || written.has(there)) continue;
-
-              const at = g.gridPos.get(there);
-              if (!at) continue;
-
-              // Next door, and not down some connection that closed up over
-              // the space it used to pass through.
-              if (Math.max(...here.map((v, i) => Math.abs(at[i] - v))) !== 1) continue;
-
-              written.add(there);
-
-              // Only space can be told what to be. Anything already going
-              // somewhere is somebody, and so is the other magnet.
-              if (there.some(r => r.moving || r.magnet)) continue;
-
-              const dir = g.direction(bd);
-              if (!dir) continue;
-
-              // Which pole this direction is out of. A source with no axis
-              // has no poles and puts the same thing out everywhere; one with
-              // an axis puts `polarity` out of the half facing along it and
-              // the opposite out of the half facing back, with the ring
-              // exactly across it emitting nothing — an equator, which is
-              // what makes it a magnet and not a lamp.
-              let out = polarity;
-
-              // How nearly this direction lies along the magnet's axis: +1
-              // straight out of the north pole, −1 out of the south, 0 on the
-              // equator between them.
-              const cos = ray.axis
-                ? dir.reduce((sum, v, i) => sum + v * (ray.axis![i] ?? 0), 0)
-                  / (Math.hypot(...ray.axis) || 1)
-                : 0;
-
-              if (ray.axis) {
-                if (Math.abs(cos) < 1e-9) continue; // the equator emits nothing
-
-                if (cos < 0) out = polarity === Polarity.Positive
-                  ? Polarity.Negative
-                  : Polarity.Positive;
-              }
-
-              /**
-               * A magnet that turns radiates into the plane it turns in.
-               *
-               * Its poles are in that plane and sweeping round it, so a
-               * direction lying in the plane is swept by north, then the
-               * equator, then south — the full stroke, once per revolution.
-               * A direction along the axis it turns ABOUT is perpendicular to
-               * the poles at every moment of the turn: it sits on the dipole's
-               * equator permanently, and the equator is exactly what emits
-               * nothing. In between, the further out of the plane you are,
-               * the less of the stroke reaches you.
-               *
-               * So the emission is thrown outward rather than all around, and
-               * a revolution lays down a disk. Which is not something added
-               * to make the picture flat — the poles being in the plane is
-               * what makes it flat, and the version without this was drawing
-               * a sphere for a source that has no business making one.
-               */
-              /**
-               * A turning magnet emits along its poles, not out of half of
-               * itself.
-               *
-               * Held still, a pole is a hemisphere: everything on the north
-               * side gets north's charge, and it does not matter that the
-               * side is a hundred and eighty degrees wide, because the thing
-               * is not going anywhere and every direction in that half is
-               * being given the same answer forever.
-               *
-               * Turning, the width is the whole problem. A hemisphere pointed
-               * one way overlaps almost entirely with a hemisphere pointed an
-               * eighth of a turn later, so consecutive pulses land on top of
-               * one another and what winds out from the source is not a
-               * pattern but a wash. Measured: the distance from the source
-               * tracks how long ago a pulse left, cleanly — but the direction
-               * of it does not track where the magnet was pointing at all,
-               * because a lobe spanning half the sky has no direction to
-               * speak of.
-               *
-               * Narrowed to the poles themselves, each pulse goes one way,
-               * the next goes an eighth of a turn round from it, and the
-               * locus of them is an arm winding outward. Which is what a
-               * lighthouse is, and a pulsar, and why the beam has to be a
-               * beam for there to be a sweep at all.
-               */
-              /*
-               * Every direction, here as everywhere else.
-               *
-               * There was a cone here, narrowing a turning magnet's emission
-               * to a beam near its poles, on the reasoning that a lighthouse
-               * needs a beam to have a sweep. It does — but this is not a
-               * lighthouse, and the sweep does not have to be made of where
-               * the pulse went.
-               *
-               * A pulse goes everywhere, as it does for every other source in
-               * this article. What rotates is WHICH WAY ROUND it goes: the
-               * half of the sky facing the north pole gets one charge and the
-               * half facing south gets the other, and the line between those
-               * halves comes round an eighth of a turn every tick. So the
-               * charge a given direction receives alternates as the poles
-               * sweep past it, and the boundary between the two — traced
-               * outward through everything already in flight, each shell
-               * having been laid down with the magnet pointing somewhere
-               * slightly different — is a spiral. Not a spiral anything
-               * travels along. A spiral in the arrangement of what was
-               * emitted, which is what a rotating dipole actually makes.
-               */
-
-              for (const r of there)
-                for (const x of r.boundaries) x.polarity = out;
-
-              facing.at.moving = g.along(facing.at, dir, 1);
-
-// Nothing travels slower than anything else: a charge is a
-              // charge, and it leaves at one step a tick like everything
-              // here does.
-              
-
-              // Which emission this is: one pulse per source per turn of it,
-              // which is what makes a pulse a thing with a surface.
-              facing.at.wave = pulse * sides.length + (ray.source ?? 0);
-
-              // And whose it is, which for a turning source is what says
-              // which arm a charge is on — see the spiral pass in the
-              // renderer.
-              facing.at.source = ray.source;
-              facing.at.turning = ray.turning;
-
-              g.stats.emitted++;
-            }
-          }
-        }
-      }
-
-      /**
-       * Once each, and not straight away.
-       *
-       * Concentric shells one step apart, one per tick, moving one step per
-       * tick, are exactly the shells that tile a ball — so filling every one
-       * of them fills the ball completely, and a ball with no space in it is
-       * a ball in which nothing can move, since moving is trading places with
-       * space. That is not a near miss to be tuned around; unit shells at
-       * every radius sum to the volume they sit in, and it is why spreading
-       * on every tick froze the field solid.
-       *
-       * What is affordable is a fixed number of points per shell rather than
-       * a filled one: each ray fans out ONCE, into the ring of directions
-       * across its path, and its children never fan again. A pulse is then
-       * twenty-six rays and their fan — a couple of hundred points — however
-       * far out it gets.
-       *
-       * And it waits until `fanAt` before doing it. A shell of radius two has
-       * only a few dozen cells in it and is already as full as it can be, so
-       * fanning immediately puts every child straight into the crush around
-       * the source, walls the source in, and stops the emission. Waiting
-       * until the shell is wide enough to have somewhere to put them spends
-       * the same points where there is room for them — and where they are
-       * wanted, since what a shell is for is meeting the other one, and that
-       * happens out at the distance between the sources rather than next
-       * door.
-       */
-      if (spread <= 1) {
-        const front: { ray: Ray, dir: number[], polarity: Polarity, wave?: number }[] = [];
-
-        for (const nd of g.nodes) {
-          for (const ray of nd) {
-            if (ray.magnet || !ray.moving) continue;
-            if (ray.moving.polarity === Polarity.Neutral) continue;
-
-            // Age is counted in `tick`, once, for everything in flight.
-            if (ray.fanned || (ray.age ?? 0) < fanAt) continue;
-
-            const dir = g.direction(ray.moving);
-            if (!dir) continue;
-
-            ray.fanned = true;
-            front.push({ ray, dir, polarity: ray.moving.polarity, wave: ray.wave });
-          }
-        }
-
-        for (const { ray, dir, polarity, wave } of front) {
-          for (const bd of ray.boundaries) {
-            const facing = bd.target;
-            if (!facing) continue;
-
-            const there = facing.at.node;
-            if (there === ray.node) continue;
-            if (there.some(r => r.moving || r.magnet)) continue;
-
-            const d = g.direction(bd);
-            if (!d) continue;
-
-            // BESIDE us — not behind, and not ahead either.
-            //
-            // Behind is everywhere the wave has already been, and filling
-            // that in is a wave that never leaves anywhere. Ahead is where we
-            // are going ourselves, and filling that in is a wave that thickens
-            // into a solid ball instead of staying a surface. What is left is
-            // the ring of directions across our path, which is the front
-            // itself: the shell grows sideways, into the room a bigger shell
-            // has that a smaller one didn't.
-            const along = d.reduce((sum, v, i) => sum + v * dir[i], 0);
-            if (along < spread || along > 0.9) continue;
-
-            for (const r of there)
-              for (const x of r.boundaries) x.polarity = polarity;
-
-            // And it leaves in the direction between ours and its own, so the
-            // front fans out as it goes rather than travelling as a sheaf of
-            // parallel lines. Twenty-six directions repeatedly split between
-            // is how a lattice with twenty-six of them makes a round shell.
-            const bias = dir.map((v, i) => v + d[i]);
-
-            facing.at.moving = g.along(facing.at, bias, 1);
-            facing.at.wave = wave; // still the same pulse, spread wider
-            facing.at.source = ray.source;
-            facing.at.turning = ray.turning;
-            facing.at.age = ray.age;
-
-            // And it travels at the speed its parent does.
-            //
-            // Without this a fanned charge is quick and the charge it came
-            // from is slow — three times as quick, where the source is one
-            // that turns — so it runs out through the shell ahead of it and
-            // the one ahead of that, carrying its own polarity into the
-            // middle of theirs. Every shell ends up holding both charges at
-            // once, mixed, and the neat alternation that IS the spiral is
-            // stirred out of the field before anything gets to draw it.
-            facing.at.mass = ray.mass;
-
-            // Already fanned, as far as it is concerned. Otherwise each child
-            // fans in turn and the shell doubles every tick until it has
-            // filled everything, which is where this started.
-            facing.at.fanned = true;
-            facing.at.age = ray.age;
-          }
-        }
-      }
-    };
-
-    return graph;
-  }
-
-  /**
-   * The smallest possible universe: two spatial points A—B, one ray each,
-   * joined by a mutual boundary pair. Every permutation of (polarity,
-   * movement direction) over the two sides is one isolated experiment in the
-   * tick rules — head-on like polarities merge into one point, head-on
-   * opposite polarities annihilate, and anything else moves: away from each
-   * other they grow the structure ahead of them and instantiate the space
-   * they vacate between themselves.
-   *
-   * Each side also carries an OUTWARD boundary (no target, pointing away from
-   * the partner). Without it "moving away from the connection" would be
-   * inexpressible — a ray whose only boundary is the connection can never
-   * point elsewhere, so a side could never be at an actual boundary of the
-   * structure and moving into it.
-   */
-  static pair(a: PairSide, b: PairSide): Graph {
-    // "Towards" and "away" are the two ends of a line seen from each other:
-    // the left one heads right to close the gap, the right one heads left.
-    return Graph.line([
-      { polarity: a.polarity, moving: a.moving === 'towards' ? 'right' : 'left' },
-      { polarity: b.polarity, moving: b.moving === 'towards' ? 'left' : 'right' },
-    ]);
-  }
-
-  /**
-   * The same universe with room in it: n charges in a row, each with a
-   * polarity and a direction along the line, every point connected to the
-   * next.
-   *
-   * A pair can only do the one thing its two ends do to each other. A line
-   * of three or four has an inside — charges with something on both sides of
-   * them — so what one interaction leaves behind is what the next one has to
-   * work with. Annihilations close the line up behind them, movement trades
-   * places with the space between, and the ends grow more line to move into.
-   *
-   * Both ends carry an OUTWARD boundary (no target, pointing off the end).
-   * Without it an end moving outwards would have nowhere to be moving — it is
-   * at an actual boundary of the structure, and moves by making more of it.
-   */
-  static line(sides: LineSide[]): Graph {
-    const graph = new Graph();
-    graph.dims = 3;
-    graph.ringRadius = 1;
-
-    const n = sides.length;
-    const lefts: Boundary[] = [];
-    const rights: Boundary[] = [];
-
-    sides.forEach((side, i) => {
-      const nd: node = [];
-      const ray = new Ray(nd, graph);
-      ray.boundaries = []; // drop the constructor's default
-
-      const left = new Boundary(ray, graph);
-      left.polarity = side.polarity;
-      if (i === 0) left.outward = [-1, 0, 0];
-
-      const right = new Boundary(ray, graph);
-      right.polarity = side.polarity;
-      if (i === n - 1) right.outward = [1, 0, 0];
-
-      ray.boundaries.push(left, right);
-      ray.moving = side.moving === 'left' ? left : right;
-
-      lefts.push(left);
-      rights.push(right);
-
-      graph.nodes.push(nd);
-      graph.setPos(nd, [i - (n - 1) / 2, 0, 0]);
-    });
-
-    for (let i = 0; i + 1 < n; i++) {
-      rights[i].target = lefts[i + 1];
-      lefts[i + 1].target = rights[i];
-    }
-
-    return graph;
-  }
-
-  /**
-   * A deep copy: new nodes, rays and boundaries, with every `target` and
-   * `moving` reference remapped onto the copies. Ticking the original leaves
-   * the clone untouched, which is what lets a run be frozen state by state.
-   *
-   * Rays and boundaries are built with `Object.create` rather than `new`,
-   * because their constructors have side effects — a Ray registers itself on
-   * its node and grows a default boundary — that would corrupt the copy.
-   */
-  clone(): Graph {
-    const graph = new Graph();
-    graph.dims = this.dims;
-    graph.ringRadius = this.ringRadius;
-    graph._tickId = this._tickId;
-    graph.onTick = this.onTick;
-    graph.relax = this.relax;
-    graph.wander = this.wander;
-    graph.sealed = this.sealed;
-    graph.focus = this.focus;
-    graph.events = this.events.map(e => ({ ...e, at: e.at.slice() }));
-    graph.history = this.history.slice();
-
-    const rays = new Map<Ray, Ray>();
-    const boundaries = new Map<Boundary, Boundary>();
-
-    for (const nd of this.nodes) {
-      const copy: node = [];
-
-      for (const ray of nd) {
-        const r: Ray = Object.create(Ray.prototype);
-        r.id = ray.id;
-        r.node = copy;
-        r.boundaries = [];
-        r.magnet = ray.magnet;
-        r.emits = ray.emits;
-        r.phase = ray.phase;
-        r.source = ray.source;
-        r.wave = ray.wave;
-        r.credit = ray.credit;
-        r.mass = ray.mass;
-        r.age = ray.age;
-        r.fanned = ray.fanned;
-        r.axis = ray.axis?.slice();
-        r.turning = ray.turning;
-        r.ring = ray.ring;
-        r.heading = ray.heading?.slice();
-        rays.set(ray, r);
-        copy.push(r);
-
-        for (const bd of ray.boundaries) {
-          const b: Boundary = Object.create(Boundary.prototype);
-          b.polarity = bd.polarity;
-          b.at = r;
-          if (bd.outward) b.outward = bd.outward.slice();
-          boundaries.set(bd, b);
-          r.boundaries.push(b);
-        }
-      }
-
-      graph.nodes.push(copy);
-
-      const pos = this.gridPos.get(nd);
-      if (pos) graph.setPos(copy, pos.slice());
-    }
-
-    // Second pass — every boundary now exists, so the references between
-    // them can be resolved.
-    for (const nd of this.nodes) {
-      for (const ray of nd) {
-        const r = rays.get(ray)!;
-        if (ray.moving) r.moving = boundaries.get(ray.moving);
-
-        ray.boundaries.forEach((bd, i) => {
-          if (bd.target) r.boundaries[i].target = boundaries.get(bd.target);
-        });
-      }
-    }
-
-    return graph;
-  }
-
-  private layoutCache?: Map<node, Vec>;
-  private dirty = true;
-
-  get layout(): Map<node, Vec> {
-    // A relaxed layout is never done: it eases towards the shape the
-    // connections are asking for, and is recomputed every time it is looked
-    // at rather than once per tick, so what the structure does to it is
-    // something that happens over frames instead of in one jump.
-    if (this.relax) return this.relaxedLayout();
-
-    if (!this.layoutCache || this.dirty) {
-      this.layoutCache = this.sphereLayout({ scale: LATTICE_STEP });
-      this.dirty = false;
-    }
-
-    return this.layoutCache;
-  }
-
-  /**
-   * The last relaxed layout, which the next one starts from — and, with it,
-   * the working set the solve runs on.
-   *
-   * This is cached across frames on purpose. The connections only change when
-   * the world does, which is once a tick, while the solve runs every frame:
-   * rebuilding the list of them sixty times a second means allocating some
-   * eighty thousand of them sixty times a second, for a list that was already
-   * correct. So the structure is rebuilt when the structure changes, and in
-   * between, the passes run over what is already there — mutating the
-   * position vectors in place, which is also why the map handed to the
-   * renderer doesn't have to be rebuilt either.
-   */
-  private relaxed?: {
-    at: Map<node, Vec>;
-    P: Vec[];
-    links: { i: number, j: number, rest: number, weight: number }[];
-    correction: Vec[];
-    asked: number[];
-  };
-
-  /**
-   * Where the points are, if where they are is decided by what they are
-   * connected to.
-   *
-   * Every connection wants to be one step long — one step in ITS direction,
-   * so a face connection wants 1 and a corner connection √3, which is what
-   * keeps a lattice wired in all twenty-six directions from crumpling. A
-   * connection whose two ends are three cells apart in coordinates still
-   * wants to be one step, because the two cells in between were annihilated
-   * and are not anywhere any more. That single sentence is the gravity in
-   * this model: destroyed space is shorter space, and shorter space pulls
-   * whatever is on either side of it together.
-   *
-   * It is a positional solve rather than a force integration — each pass
-   * moves every point by the average of what its connections are asking of
-   * it — so there is no velocity to blow up and no timestep to tune. It
-   * cannot overshoot at stiffness ≤ 1, which matters when the thing being
-   * solved gains and loses points every tick.
-   */
-  relaxedLayout(
-    {
-      scale = LATTICE_STEP,
-      iterations = 3,
-      stiffness = 0.65,
-      adjacency = 12,
-    }: {
-      scale?: number, iterations?: number,
-      stiffness?: number, adjacency?: number,
-    } = {},
-  ): Map<node, Vec> {
-    const dims = this.dims;
-
-    if (!this.dirty && this.relaxed) {
-      this.solve(this.relaxed, iterations, stiffness, dims);
-
-      return this.relaxed.at;
-    }
-
-    this.dirty = false;
-
-    const previous = this.relaxed?.at;
-    const list = this.nodes;
-
-    const index = new Map<node, number>();
-    list.forEach((nd, i) => index.set(nd, i));
-
-    const P: Vec[] = new Array(list.length);
-    const fresh: number[] = [];
-
-    for (let i = 0; i < list.length; i++) {
-      const was = previous?.get(list[i]);
-
-      if (was) { P[i] = was; continue; }
-
-      fresh.push(i);
-      const grid = this.gridPos.get(list[i]);
-      P[i] = grid && grid.length ? grid.map(v => v * scale) : new Array(dims).fill(0);
-    }
-
-    // A point that has only just come into being appears where its neighbours
-    // already are, one step off them in the direction its coordinate says it
-    // lies — not at the coordinate itself. It was put down in space that has
-    // already been bent, and dropping it in at the unbent position would be a
-    // kick delivered every time anything moves.
-    const isFresh = new Set(fresh);
-
-    for (const i of fresh) {
-      const here = this.gridPos.get(list[i]);
-      if (!here) continue;
-
-      const sum = new Array(dims).fill(0);
-      let n = 0;
-
-      for (const ray of list[i]) {
-        for (const bd of ray.boundaries) {
-          const other = bd.target?.at.node;
-          if (!other) continue;
-
-          const j = index.get(other);
-          if (j === undefined || isFresh.has(j)) continue;
-
-          const there = this.gridPos.get(other);
-          if (!there) continue;
-
-          const step = latticeStep(here.map((v, k) => v - there[k]));
-          if (!step) continue;
-
-          for (let k = 0; k < dims; k++) sum[k] += P[j][k] + step[k] * scale;
-          n++;
-        }
-      }
-
-      if (n) P[i] = sum.map(v => v / n);
-    }
-
-    /**
-     * Every connection, once, with the length it is asking for and how loudly
-     * it asks. Built up front rather than per pass, since it is the same list
-     * every pass.
-     *
-     * `adjacency` is how much more a connection that spans destroyed space
-     * counts than an ordinary one, per cell it spans. At 1 they count the
-     * same, and the picture is the honest compromise: two sources that have
-     * eaten their way to each other are held apart anyway, because each of
-     * them has twenty-six other connections all quite happy where they are,
-     * and one voice against twenty-six moves nothing.
-     *
-     * Above 1 the picture takes a side. It says that a connection standing
-     * where sixteen points used to be is a stronger claim about what is next
-     * to what than a connection that has never had anything happen to it —
-     * that adjacency arrived at by destroying everything in between should
-     * win against the undisturbed shape of the lattice around it.
-     *
-     * That is a decision about the drawing and not a law of the model, and it
-     * is worth being plain that nothing derives it. What it buys is a picture
-     * in which two things that have become neighbours are drawn as
-     * neighbours, which is the thing the whole exercise is trying to show and
-     * which the even-handed version will not show at any zoom.
-     */
-    const links: { i: number, j: number, rest: number, weight: number }[] = [];
-
-    for (let i = 0; i < list.length; i++) {
-      const here = this.gridPos.get(list[i]);
-
-      for (const ray of list[i]) {
-        for (const bd of ray.boundaries) {
-          const other = bd.target?.at.node;
-          if (!other) continue;
-
-          const j = index.get(other);
-          if (j === undefined || j <= i) continue; // once per pair
-
-          const there = this.gridPos.get(other);
-          const offset = here && there ? here.map((v, k) => v - there[k]) : undefined;
-          const step = offset && latticeStep(offset);
-
-          // How far apart the two ends still are in coordinates — which, for
-          // a connection, is how much has been taken out from between them.
-          const spans = offset ? Math.max(...offset.map(Math.abs)) : 1;
-
-          links.push({
-            i, j,
-            rest: (step ? Math.hypot(...step) : 1) * scale,
-            weight: 1 + Math.max(spans - 1, 0) * adjacency,
-          });
-        }
-      }
-    }
-
-    const at = new Map<node, Vec>();
-    for (let i = 0; i < list.length; i++) at.set(list[i], P[i]);
-
-    this.relaxed = {
-      at, P, links,
-      correction: list.map(() => new Array(dims).fill(0)),
-      asked: new Array(list.length).fill(0),
-    };
-
-    this.solve(this.relaxed, iterations, stiffness, dims);
-
-    return at;
-  }
-
-  // One or more passes of the solve above, over a working set that is already
-  // built. Positions are moved in place, so everything holding a reference to
-  // one — the map the renderer reads, above all — is up to date by the time
-  // this returns.
-  private solve(
-    { P, links, correction, asked }: NonNullable<Graph['relaxed']>,
-    iterations: number,
-    stiffness: number,
-    dims: number,
-  ) {
-    for (let pass = 0; pass < iterations; pass++) {
-      for (let i = 0; i < P.length; i++) {
-        correction[i].fill(0);
-        asked[i] = 0;
-      }
-
-      for (const { i, j, rest, weight } of links) {
-        let lengthSq = 0;
-
-        for (let k = 0; k < dims; k++) {
-          const d = P[j][k] - P[i][k];
-          lengthSq += d * d;
-        }
-
-        const length = Math.sqrt(lengthSq);
-        if (length < 1e-6) continue;
-
-        // Half the error each, so neither end is privileged over the other.
-        const pull = ((length - rest) / length) * 0.5 * stiffness * weight;
-
-        for (let k = 0; k < dims; k++) {
-          const d = (P[j][k] - P[i][k]) * pull;
-          correction[i][k] += d;
-          correction[j][k] -= d;
-        }
-
-        // A weighted average, so a connection that counts for more moves its
-        // ends more — rather than a louder constraint simply overshooting,
-        // which is what an unweighted divisor would turn it into.
-        asked[i] += weight;
-        asked[j] += weight;
-      }
-
-      for (let i = 0; i < P.length; i++) {
-        const n = asked[i] || 1;
-        for (let k = 0; k < dims; k++) P[i][k] += correction[i][k] / n;
-      }
-    }
-  }
-
-  /**
-   * Deterministic cube→sphere layout.
-   *
-   * Each cell has a cube position (gridPos · scale — a crisp lattice, so
-   * the 3×3×3 seed reads as a clean cube) and a sphere position (the same
-   * direction but at a radius set by its Chebyshev ring, so corners get
-   * pulled in to share a shell). The two are blended by how far the graph
-   * has grown: pure cube at ring 1, easing to a pure sphere by MORPH_RINGS.
-   * So it starts as a nice cube and rounds into a sphere as it expands.
-   * Same graph => same output every run (no forces, no iteration).
-   */
-  sphereLayout({ scale = 50 }: { scale?: number } = {}): Map<node, Vec> {
-    const pos = new Map<node, Vec>();
-
-    const MORPH_RINGS = 6;
-    const raw = Math.min(Math.max((this.ringRadius - 1) / (MORPH_RINGS - 1), 0), 1);
-    const t = raw * raw * (3 - 2 * raw); // smoothstep cube→sphere
-
-    for (const node of this.nodes) {
-      const grid = this.gridPos.get(node);
-
-      if (!grid) {
-        pos.set(node, [0, 0, 0]);
-        continue;
-      }
-
-      const ring = Math.max(...grid.map(v => Math.abs(v)));
-
-      if (ring === 0) {
-        pos.set(node, grid.map(() => 0));
-        continue;
-      }
-
-      const euclidean = Math.hypot(...grid) || 1;
-      const sphereR = ring * scale;
-
-      pos.set(node, grid.map(v => {
-        const cube = v * scale;
-        const sphere = (v / euclidean) * sphereR;
-        return cube * (1 - t) + sphere * t;
-      }));
-    }
-
-    return pos;
-  }
-
-  invalidateLayout() {
-    this.dirty = true;
-  }
-
-  updateLayout() {
-    const layout = this.springLayout({
-      iterations: 50,
-      radius: 100,
-    });
-
-    for (const [node, pos] of layout) {
-      this.positions.set(node, pos);
-
-      if (!this.velocities.has(node)) {
-        this.velocities.set(node, [0, 0, 0]);
-      }
-    }
-
-    // remove deleted nodes
-    for (const node of [...this.positions.keys()]) {
-      if (!this.nodes.includes(node)) {
-        this.positions.delete(node);
-        this.velocities.delete(node);
-      }
-    }
-  }
-
-  /**
-   * Deterministic spring layout.
-   *
-   * Same graph => same output every run.
-   */
-  springLayout(
-    {
-      dims = 3,
-      iterations = 250,
-      radius = 100,
-      springK = 0.8,
-      rewiredSpringK = 0.2,
-      repulsionK = 300,
-      restLength = 50,
-      step = 0.01,
-    }: LayoutOptions = {},
-  ): Map<node, Vec> {
-    let nodes = this.nodes;
-    let edges = this.edges;
-
-    // Stable ordering
-    nodes = [...nodes].sort((a, b) => hashNode(a) - hashNode(b));
-
-    const index = new Map<Ray[], number>();
-
-    for (let i = 0; i < nodes.length; i++)
-      index.set(nodes[i], i);
-
-    const pos = new Map<node, Vec>();
-
-    for (const node of nodes) {
-      const grid = this.gridPos.get(node);
-
-      if (!grid) {
-        pos.set(node, Array(dims).fill(0));
-        continue;
-      }
-
-      pos.set(
-        node,
-        grid.map(v => v * restLength)
-      );
-    }
-
-    const forces: Vec[] = Array.from(
-      { length: nodes.length },
-      () => Array(dims).fill(0),
-    );
-
-    const delta = new Array(dims).fill(0);
-
-    for (let iter = 0; iter < iterations; iter++) {
-
-      // zero forces
-      for (const f of forces)
-        f.fill(0);
-
-      //
-      // REPULSION
-      //
-      for (let i = 0; i < nodes.length; i++) {
-        const pi = pos.get(nodes[i])!;
-
-        for (let j = i + 1; j < nodes.length; j++) {
-          const pj = pos.get(nodes[j])!;
-
-          let distSq = 0;
-
-          for (let k = 0; k < dims; k++) {
-            delta[k] = pj[k] - pi[k];
-            distSq += delta[k] * delta[k];
-          }
-
-          distSq = Math.max(distSq, 1e-6);
-
-          const dist = Math.sqrt(distSq);
-
-          const f = repulsionK / distSq;
-
-          for (let k = 0; k < dims; k++) {
-            const x = delta[k] / dist * f;
-
-            forces[i][k] -= x;
-            forces[j][k] += x;
-          }
-        }
-      }
-
-      //
-      // SPRINGS
-      //
-      for (const edge of edges) {
-
-        const ia = index.get(edge[0])!;
-        const ib = index.get(edge[1])!;
-
-        const pa = pos.get(edge[0])!;
-        const pb = pos.get(edge[1])!;
-
-        let distSq = 0;
-
-        for (let k = 0; k < dims; k++) {
-          delta[k] = pb[k] - pa[k];
-          distSq += delta[k] * delta[k];
-        }
-
-        const dist = Math.sqrt(Math.max(distSq, 1e-6));
-
-        const kSpring = false//edge.rewired
-          ? rewiredSpringK
-          : springK;
-
-        const f = kSpring * (dist - restLength);
-
-        for (let k = 0; k < dims; k++) {
-          const x = delta[k] / dist * f;
-
-          forces[ia][k] += x;
-          forces[ib][k] -= x;
-        }
-      }
-
-      //
-      // MOVE
-      //
-      for (let i = 0; i < nodes.length; i++) {
-
-        let magSq = 0;
-
-        for (let k = 0; k < dims; k++)
-          magSq += forces[i][k] * forces[i][k];
-
-        const maxForce = 300;
-
-        if (magSq > maxForce * maxForce) {
-          const s = maxForce / Math.sqrt(magSq);
-
-          for (let k = 0; k < dims; k++)
-            forces[i][k] *= s;
-        }
-
-        const p = pos.get(nodes[i])!;
-
-        for (let k = 0; k < dims; k++)
-          p[k] += step * forces[i][k];
-      }
-    }
-
-    return pos;
-  }
-
-}
-
-type node = Ray[]
-
-let NEXT_ID = 0;
-class Ray {
-  id: number;
-  boundaries: Boundary[] = [];
-
-  // The directional movement of this ray: the boundary (one of its own) it
-  // is currently moving towards. It heads towards the node on the far side
-  // of that boundary's connection (moving.target's node).
-  moving?: Boundary;
-
-  // A source: something that goes on writing a charge onto the space around
-  // it, tick after tick, rather than being written once and then only ever
-  // interacting. Nothing in the rules makes one — the rules have no way to
-  // begin anything — so it is the seed's doing, and the only thing the rules
-  // have to know about it is that it is never mistaken for space.
-  //
-  // `emits` is the polarity it puts out, and `phase` offsets its turning
-  // against the other sources, so two magnets can be spinning together or
-  // against each other.
-  magnet?: boolean;
-  emits?: Polarity;
-  phase?: number;
-
-  // Which way round it is: `emits` out of the half pointing this way, the
-  // opposite out of the half pointing back, nothing across the middle. Absent
-  // for a source with no sides, which puts the same thing out everywhere.
-  axis?: number[];
-
-  // Which way the axis comes round, an eighth of a turn at a time, or nothing
-  // for a magnet that is held still, and the ring of directions it comes
-  // round through. See `turnRing`.
-  turning?: number;
-  ring?: number[][];
-
-  // What a step costs this ray, as a multiple of the step's own length. One
-  // for everything the rules make; more for a source, which is the only thing
-  // here heavy enough to be worth pushing. See `MAGNET_MASS`.
-  mass?: number;
-
-  // Which source, for a source; which emission of it, for a charge that came
-  // out of one. The dynamics never read either — a charge is a charge and
-  // what it does depends on nothing but its polarity and where it is going.
-  // It is bookkeeping for the picture: what makes one pulse one pulse, and
-  // therefore something that can be drawn as a surface instead of as a few
-  // thousand unrelated points.
-  source?: number;
-  wave?: number;
-
-  // How many ticks a charge has been in flight, and whether it has yet fanned
-  // out into the room a bigger shell has that a smaller one hadn't. See the
-  // Huygens step in `Graph.magnets`.
-  age?: number;
-  fanned?: boolean;
-
-  /**
-   * The way it is going in the large, which is not the same as the step it is
-   * taking this tick.
-   *
-   * Wandering takes a direction apart — a ray heading along (1,1,1) may spend
-   * this move going (1,0,0) instead — and without somewhere to keep the whole
-   * direction, taking it apart destroys it: the step becomes the direction,
-   * its only piece is itself, and the ray is committed to an axis forever
-   * after one unlucky move. Kept here, the pieces are only ever a detour, and
-   * the way it was going is still there to come back to.
-   */
-  heading?: number[];
-
-  // How much of its next step it has paid for. A step costs its own length
-  // and a tick pays one, so a ray going along an axis is always ready and one
-  // going through a corner is ready five times in nine — which is what makes
-  // every direction travel at the same speed. See the movement half of
-  // `tick`.
-  credit?: number;
-
-  constructor(
-    public node: node, // reassignable: nodes merge on annihilation
-    graph: Graph
-  ) {
-    this.id = NEXT_ID++;
-
-    node.push(this);
-
-    this.boundaries.push(
-      new Boundary(this, graph)
-    );
-  }
-}
-
-class Boundary {
-  polarity: Polarity = Polarity.Positive;
-
-  get source(): Boundary { return Universe.random(this.at.boundaries.filter(x => x !== this)); }
-
-  // The boundary on the neighbouring node this one connects to / points at.
-  target?: Boundary;
-
-  // A boundary with no target has no neighbour to be drawn towards. `outward`
-  // gives it a bare direction (in grid units) so it can still be rendered —
-  // and so a ray has somewhere to move that ISN'T one of its connections,
-  // which is what "moving away from this connection" means.
-  outward?: number[];
-
-  constructor(public at: Ray, private readonly graph: Graph) { }
-
-  positive() { this.polarity = Polarity.Positive; }
-  negative() { this.polarity = Polarity.Negative; }
-}
-
-
-type Vec = number[];
-
-export interface LayoutOptions {
-  dims?: 2 | 3;
-  iterations?: number;
-  radius?: number;
-  springK?: number;
-  rewiredSpringK?: number;
-  repulsionK?: number;
-  restLength?: number;
-  step?: number;
-}
-
-function hashString(s: string): number {
-  let h = 2166136261;
-
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-
-  return h >>> 0;
-}
-
-function hashNode(node: node): number {
-  let h = 2166136261;
-
-  for (const ray of node) {
-    const x = hashString(String(ray.id));
-    h ^= x;
-    h = Math.imul(h, 16777619);
-  }
-
-  return h >>> 0;
-}
-
-function unit(h: number): number {
-  return (h >>> 0) / 4294967296;
-}
-
-function initialPosition(
-  node: node,
-  gridPos: number[],
-  scale: number
-): Vec {
-  return gridPos.map(v => v * scale);
-}
-
-// How many ticks one cycle of a repeating pattern runs for, when `repeated`
-// is passed as a bare boolean rather than a count.
-const DEFAULT_STEPS = 8;
-
-/**
- * How much of the universe is worth drawing.
- *
- * `lattice` draws all of it: every boundary of every point, one stroke each.
- * That is the right thing for a universe of a dozen points, where each one is
- * the subject.
- *
- * `field` is for the ones with thousands. A point wired in all twenty-six
- * directions has twenty-six boundaries, and a ball of a thousand such points
- * has some thirteen thousand connections — drawn one stroke at a time it is
- * both unaffordable and a solid grey fog. So the space is drawn as its
- * axis-aligned connections only, batched into a single path, and everything
- * on top of it is only what is HAPPENING: the sources, and the charges in
- * flight. The lattice bending is then something you can see, because there is
- * a lattice to see rather than a fill.
- */
-type RenderMode = 'lattice' | 'shells' | 'field';
-
-export interface CalculusVisualizationProps {
-  // The universe to run. A factory, not an instance: it is called again on
-  // every reset, so each cycle starts from a freshly seeded graph.
-  graph?: () => Graph;
-
-  // A repeating pattern: run this many ticks, reset to the seed, run again.
-  // `true` uses DEFAULT_STEPS; `false` runs indefinitely without resetting.
-  repeated?: boolean | number;
-
-  // Don't animate: lay every step of the pattern out at once, left to right
-  // (wrapping to further lines when there isn't the width), with an arrow
-  // between consecutive states. There is nothing to play, so no controls.
-  filmstrip?: boolean;
-
-  autoplay?: boolean;
-  height?: number;
-
-  // The gravity-flow glow. Worth it for a large universe; for a two-point one
-  // it just washes out the handful of boundaries the picture is about (and
-  // costs a few hundred gradient fills a frame, times however many of these
-  // are on the page).
-  density?: boolean;
-
-  mode?: RenderMode;
-
-  // Seconds per tick. The default is slow enough to read one interaction at a
-  // time; a universe whose interest is in what it does over a hundred ticks
-  // wants to be quicker than that.
-  interval?: number;
-}
-
-/**
- * One canvas showing one universe.
- *
- * `animate` is what separates a player from a still: with it the view runs a
- * requestAnimationFrame loop, easing the camera and handing each frame's dt
- * back to the caller (which is where ticking lives — this component only ever
- * renders, it never advances the dynamics). Without it the universe is drawn
- * exactly once, with the camera snapped straight to its target orientation
- * rather than eased into it, since there are no later frames to ease over.
- */
-/**
- * Runs something while an element is worth drawing, and stops it when it is
- * not.
- *
- * An article like this one is thirty-odd universes stacked up a page, of
- * which at most two are on screen. Every one of them left running is a frame
- * loop, a tick, and a canvas the size of the viewport being filled sixty
- * times a second for nobody — which is most of what the page costs, and the
- * reason it got slower the further down it went.
- *
- * A margin, so that a view is going by the time it is looked at rather than
- * starting the moment it is: half a screen is enough at any speed a page is
- * read at, and costs nothing when it turns out to be wrong.
- */
-const whileOnScreen = (el: Element, show: (visible: boolean) => void) => {
-  if (typeof IntersectionObserver === "undefined") {
-    // Nothing to watch with: the old behaviour, which is to run regardless.
-    show(true);
-
-    return () => { };
-  }
-
-  const watcher = new IntersectionObserver(
-    entries => show(entries[entries.length - 1].isIntersecting),
-    { rootMargin: "50% 0px" },
-  );
-
-  watcher.observe(el);
-
-  return () => watcher.disconnect();
-};
-
-const GraphView = ({
-  graph: current,
-  animate = false,
-  density = true,
-  mode = 'lattice',
-  onFrame,
-  onVisible,
-}: {
-  // Read afresh every frame, so a reset that swaps the whole graph out is
-  // picked up without tearing the render loop down. Nothing at all is a
-  // universe that has been let go of because nobody is looking at it — the
-  // view draws nothing rather than pretending there is something to draw.
-  graph: () => Graph | null;
-  animate?: boolean;
-  density?: boolean;
-  mode?: RenderMode;
-  onFrame?: (dt: number) => void;
-
-  // Called as the view comes on and off screen, so that whoever owns the
-  // universe can let go of it and make a new one. See `CalculusPlayer`.
-  onVisible?: (visible: boolean) => void;
-}) => {
-  const canvasRef = useRef(null);
-  const camRef = useRef({ scale: 44, rot: Math.PI / 4, tilt: 0.6155, anchor: null, dist: null, distMult: 1.5, scaleMult: 1 });
-
-  // The frame loop is set up once and outlives every re-render, so it must
-  // not capture these — a callback closed over at mount time would still be
-  // looking at the state of the world as it was then (which is what made
-  // pausing do nothing: the loop kept calling the first render's onFrame,
-  // where `running` was frozen at its initial value). Kept in refs and read
-  // per frame, so the loop always calls the current ones.
-  const latest = useRef({ current, onFrame, onVisible });
-  latest.current = { current, onFrame, onVisible };
-
-  // TODO Right click/left click cursor=grab
-  useEffect(() => {
-    const canvas = canvasRef.current;
-    const ctx = canvas.getContext("2d");
-    let raf = 0;
-    let last = performance.now();
-
-    // Whether anyone is looking. Nothing is drawn, ticked or held on to
-    // until this is true — see the observer at the bottom of this effect.
-    let seen = false;
-
-    // The field as drawn, which lags the field as computed and catches up a
-    // fraction every frame. Kept across frames because that lag is the whole
-    // of what makes the animation flow rather than step.
-    let eased: Float32Array | null = null;
-
-    function resize() {
-      const parent = canvas.parentElement;
-      const w = parent.clientWidth, h = parent.clientHeight;
-      const ratio = window.devicePixelRatio || 1;
-      canvas.width = w * ratio;
-      canvas.height = h * ratio;
-      canvas.style.width = w + "px";
-      canvas.style.height = h + "px";
-      ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
-    }
-
-    // Deliberately not called here: a view that is never scrolled to should
-    // never take its pixels at all. `show` asks for them.
-    const onResize = () => {
-      resize();
-      // No frame loop to pick the new size up — but only if there is anyone
-      // to pick it up for.
-      if (!animate && seen) draw();
-    };
-
-    // Only while it is on screen; off screen there is no buffer to resize,
-    // and it will be asked for at the size it is when it comes back.
-    const onResizeIfSeen = () => { if (seen) onResize(); };
-    window.addEventListener("resize", onResizeIfSeen);
-
-    // Scroll to zoom. 2D: cursor-anchored zoom (screen-space, no depth to
-    // navigate) — modifies cam.scaleMult. 3D: real dolly — scrolling
-    // moves the camera closer/farther along the view axis, driving
-    // genuine perspective rather than a flat scale.
-    // function onWheel(e) {
-    //   e.preventDefault();
-    //   const factor = Math.exp(-e.deltaY * 0.001);
-    //   const cam = camRef.current;
-
-    //   if (dim === 3) {
-    //     cam.distMult = Math.min(Math.max((cam.distMult || 1.5) / factor, 0.01), 200);
-    //     return;
-    //   }
-
-    //   const rect = canvas.getBoundingClientRect();
-    //   const rx = e.clientX - rect.left - rect.width / 2;
-    //   const ry = e.clientY - rect.top - rect.height / 2;
-    //   const curPanX = cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
-    //   const curPanY = cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
-    //   cam.anchor = {
-    //     worldX: (rx - curPanX) / cam.scale,
-    //     worldY: (ry - curPanY) / cam.scale,
-    //     screenX: rx,
-    //     screenY: ry,
-    //   };
-    //   cam.scaleMult = Math.min(Math.max((cam.scaleMult || 1) * factor, 1e-4), 1e4);
-    // }
-    // canvas.addEventListener("wheel", onWheel, { passive: false });
-
-    // // Right-click drag to orbit (3D) — horizontal drag rotates, vertical
-    // // drag adjusts tilt. Suppress the browser context menu so right-click
-    // // is free to use as a drag button.
-    // function onContextMenu(e) {
-    //   e.preventDefault();
-    // }
-    // canvas.addEventListener("contextmenu", onContextMenu);
-
-    // let dragging = false;
-    // let lastX = 0, lastY = 0;
-    // function onMouseDown(e) {
-    //   if (e.button !== 2) return;
-    //   dragging = true;
-    //   lastX = e.clientX;
-    //   lastY = e.clientY;
-    // }
-    // function onMouseMove(e) {
-    //   if (!dragging) return;
-    //   const dx = e.clientX - lastX, dy = e.clientY - lastY;
-    //   lastX = e.clientX;
-    //   lastY = e.clientY;
-    //   const cam = camRef.current;
-    //   cam.rot += dx * 0.006;
-    //   cam.tilt = Math.min(Math.max(cam.tilt + dy * 0.006, -1.15), 1.15);
-    // }
-    // function onMouseUp(e) {
-    //   if (e.button === 2) dragging = false;
-    // }
-    // canvas.addEventListener("mousedown", onMouseDown);
-    // window.addEventListener("mousemove", onMouseMove);
-    // window.addEventListener("mouseup", onMouseUp);
-
-    function project(pos, rot, tilt, camDist) {
-      const x = pos[0] || 0, y = pos[1] || 0, z = pos[2] || 0;
-      // if (dim === 2) return { x, y, depth: 1, clipped: false };
-      const cosR = Math.cos(rot), sinR = Math.sin(rot);
-      const x1 = x * cosR - z * sinR;
-      const z1 = x * sinR + z * cosR;
-      const cosT = Math.cos(tilt), sinT = Math.sin(tilt);
-      const y1 = y * cosT - z1 * sinT;
-      const z2 = y * sinT + z1 * cosT;
-      // True perspective: camera sits at distance camDist from the origin
-      // along the view axis. Points nearer the camera than that (denom small
-      // or negative) are behind/at the lens and get clipped. Convergence
-      // toward a vanishing point is now the CORRECT result of an actual
-      // camera, not a bug — it's what "moving the camera closer" means.
-      const denom = z2 + camDist;
-      if (denom < camDist * 0.02) return { x: 0, y: 0, depth: 0, clipped: true };
-      const persp = camDist / denom;
-      return { x: x1 * persp, y: y1 * persp, depth: Math.min(Math.max(persp, 0.15), 6), clipped: false };
-    }
-
-    function draw() {
-      const cam = camRef.current;
-      const graph = latest.current.current();
-      if (!graph) return;
-      // The outline enclosing a set of points. Andrew's monotone chain:
-      // sort, then walk once along the bottom and once back along the top,
-      // dropping any point the walk turns the wrong way at.
-      const outline = (at: { x: number, y: number }[]) => {
-        const p = at.slice().sort((a, b) => a.x - b.x || a.y - b.y);
-        const turn = (o: typeof p[0], a: typeof p[0], b: typeof p[0]) =>
-          (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
-
-        const half = (source: typeof p) => {
-          const out: typeof p = [];
-
-          for (const q of source) {
-            while (out.length >= 2 && turn(out[out.length - 2], out[out.length - 1], q) <= 0) out.pop();
-            out.push(q);
-          }
-
-          out.pop();
-
-          return out;
-        };
-
-        return half(p).concat(half(p.slice().reverse()));
-      };
-
-      // Both of the two field renderings want the lattice, the sources and
-      // the marks; they differ in what they make of the charges.
-      const field = mode !== 'lattice';
-      const contours = mode === 'field';
-
-      const w = canvas.clientWidth, h = canvas.clientHeight;
-
-      ctx.fillStyle = "#06070c";
-      ctx.fillRect(0, 0, w, h);
-      const vg = ctx.createRadialGradient(w / 2, h / 2, 0, w / 2, h / 2, Math.max(w, h) / 1.05);
-      vg.addColorStop(0, "rgba(20,22,34,0)");
-      vg.addColorStop(1, "rgba(0,0,0,0.55)");
-      ctx.fillStyle = vg;
-      ctx.fillRect(0, 0, w, h);
-
-      if (graph.nodes.length === 0) return;
-
-      const layout = graph.layout;
-
-      // What the camera measures itself against. Everything, unless the
-      // universe has said which part of itself is the subject — see `focus`.
-      const framed = graph.focus === undefined
-        ? [...layout]
-        : [...layout].filter(([nd]) => graph.inFocus(nd));
-
-      // Raw world extent (unprojected) — this is what the base pixel scale
-      // tracks, deliberately independent of camera distance/perspective, so
-      // there's no feedback loop between "how far the camera has dollied" and
-      // "how much of the grid fits on screen". A real camera doesn't refit
-      // its FOV to guarantee everything stays visible as it moves closer.
-      let worldExtent = 1e-6;
-      for (const [node, pos] of framed) {
-        const r = Math.hypot(...pos);
-        if (r > worldExtent) worldExtent = r;
-      }
-
-      // Auto-orient the camera to the effective dimensionality of what's
-      // actually on screen: measure the spread along each world axis and
-      // count how many are meaningfully populated. A 1D structure (one
-      // axis) lies flat as a horizontal line, a 2D structure (two axes) is
-      // viewed straight-on/top-down, and a 3D structure gets a ¾
-      // perspective. The camera eases toward the target so a change in
-      // dimensionality (e.g. a line thickening into a plane) animates
-      // rather than snapping.
-      const lo = [Infinity, Infinity, Infinity];
-      const hi = [-Infinity, -Infinity, -Infinity];
-      for (const [, pos] of framed) {
-        for (let k = 0; k < 3; k++) {
-          const v = pos[k] || 0;
-          if (v < lo[k]) lo[k] = v;
-          if (v > hi[k]) hi[k] = v;
-        }
-      }
-      const extent = [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]];
-      const maxExtent = Math.max(extent[0], extent[1], extent[2], 1e-6);
-      const effDims = extent.filter(e => e > maxExtent * 0.15).length;
-
-      const targetRot = effDims >= 3 ? Math.PI / 4 : 0;
-      const targetTilt = effDims >= 3 ? 0.6155 : 0;
-      // A still has no later frames to ease over, so it snaps.
-      const orientEase = animate ? 0.12 : 1;
-      cam.rot += (targetRot - cam.rot) * orientEase;
-      cam.tilt += (targetTilt - cam.tilt) * orientEase;
-
-      // Scale/distance are always exactly proportional to the grid's current
-      // size — recomputed directly every frame, not smoothed toward a target.
-      // That matters for two reasons: (1) no lerp means nothing ever "chases"
-      // a moving target, which is what read as unwanted drift; (2) being
-      // exactly proportional means the camera can never fall behind the
-      // grid's exponential physical growth, which a genuinely fixed distance
-      // eventually does — that falling-behind is what looked like runaway
-      // automatic zoom-in with no way to scroll back out. The user's zoom
-      // level (scaleMult / distMult) is a stable multiplier riding on top,
-      // changed only by scroll — never reset or overridden automatically.
-      cam.dist = worldExtent * (cam.distMult || 1.5);
-      // cam.scale is fit to the projected bounding box below (once every
-      // node has been projected), so the zoom matches the actual on-screen
-      // shape and the available width/height — see the fit step.
-
-      // Cursor-anchored pan only applies in 2D — there's no camera distance to
-      // dolly there, so screen-space zoom-toward-cursor is the natural
-      // control. In 3D the camera orbits/dollies toward the origin, which is
-      // the standard convention for an orbit camera.
-      // const panX = dim === 2 && cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
-      // const panY = dim === 2 && cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
-      const cx = w / 2 /*+ panX*/, cy = h / 2 /*+ panY*/;
-
-      const projected = new Map();
-      for (const [n, pos] of layout)
-        projected.set(n, project(pos, cam.rot, cam.tilt, cam.dist || 1));
-
-      // Where a boundary's stub points, in projected (pre-scale) space: at
-      // its neighbour, or one lattice step along its bare outward direction.
-      // The same two cases the renderer draws, so the box below is measured
-      // against exactly what ends up on the canvas.
-      const aims = (n: node, bd: Boundary) => {
-        if (bd.target) return projected.get(bd.target.at.node);
-
-        const wp = layout.get(n);
-        if (!bd.outward || !wp) return undefined;
-
-        return project(
-          wp.map((v, i) => v + (bd.outward![i] || 0) * LATTICE_STEP),
-          cam.rot, cam.tilt, cam.dist || 1,
-        );
-      };
-
-      // Fit-to-viewport zoom: size the structure from its actual PROJECTED
-      // extent against the available width and height. A horizontal line
-      // fills the width, a flat plane fills the frame, and a sphere sits
-      // inside the smaller dimension — each zoomed appropriately for its
-      // shape rather than assumed spherical. Boundary stubs are measured
-      // along with the nodes: the outward ones reach past the outermost node
-      // by a quarter of a lattice step, which on a two-point universe is a
-      // large fraction of the whole picture, and would otherwise hang off
-      // the edge of the canvas.
-      let loX = Infinity, hiX = -Infinity, loY = Infinity, hiY = -Infinity;
-      const consider = (x: number, y: number) => {
-        if (x < loX) loX = x;
-        if (x > hiX) hiX = x;
-        if (y < loY) loY = y;
-        if (y > hiY) hiY = y;
-      };
-      for (const [n, p] of projected) {
-        if (p.clipped || !graph.inFocus(n)) continue;
-        consider(p.x, p.y);
-
-        for (const ray of n) {
-          for (const bd of ray.boundaries) {
-            const t = aims(n, bd);
-            if (!t || t.clipped) continue;
-            consider(p.x + (t.x - p.x) * BOUNDARY_STUB, p.y + (t.y - p.y) * BOUNDARY_STUB);
-          }
-        }
-      }
-      if (loX > hiX) { loX = hiX = loY = hiY = 0; } // nothing survived clipping
-
-      // The camera frames what is actually there, rather than the world
-      // origin: the middle of that bounding box is what lands in the middle
-      // of the canvas. A universe that has drifted off the origin — every
-      // node merged onto one side, say — is still centred on screen instead
-      // of clinging to an edge.
-      const midX = (loX + hiX) / 2, midY = (loY + hiY) / 2;
-      const halfX = Math.max((hiX - loX) / 2, 1e-6);
-      const halfY = Math.max((hiY - loY) / 2, 1e-6);
-
-      const FIT_MARGIN = 0.9; // small gap at the edges
-      cam.scale = Math.min(
-        (w * 0.5 * FIT_MARGIN) / halfX,
-        (h * 0.5 * FIT_MARGIN) / halfY,
-        // A single point has no extent to fit, and would otherwise ask for
-        // an infinite zoom.
-        Math.min(w, h) / LATTICE_STEP,
-      ) * (cam.scaleMult || 1);
-
-      // Projected space to canvas pixels. Everything drawn goes through this,
-      // so the framing above holds for nodes, boundaries and the density
-      // cloud alike.
-      const place = (pr: { x: number, y: number, depth: number, clipped: boolean }) => ({
-        x: cx + (pr.x - midX) * cam.scale,
-        y: cy + (pr.y - midY) * cam.scale,
-        depth: pr.depth,
-        clipped: pr.clipped,
-      });
-
-      const pts = new Map();
-      for (const [n, p] of projected) pts.set(n, place(p));
-
-      // Screen position of an arbitrary world point, through the same camera
-      // as the nodes — used for boundaries that point somewhere no node is.
-      const screenOf = (world: Vec) =>
-        place(project(world, cam.rot, cam.tilt, cam.dist || 1));
-
-      // The seed of an expanding universe — the one cell at the origin.
-      const isCenterNode = (nd: node) => {
-        const g = graph.gridPos.get(nd);
-        return !!g && g.every(v => v === 0);
-      };
-
-      // Viewport culling: skip the detailed rendering work (ray projection,
-      // shadowBlur, stroke/fill calls) for anything clearly off-screen. Once
-      // zoomed into part of a large structure, most of the population isn't
-      // actually visible — this is what stops paying for it anyway. Margin
-      // is generous (a couple of scale-units of screen space) so a node just
-      // outside the canvas edge doesn't have its still-visible ray tip
-      // prematurely clipped.
-      const cullMargin = cam.scale * 2;
-      const onScreen = (p) => p.x > -cullMargin && p.x < w + cullMargin && p.y > -cullMargin && p.y < h + cullMargin;
-
-      // Connections — one faint line per boundary link (deduped), following
-      // the actual graph structure, so merged and newly-created nodes read
-      // correctly wherever they sit.
-      //
-      // In `field` mode this is the whole of how space is drawn, and it is
-      // one path stroked once rather than a stroke per connection — a lattice
-      // wired in every direction has too many of them for anything else. Only
-      // the axis-aligned ones are taken: the diagonals are just as real, but
-      // drawing all twenty-six through every point is a grey fill you can
-      // read nothing off, where three lines through every point is a grid
-      // whose bending is the thing worth seeing.
-      // Faint enough to be the paper rather than the drawing: what the
-      // lattice is here for is to be bent, and reading a bend needs only
-      // enough of a grid to see it against.
-      ctx.strokeStyle = field ? "rgba(124,136,176,0.05)" : "rgba(140,150,180,0.3)";
-      ctx.lineWidth = field ? 1 : 2.2;
-      const idxOf = new Map<node, number>();
-      graph.nodes.forEach((nd, i) => idxOf.set(nd, i));
-
-      if (field) ctx.beginPath();
-      for (const nd of graph.nodes) {
-        const a = pts.get(nd);
-        if (!a || a.clipped) continue;
-
-        // Outside the frame there is lattice nothing can reach — the edge
-        // absorbs before anything gets there — so it is a few thousand
-        // segments a frame drawn beyond the edge of the picture.
-        if (field && !graph.inFocus(nd)) continue;
-
-        for (const ray of nd) {
-          for (const bd of ray.boundaries) {
-            const other = bd.target?.at.node;
-            if (!other || other === nd) continue;
-
-            // Each connection drawn once, from its lower-numbered end. This
-            // was a set of "ia-ib" strings, which on a lattice wired in
-            // twenty-six directions is a couple of hundred thousand strings
-            // built and hashed every frame to answer a question two integers
-            // already answer.
-            if (idxOf.get(nd)! > idxOf.get(other)!) continue;
-
-            const b = pts.get(other);
-            if (!b || b.clipped) continue;
-            if (!onScreen(a) && !onScreen(b)) continue;
-
-            if (field) {
-              const from = graph.gridPos.get(nd), to = graph.gridPos.get(other);
-              if (!from || !to) continue;
-
-              // One step, along an axis. Anything longer is a connection that
-              // has closed up over space that was annihilated out from
-              // between its two ends — real, and the reason the two ends are
-              // now near each other, but it is not an event and must not look
-              // like one. They accumulate: every cancellation there has ever
-              // been leaves one behind, permanently, so marking them out puts
-              // a growing web of bright lines over the picture that reads as
-              // things happening everywhere at once and never stopping.
-              //
-              // What they do is already visible without drawing them, because
-              // the layout is solved against them (`relaxedLayout`): they pull
-              // their ends together, and that pulling IS the attraction. So
-              // they are left to act rather than shown acting.
-              const off = from.map((v, i) => to[i] - v);
-              if (off.filter(v => v !== 0).length !== 1) continue;
-              if (Math.max(...off.map(Math.abs)) > 1) continue;
-
-              ctx.moveTo(a.x, a.y);
-              ctx.lineTo(b.x, b.y);
-              continue;
-            }
-
-            ctx.beginPath();
-            ctx.moveTo(a.x, a.y);
-            ctx.lineTo(b.x, b.y);
-            ctx.stroke();
-          }
-        }
-      }
-
-      if (field) ctx.stroke();
-
-      // Gravity-flow density cloud — the warm glow that fills the dense
-      // core. A continuous scalar potential sampled on a real 3D grid,
-      // colored on a dark→purple→orange→white ramp and blended additively
-      // so overlapping samples read as one smooth glow. Fully world-space:
-      // every sample is a real coordinate run through the same camera as
-      // the nodes, so it navigates identically.
-      const sources: { pos: Vec; sign: number; w: number }[] = [];
-      for (const nd of density ? graph.nodes : []) {
-        const mv = nd[0] && nd[0].moving;
-        if (!mv) continue;
-        const wpos = layout.get(nd);
-        if (!wpos) continue;
-        // Positive polarity glows one way, Negative the other; neutral space
-        // contributes nothing to pull against.
-        if (mv.polarity === Polarity.Neutral) continue;
-        sources.push({ pos: wpos, sign: mv.polarity === Polarity.Positive ? 1 : -1, w: 1 });
-      }
-      const MAX_SOURCES = 220;
-      if (sources.length > MAX_SOURCES) {
-        sources.sort((x, y) => y.w - x.w);
-        sources.length = MAX_SOURCES;
-      }
-
-      if (sources.length > 0) {
-        const SOFTEN_SQ = (0.6 * worldExtent) ** 2 * 0.02 + 0.04;
-        const gridExtent = worldExtent * 1.05;
-        const RES = 7;
-        const stepG = (gridExtent * 2) / RES;
-        const depthStackCompensation = 1 / (RES * 0.45);
-
-        const densityColor = (t: number, alpha: number) => {
-          t = Math.min(Math.max(t, 0), 1);
-          let r: number, g: number, b: number;
-          if (t < 0.4) { const u = t / 0.4; r = u * 60; g = u * 20; b = u * 70; }
-          else if (t < 0.75) { const u = (t - 0.4) / 0.35; r = 60 + u * 195; g = 20 + u * 95; b = 70 - u * 30; }
-          else { const u = (t - 0.75) / 0.25; r = 255; g = 115 + u * 140; b = 40 + u * 215; }
-          return `rgba(${r | 0},${g | 0},${b | 0},${alpha})`;
-        };
-
-        const samples: { pos: Vec; mag: number }[] = [];
-        let maxMag = 0;
-        const sp: number[] = new Array(3);
-        const build = (axis: number) => {
-          if (axis === 3) {
-            let potential = 0;
-            for (const src of sources) {
-              let distSq = SOFTEN_SQ;
-              for (let k = 0; k < 3; k++) distSq += (src.pos[k] - sp[k]) ** 2;
-              potential += (src.w * src.sign) / distSq;
-            }
-            const mag = Math.max(potential, 0);
-            if (mag > maxMag) maxMag = mag;
-            samples.push({ pos: sp.slice(), mag });
-            return;
-          }
-          for (let i = 0; i < RES; i++) { sp[axis] = -gridExtent + i * stepG + stepG / 2; build(axis + 1); }
-        };
-        build(0);
-
-        const withDepth = samples
-          .map(s => ({ s, proj: project(s.pos, cam.rot, cam.tilt, cam.dist || 1) }))
-          .filter(x => !x.proj.clipped);
-        withDepth.sort((x, y) => y.proj.depth - x.proj.depth);
-
-        const prevComposite = ctx.globalCompositeOperation;
-        ctx.globalCompositeOperation = "lighter";
-        for (const { s, proj } of withDepth) {
-          const { x, y } = place(proj);
-          if (!onScreen({ x, y })) continue;
-          const depthFactor = Math.min(Math.max(proj.depth, 0.3), 1.8);
-          const norm = maxMag > 0 ? Math.min(s.mag / maxMag, 1) : 0;
-          if (norm < 0.015) continue;
-          const radius = (stepG * cam.scale * 0.9 + norm * cam.scale * 0.5) * depthFactor;
-          if (radius < 1.5) continue;
-          const alpha = Math.min(0.05 + norm * 0.35, 0.4) * Math.min(depthFactor, 1) * depthStackCompensation;
-          const grad = ctx.createRadialGradient(x, y, 0, x, y, radius);
-          grad.addColorStop(0, densityColor(norm, alpha));
-          grad.addColorStop(1, densityColor(norm, 0));
-          ctx.fillStyle = grad;
-          ctx.beginPath();
-          ctx.arc(x, y, radius, 0, Math.PI * 2);
-          ctx.fill();
-        }
-        ctx.globalCompositeOperation = prevComposite;
-      }
-
-      /**
-       * The way from one source to the other, as it currently runs.
-       *
-       * Two sources that have eaten the space between them end up one step
-       * apart along ONE route, and as far apart as they ever were along every
-       * other — because what a pulse meeting a pulse destroys is a line, not
-       * a region. That structure has no faithful drawing in three dimensions:
-       * asked to put two points both next to each other and far apart, a
-       * layout can only compromise, and that compromise is the dimple you see
-       * instead of two things arriving.
-       *
-       * So the closeness is drawn as what it actually is — the chain of
-       * points you would have to pass through to get from one source to the
-       * other. Long and wandering to begin with, a short bright link between
-       * two neighbours by the end. That shortening IS the attraction, and it
-       * is visible here whether or not the two are ever drawn near each
-       * other.
-       */
-      if (field && graph.route.length > 1) {
-        const chain = graph.route
-          .map(nd => pts.get(nd))
-          .filter(p => p && !p.clipped) as { x: number, y: number }[];
-
-        if (chain.length > 1) {
-          ctx.strokeStyle = "rgba(255,214,66,0.45)";
-          ctx.lineWidth = 2.4;
-          ctx.lineCap = "round";
-          ctx.beginPath();
-          ctx.moveTo(chain[0].x, chain[0].y);
-          for (let i = 1; i < chain.length; i++) ctx.lineTo(chain[i].x, chain[i].y);
-          ctx.stroke();
-
-          ctx.fillStyle = "rgba(255,232,150,0.8)";
-          for (const p of chain) {
-            ctx.beginPath();
-            ctx.arc(p.x, p.y, 2, 0, Math.PI * 2);
-            ctx.fill();
-          }
-
-          ctx.lineCap = "butt";
-        }
-      }
-
-      /**
-       * One surface per pulse: the shells as they were drawn before.
-       *
-       * Each emission is taken on its own and given the outline that encloses
-       * it — split by charge as well as by pulse, because a source with poles
-       * throws opposite charges out of its two halves in the same breath and
-       * collecting them together loses the fact that it has sides at all.
-       *
-       * Not drawn as circles: the outline is taken from where the charges
-       * actually are, so a shell crossing space that has been eaten comes out
-       * dented, which is the thing worth seeing in the examples where the two
-       * magnets are pulling on each other.
-       */
-      if (field && !contours) {
-        const waves = new Map<string, {
-          at: { x: number, y: number }[], depth: number, out: number, polarity: Polarity,
-        }>();
-
-        for (const nd of graph.nodes) {
-          if (!graph.inFocus(nd)) continue;
-
-          for (const ray of nd) {
-            if (ray.magnet || !ray.moving || ray.wave === undefined) continue;
-            if (ray.moving.polarity === Polarity.Neutral) continue;
-
-            const p = pts.get(nd);
-            if (!p || p.clipped) continue;
-
-            const key = `${ray.wave}|${ray.moving.polarity}`;
-
-            let wave = waves.get(key);
-            if (!wave) waves.set(key, wave = {
-              at: [], depth: 0, out: 0, polarity: ray.moving.polarity,
-            });
-
-            wave.at.push({ x: p.x, y: p.y });
-            wave.depth += p.depth;
-
-            const wp = layout.get(nd);
-            if (wp) wave.out += Math.hypot(...wp) / ((graph.focus ?? 12) * LATTICE_STEP);
-
-            break;
-          }
-        }
-
-        const shells = [...waves.values()]
-          .filter(wave => wave.at.length >= 3)
-          .map(wave => ({
-            hull: outline(wave.at),
-            depth: wave.depth / wave.at.length,
-            out: Math.min(wave.out / wave.at.length, 1),
-            polarity: wave.polarity,
-          }))
-          .filter(shell => shell.hull.length >= 3)
-          // Far ones first, so a near shell reads as in front of one behind
-          // it rather than the two adding up.
-          .sort((a, b) => b.depth - a.depth);
-
-        const prev = ctx.globalCompositeOperation;
-        ctx.globalCompositeOperation = "lighter";
-
-        for (const shell of shells) {
-          const tint = shell.polarity === Polarity.Positive ? "255,122,69" : "61,220,255";
-          const h = shell.hull;
-          const at = (i: number) => h[(i % h.length + h.length) % h.length];
-
-          // A smooth closed curve rather than the corners it was computed
-          // from: the straight lines between them are an artefact of there
-          // being finitely many charges, and drawing those claims the shell
-          // has facets and edges, which nothing supports.
-          ctx.beginPath();
-          ctx.moveTo(h[0].x, h[0].y);
-
-          for (let i = 0; i < h.length; i++) {
-            const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
-
-            ctx.bezierCurveTo(
-              p1.x + (p2.x - p0.x) / 6, p1.y + (p2.y - p0.y) / 6,
-              p2.x - (p3.x - p1.x) / 6, p2.y - (p3.y - p1.y) / 6,
-              p2.x, p2.y,
-            );
-          }
-
-          ctx.closePath();
-
-          // Bright where it was emitted, faint by the time it is far out — a
-          // wave spreading the same charge over a larger and larger surface.
-          const lift = Math.max(1 - shell.out, 0);
-          const fade = 0.1 + lift * lift * 0.9;
-
-          ctx.fillStyle = `rgba(${tint},${0.06 * fade})`;
-          ctx.fill();
-
-          ctx.strokeStyle = `rgba(${tint},${0.55 * fade})`;
-          ctx.lineWidth = 1.2;
-          ctx.stroke();
-        }
-
-        ctx.globalCompositeOperation = prev;
-      }
-
-      /**
-       * ONE of two ways of drawing the same charges, and they answer
-       * different questions.
-       *
-       * `shells` draws each pulse: one surface per emission, so what you see
-       * is the source letting go of shell after shell and each of them
-       * travelling. It is the honest picture of a thing that emits, and for a
-       * source that only flips over it is the whole story, since every shell
-       * is the same in every direction and there is nothing else to say about
-       * one.
-       *
-       * `field` draws what the pulses add up to: the region where the field
-       * is one charge and the region where it is the other, with the boundary
-       * between them. For a source that TURNS, that is the only way to see
-       * what it is doing — a turning source lays down a spiral, and a spiral
-       * is a property of a whole train of shells and of none of them
-       * separately. Drawn shell by shell it is a stack of lobes, and the
-       * winding they make is nowhere in the picture.
-       *
-       * Two surfaces. Not two hundred.
-       *
-       * A charge at distance r in direction θ left r cells ago, when the
-       * magnet's north pole pointed at α − ωr rather than at α. So its sign
-       * depends on θ − ωr: the positive charges are one Archimedean spiral
-       * winding out from the source, and the negative ones fill exactly the
-       * gaps between its turns. One body each, connected from the middle to
-       * the edge, and neither is ever where the other is.
-       *
-       * Drawing per pulse guarantees the one thing that must not happen. A
-       * pulse is a ring, so a picture made of pulses is a stack of rings
-       * lying across one another — when what is actually there is two
-       * interleaved spirals that never cross at all.
-       *
-       * So the outline is still an outline, drawn exactly as the shells were:
-       * a smooth closed curve, barely filled, its own colour at the edge,
-       * fading with distance. What changed is what it goes round. Instead of
-       * enclosing the charges of one pulse, it follows the edge of the region
-       * where the field has that sign — which is found by reconstructing the
-       * field from the charges and walking the line along which it crosses.
-       * The result is one curve per body rather than one per pulse, it is
-       * shaped like the body (so it winds, because the body winds), and two
-       * of them can no more overlap than a place can be both positive and
-       * negative.
-       */
-      if (contours) {
-        const CELL = 4;                                 // pixels per sample
-        const cols = Math.max(Math.ceil(w / CELL), 1);
-        const rows = Math.max(Math.ceil(h / CELL), 1);
-
-        const sum = new Float32Array(cols * rows);
-        const weight = new Float32Array(cols * rows);
-        const near = new Float32Array(cols * rows);
-        const cut = new Float32Array(cols * rows);
-
-        /**
-         * The average over a square neighbourhood, however wide, for the
-         * price of one.
-         *
-         * A running total gives every sample the mean over its whole
-         * neighbourhood in one pass per axis, where a diffusion of the same
-         * width costs passes going as the square of it. It is a cruder shape
-         * of average than the smoothing the picture is drawn from, and it is
-         * used only where nothing is drawn from it — spreading the directions
-         * the charges are travelling in, and deciding how hard to press. Both
-         * are decisions about the field rather than the field, and there is
-         * no such thing as a square edge on a decision.
-         */
-        const scratch = new Float32Array(cols * rows);
-
-        const box = (a: Float32Array, r: number) => {
-          const clampX = (x: number) => Math.min(Math.max(x, 0), cols - 1);
-          const clampY = (y: number) => Math.min(Math.max(y, 0), rows - 1);
-          const n = 2 * r + 1;
-
-          for (let y = 0; y < rows; y++) {
-            const row = y * cols;
-            let acc = 0;
-
-            for (let x = -r; x <= r; x++) acc += a[row + clampX(x)];
-
-            for (let x = 0; x < cols; x++) {
-              scratch[row + x] = acc / n;
-              acc += a[row + clampX(x + r + 1)] - a[row + clampX(x - r)];
-            }
-          }
-
-          for (let x = 0; x < cols; x++) {
-            let acc = 0;
-
-            for (let y = -r; y <= r; y++) acc += scratch[clampY(y) * cols + x];
-
-            for (let y = 0; y < rows; y++) {
-              a[y * cols + x] = acc / n;
-              acc += scratch[clampY(y + r + 1) * cols + x] - scratch[clampY(y - r) * cols + x];
-            }
-          }
-        };
-
-        /**
-         * How far one charge speaks for, and it is bounded on both sides.
-         *
-         * Too small and the charges never meet: the region comes apart into
-         * one little ring per charge, which is the picture of points that
-         * keeps coming back. Too large and a band bleeds into the next band
-         * round, the alternation averages itself away, and there is one grey
-         * body instead of two winding ones.
-         *
-         * The right size is set by the winding itself, and the winding here
-         * is the one `every: undefined` above settles on: a shell leaves
-         * every tick, the wave advances a cell a tick, and the source comes
-         * round an eighth of a turn in between. So a whole turn is CYCLE
-         * cells out from the source and a band of one sign is half of that —
-         * four cells thick, with four cells of the other sign beyond it.
-         */
-        const step = cam.scale * LATTICE_STEP;          // pixels per cell
-        const band = (CYCLE / 2) * step / CELL;         // samples across one band
-
-        /**
-         * And it reaches much further across a charge's path than along it.
-         *
-         * A round reach has to be a compromise between two things that want
-         * opposite sizes. The holes to be closed are the gaps between charges
-         * of one shell, which open up as the shell grows and are the reason
-         * the arcs come out as strings of islands; closing them wants a
-         * generous reach. What must not be closed is the gap between one
-         * shell and the next, which is where the alternation lives, since a
-         * shell four along is the opposite charge; keeping that wants a mean
-         * one. Round, there is no size that does both, and the picture is
-         * either beads or porridge.
-         *
-         * But the two gaps are not in the same direction, and the direction
-         * that tells them apart is the one the charges are travelling in. A
-         * shell is spread out ACROSS its own motion — every part of it left
-         * together and is the same age and the same charge — and the next
-         * shell is one cell AHEAD. So the reach is an ellipse laid across the
-         * path: long the way the shell runs, short the way it is going.
-         * Nothing is invented by this. It is a statement about which charges
-         * are neighbours, and a charge's neighbours are the ones off its
-         * shoulders rather than the one in front.
-         *
-         * The short axis is the delicate one, and it is why merging with any
-         * generosity in the direction of travel was wrong. Four shells make
-         * one band, so a reach of much over a cell forward joins a charge to
-         * shells that are still its own sign, which is wanted; a reach of
-         * four joins it to the opposite one, which averages the alternation
-         * away and is how a set of arcs turns into a disc.
-         *
-         * A cell, then, and not a cell and a half. Every fraction past the
-         * spacing between two shells is spent averaging a band against the
-         * one beyond it, and that cost is paid over the whole width of the
-         * seam rather than at the seam: a reach of a cell and a half puts
-         * three cells of a four-cell band within sight of the other charge
-         * and there is very little of it left reading as wholly one thing. At
-         * exactly the spacing the shells of a band still touch — which is all
-         * that is needed for it to be one body, the closing along each shell
-         * being what actually mends it — and a charge's reach stops dead
-         * before anything of the other sign.
-         */
-        const across = Math.max(band / 4.5, 1.2);           // the way it is going
-        const along = Math.max(band * 1.15, across * 3);    // the way it is spread
-
-        // Where each source is on the screen, which is what "out from it"
-        // means. Anything with no source of its own is measured from the
-        // middle of the picture.
-        const origin = new Map<number, { x: number, y: number }>();
-
-        for (const nd of graph.nodes) {
-          for (const ray of nd) {
-            if (!ray.magnet || ray.source === undefined) continue;
-
-            const p = pts.get(nd);
-            if (p && !p.clipped) origin.set(ray.source, { x: p.x, y: p.y });
-          }
-        }
-
-        // How far out each part of the picture is from the nearest source,
-        // and which way that is — the fallback frame, for the places no
-        // charge has an opinion about.
-        const outX = new Float32Array(cols * rows);
-        const outY = new Float32Array(cols * rows);
-        const rad = new Float32Array(cols * rows);
-
-        {
-          const from = origin.size
-            ? [...origin.values()].map(p => ({ x: p.x / CELL, y: p.y / CELL }))
-            : [{ x: cols / 2, y: rows / 2 }];
-
-          for (let y = 0; y < rows; y++) {
-            for (let x = 0; x < cols; x++) {
-              let dx = 1, dy = 0, len = Infinity;
-
-              for (const s of from) {
-                const ex = x - s.x, ey = y - s.y;
-                const d = Math.hypot(ex, ey);
-
-                if (d < len) { len = d; dx = ex; dy = ey; }
-              }
-
-              const i = y * cols + x;
-
-              rad[i] = len;
-
-              if (len > 1e-6) { outX[i] = dx / len; outY[i] = dy / len; }
-              else { outX[i] = 1; outY[i] = 0; }
-            }
-          }
-        }
-
-        /**
-         * Which way the field runs, taken from the charges rather than
-         * supposed of them.
-         *
-         * Everything here that closes a gap or opens one needs to know which
-         * way the thing it is working on lies — the kernel, so it can be an
-         * ellipse; the smoothing and the bridging, so they run along a body
-         * and not across one; the sharpening, so it cuts between two and not
-         * through the middle of either.
-         *
-         * And the answer is not a shape to be assumed. Supposing the bodies
-         * are rings and merging round the source draws rings; supposing they
-         * are spirals of a particular pitch and merging along that draws
-         * those. Both are the picture telling you what it was told. Worse,
-         * merging the way the charges are GOING joins each one to the one in
-         * front of it, which is the one that left a tick earlier — so a band
-         * gets knitted together from the inside out, across the very
-         * direction its polarity alternates in, and the alternation is what
-         * gets averaged away.
-         *
-         * What a charge is actually beside is what left with it. A shell is
-         * one emission, every part of it the same age and the same charge,
-         * and it is spread out ACROSS the way it travels — so the neighbours
-         * of a charge are the ones off its shoulders, and the thing in front
-         * of it is a different shell of possibly the other sign. Merge
-         * orthogonal to the motion and each shell closes into the arc it is;
-         * a source that only flips gives rings, a source that turns gives
-         * arcs each rotated from the last, which is a spiral. Neither is
-         * imposed. Both come out of the same rule, which is a statement about
-         * which charges are neighbours and says nothing about shape.
-         *
-         * Kept as a doubled angle so it can be averaged at all. These are
-         * lines rather than arrows — a charge going one way and a charge
-         * coming back lie along the same line and belong together — and
-         * averaging arrows would have the two cancel to nothing exactly where
-         * two shells meet. Doubling the angle makes opposites identical,
-         * which is what they are here, and halving it back afterwards
-         * recovers the line.
-         */
-        const spinA = new Float32Array(cols * rows);   // cos of the doubled angle
-        const spinB = new Float32Array(cols * rows);   // sin of it
-        const spinW = new Float32Array(cols * rows);
-
-        const runX = new Float32Array(cols * rows);
-        const runY = new Float32Array(cols * rows);
-
-        for (const nd of graph.nodes) {
-          if (!graph.inFocus(nd)) continue;
-
-          for (const ray of nd) {
-            if (ray.magnet || !ray.moving) continue;
-            if (ray.moving.polarity === Polarity.Neutral) continue;
-
-            const p = pts.get(nd);
-            if (!p || p.clipped) continue;
-
-            const cx = p.x / CELL, cy = p.y / CELL;
-            const sign = ray.moving.polarity === Polarity.Positive ? 1 : -1;
-
-            const wp = layout.get(nd);
-            const out = wp
-              ? Math.min(Math.hypot(...wp) / ((graph.focus ?? 12) * LATTICE_STEP), 1)
-              : 0;
-
-            // How far out it is, which is only used to keep the reach inside
-            // the arc there is to reach along.
-            const from = origin.get(ray.source ?? 0);
-            let ox = from ? cx - from.x / CELL : 0;
-            let oy = from ? cy - from.y / CELL : 0;
-            const len = Math.hypot(ox, oy);
-
-            if (len > 1e-6) { ox /= len; oy /= len; } else { ox = 1; oy = 0; }
-
-            /**
-             * And which way it is going, on the screen, which is the one
-             * thing the ellipse is oriented by.
-             *
-             * `heading` first: that is the direction in the large, and a step
-             * is only this tick's piece of it. Where there is no heading —
-             * nothing wanders in these examples, so most of the time — the
-             * step and the direction are the same thing and the point ahead
-             * says it exactly.
-             *
-             * Projected rather than taken from the lattice, because what is
-             * being drawn is the screen. A charge travelling straight at the
-             * camera has no direction in the picture at all, and its shell is
-             * a face-on ring around it there; the projection says so by
-             * coming out at nothing, and the fallback is the frame from the
-             * source, which is that ring.
-             */
-            let mx = 0, my = 0;
-
-            if (wp && ray.heading) {
-              const t = screenOf(wp.map((v, i) => v + (ray.heading![i] || 0) * LATTICE_STEP));
-
-              mx = t.x - p.x; my = t.y - p.y;
-            }
-
-            if (mx === 0 && my === 0 && ray.moving.target) {
-              const q = pts.get(ray.moving.target.at.node);
-
-              if (q && !q.clipped) { mx = q.x - p.x; my = q.y - p.y; }
-            }
-
-            const ml = Math.hypot(mx, my);
-
-            // Across the way it is going: the shoulders of its own shell.
-            let rx: number, ry: number;
-
-            if (ml > 1e-3) { rx = -my / ml; ry = mx / ml; }
-            else { rx = -oy; ry = ox; }
-
-            // Which is then remembered, so that the places between the
-            // charges can be given the same answer as the charges around
-            // them. See the doubled angle above.
-            {
-              const i0 = Math.min(Math.max(Math.round(cy), 0), rows - 1) * cols
-                + Math.min(Math.max(Math.round(cx), 0), cols - 1);
-
-              spinA[i0] += rx * rx - ry * ry;
-              spinB[i0] += 2 * rx * ry;
-              spinW[i0] += 1;
-            }
-
-            /**
-             * And it reaches no further along than there is arc to reach
-             * along.
-             *
-             * A band covers half a turn, so at radius r it is about πr long,
-             * and at one or two cells out that is shorter than the reach
-             * itself. Sweeping the full ellipse there does not join a shell
-             * to itself, it joins it right round to the next one — which is
-             * the opposite charge, and the two average away into the grey
-             * disc that the middle of these pictures kept coming out as.
-             *
-             * So the long axis is held to the arc it is supposed to be lying
-             * on. Far out that is the reach as given; close in it shrinks
-             * with the radius until the ellipse is barely longer than it is
-             * wide, which is right — near the source there are no gaps to
-             * close, the charges are on top of each other.
-             */
-            const reach = Math.max(Math.min(along, len * 0.8), across);
-            const span = Math.ceil(reach);
-
-            for (let y = Math.max(Math.floor(cy - span), 0); y <= Math.min(Math.ceil(cy + span), rows - 1); y++) {
-              for (let x = Math.max(Math.floor(cx - span), 0); x <= Math.min(Math.ceil(cx + span), cols - 1); x++) {
-                const dx = x - cx, dy = y - cy;
-
-                // Split into how far along the arm and how far off it, and
-                // measure each against its own reach.
-                const round2 = dx * rx + dy * ry;
-                const out2 = dx * -ry + dy * rx;
-
-                const d = Math.hypot(out2 / across, round2 / reach);
-                if (d >= 1) continue;
-
-                // Smooth to nothing at the edge of its reach, so no charge
-                // leaves a rim of its own in the field.
-                const k = (1 - d * d) ** 2;
-                const i = y * cols + x;
-
-                sum[i] += sign * k;
-                weight[i] += k;
-                if (1 - out > near[i]) near[i] = 1 - out;
-              }
-            }
-
-            /**
-             * Two charges moving into each other are never one thing.
-             *
-             * They are about to meet — next tick they cancel, or they turn
-             * each other round — and the whole meaning of that is that they
-             * came from different places and are arriving at each other. A
-             * body cannot be approaching itself. Yet nothing said so: the
-             * field is built from where charges are and not from where they
-             * are going, so two shells closing on one another read as one
-             * thick region of the same charge, with the interface that is
-             * about to be an event drawn straight through its middle as if it
-             * were the inside of something.
-             *
-             * So the place between them is cut. Where a charge is moving into
-             * a point that holds a charge coming back at it, the field is
-             * held to nothing along the line between the two — and a boundary
-             * is what gets drawn there, which is what puts them in different
-             * islands and keeps them there right up until the tick where they
-             * resolve.
-             */
-            const ahead = ray.moving.target?.at.node;
-
-            if (ahead && ahead !== nd
-              && ahead.some(x => x.moving?.target?.at.node === nd)) {
-              const q = pts.get(ahead);
-
-              if (q && !q.clipped) {
-                const mx = (p.x + q.x) / 2 / CELL, my = (p.y + q.y) / 2 / CELL;
-
-                /**
-                 * And what is put there is a seam, not a bite.
-                 *
-                 * The thing between two charges arriving at each other is an
-                 * interface — it has the two of them on either side of it and
-                 * it extends sideways, the way the two fronts do. Marked with
-                 * a disc instead, it takes a round hole out of whichever band
-                 * the pair happen to be sitting in, and a band with a dozen
-                 * such pairs along it is a band with a dozen holes punched
-                 * through it: the arm falls apart into the pieces between
-                 * them, and the pieces read as islands.
-                 *
-                 * Thin the way they are approaching and wide the way they are
-                 * not, it does the one thing it was for — the two of them end
-                 * up on opposite sides of a line — and it does not cost the
-                 * arm its continuity to do it.
-                 */
-                let jx = q.x - p.x, jy = q.y - p.y;
-                const jl = Math.hypot(jx, jy) || 1;
-
-                jx /= jl; jy /= jl;
-
-                const thin = Math.max(across / 4, 0.8);
-                const broad = Math.max(across, 2);
-                const bite = Math.ceil(broad);
-
-                for (let y = Math.max(Math.floor(my - bite), 0); y <= Math.min(Math.ceil(my + bite), rows - 1); y++) {
-                  for (let x = Math.max(Math.floor(mx - bite), 0); x <= Math.min(Math.ceil(mx + bite), cols - 1); x++) {
-                    const ex = x - mx, ey = y - my;
-
-                    const d = Math.hypot(
-                      (ex * jx + ey * jy) / thin,
-                      (ex * -jy + ey * jx) / broad,
-                    );
-                    if (d >= 1) continue;
-
-                    const k = (1 - d * d) ** 2;
-                    const i = y * cols + x;
-
-                    if (k > cut[i]) cut[i] = k;
-                  }
-                }
-              }
-            }
-
-            break; // one sample per point, however many rays are on it
-          }
-        }
-
-        /**
-         * And spread out over the places between them, so that the frame is
-         * something the whole picture has rather than something only the
-         * charges have.
-         *
-         * Averaged over about the width one charge speaks for, which is the
-         * distance at which two charges are meant to be part of the same
-         * thing anyway. Where a shell runs, its own members all say the same
-         * and the average is that; where two shells cross, they disagree and
-         * it comes out short, which is exactly a place with no one direction
-         * to it and is treated as one.
-         */
-        {
-          // Wide enough to have an answer in the gaps, which is where it is
-          // wanted: a place with no charge in it is the very place that needs
-          // to be told which way the thing running through it lies.
-          const smear = Math.max(Math.round(along * 0.6), 2);
-
-          box(spinA, smear);
-          box(spinB, smear);
-          box(spinW, smear);
-
-          for (let i = 0; i < runX.length; i++) {
-            const mag = Math.hypot(spinA[i], spinB[i]);
-
-            // Nothing said anything here, or what was said cancelled out.
-            // Both are the same answer: fall back to the shape of a shell
-            // around the nearest source, which is what a place with no
-            // direction of its own is nearest to being part of.
-            if (spinW[i] < 1e-4 || mag < spinW[i] * 0.15) {
-              runX[i] = -outY[i]; runY[i] = outX[i];
-              continue;
-            }
-
-            const a = 0.5 * Math.atan2(spinB[i], spinA[i]);
-
-            runX[i] = Math.cos(a); runY[i] = Math.sin(a);
-          }
-        }
-
-        /**
-         * How positive or negative each part of the picture is: +1 well
-         * inside an amber band, −1 well inside a cyan one, and nothing where
-         * no charge reaches or where the two meet.
-         *
-         * Divided by a little more than the weight actually there, which is
-         * the difference between how positive a place is and how sure of it
-         * the picture can be. Dividing by the weight exactly says a place
-         * with one charge in it is as wholly positive as a place with twenty
-         * — so a charge that has come adrift from everything, out ahead of
-         * its shell or left behind by it, reads at full strength and is
-         * traced as a little closed body of its own. Every one of those is an
-         * island, and they are the ones with nothing in them.
-         *
-         * The extra in the divisor is worth about a charge's own weight. One
-         * charge on its own then reads at a third of what a band reads, which
-         * is under the level anything is traced at, and it goes back to being
-         * what it is: a faint mark in the field rather than a body. Nothing
-         * is thrown away — twenty of them together still read as twenty, and
-         * a thin arm far out is still an arm. It is a preference for what is
-         * supported over what is isolated, applied to the reading rather than
-         * to the drawing.
-         */
-        const trust = 0.9;
-
-        const target = new Float32Array(cols * rows);
-        const known = new Uint8Array(cols * rows);
-
-        for (let i = 0; i < target.length; i++) {
-          if (weight[i] <= 0) continue;
-
-          target[i] = Math.max(Math.min(sum[i] / (weight[i] + trust), 1), -1);
-          known[i] = 1;
-        }
-
-        /**
-         * Places no charge reached take the value their surroundings imply.
-         *
-         * A charge is a sample of the field, not the extent of it. Where two
-         * of them happen to fall a little far apart the reading in between is
-         * not "no field" — it is a place nothing was measured, and treating
-         * unmeasured as zero puts a boundary through the middle of a band
-         * wherever the sampling thinned. That is what the holes in the arms
-         * are: not gaps in the field, gaps in the record of it.
-         *
-         * So a value is grown into them from their edges, a ring at a time,
-         * and each takes the average of whatever is already known beside it.
-         * Somewhere with amber on all sides fills in amber, and the band
-         * closes; somewhere between amber and cyan fills in with what is
-         * between them, which is nothing, and the boundary stays exactly
-         * where it was. Only a few rings of it, so a genuinely empty part of
-         * the world stays empty rather than being papered over.
-         */
-        /**
-         * And pressed a good deal further than a few rings, at the price of
-         * getting stricter about what counts as a gap.
-         *
-         * The two things it must not do are grow a band outwards into the
-         * empty space past the wavefront, and grow one band into the next.
-         * The second is already handled — disagreeing neighbours are refused
-         * below — and the first is what the small number of passes was really
-         * buying: an edge grows one ring per pass just as a hole fills one
-         * ring per pass, so the only thing keeping the outside of the picture
-         * from creeping outwards was stopping early, which also stopped every
-         * hole halfway through being mended.
-         *
-         * Told apart instead of traded off. A place inside a hole has known
-         * neighbours nearly all round it; a place just outside the edge of
-         * something has them on one side only. So the first few passes take
-         * anything with two — that is a crack one sample wide, and closing
-         * those is most of what closing is — and every pass after that wants
-         * three of four, which a hole has and an edge never does. Then the
-         * filling can run until it has nothing left to fill.
-         */
-        for (let pass = 0; pass < 16; pass++) {
-          const grown: [number, number][] = [];
-          const need = pass < 3 ? 2 : 3;
-
-          for (let y = 1; y + 1 < rows; y++) {
-            for (let x = 1; x + 1 < cols; x++) {
-              const i = y * cols + x;
-              if (known[i]) continue;
-
-              let total = 0, n = 0, warm = 0, cold = 0;
-
-              for (const j of [i - 1, i + 1, i - cols, i + cols]) {
-                if (!known[j]) continue;
-
-                total += target[j];
-                n++;
-
-                if (target[j] > 0.05) warm++;
-                else if (target[j] < -0.05) cold++;
-              }
-
-              /**
-               * Filled only where its surroundings agree.
-               *
-               * Averaging whatever is beside it is right in the middle of a
-               * band and wrong on the edge of one. A place with amber on one
-               * side and cyan on the other is not a hole in either — it is
-               * the seam between them, and filling it with the average is
-               * filling it with something halfway, which is a step towards
-               * one band and the next one out becoming a single band. Enough
-               * of those and the layers close up into each other and the
-               * winding goes.
-               *
-               * So a gap is only closed from the inside. Where the known
-               * neighbours are all of one charge it fills with that charge
-               * and the band mends; where they disagree it is left as it is,
-               * because what is there is a boundary and a boundary is
-               * supposed to be empty.
-               */
-              if (warm && cold) continue;
-
-              if (n >= need) grown.push([i, total / n]);
-            }
-          }
-
-          if (!grown.length) break;
-
-          // All of them at once, so a ring fills from the ring outside it
-          // rather than from itself half-filled.
-          for (const [i, v] of grown) { target[i] = v; known[i] = 1; }
-        }
-
-        /**
-         * Eased from the last frame rather than replaced.
-         *
-         * The world only changes on a tick, and a tick is a whole cell — a
-         * charge is here, and then it is a cell further out, with nothing in
-         * between because there is nothing in between to be in. Drawn
-         * directly, the picture stands still for a fifth of a second and then
-         * jumps, which is honest about the model and awful to watch: the eye
-         * reads the jump instead of the movement.
-         *
-         * The FIELD, though, is a continuous quantity — how positive a place
-         * is — and there is nothing wrong with a place becoming more positive
-         * gradually. So the drawn field walks towards the true one a fraction
-         * each frame instead of arriving at it at once. A band that moves one
-         * cell out fades out of where it was and into where it has got to,
-         * and what you see is the wave travelling rather than a slideshow of
-         * where it has been.
-         *
-         * It is a property of the drawing and not of the model. Nothing here
-         * is fed back into the dynamics, and a still of any frame is the same
-         * picture the unsmoothed version would have reached a moment later.
-         */
-        if (!eased || eased.length !== target.length) eased = target.slice();
-        else for (let i = 0; i < eased.length; i++)
-          eased[i] += (target[i] - eased[i]) * 0.2;
-
-        /**
-         * And smoothed along itself before anything is traced from it.
-         *
-         * The field is built by dropping a kernel at every charge, so it
-         * carries the charges in it: little bumps where one landed, little
-         * dips between two, all at the scale of a single lattice cell. A line
-         * traced through that follows every one of them, and the arm comes
-         * out scalloped — which is not the shape of the arm, it is the shape
-         * of the fact that it was measured at points.
-         *
-         * A few passes of each sample settling towards the ones on either
-         * side of it takes that out. Which two are "on either side" is the
-         * whole question, and it is the same answer as everywhere else here:
-         * the ones further along the band, not the ones further out from the
-         * source. Settling towards the neighbours in every direction equally
-         * pulls each band towards the two of the other sign it lies between,
-         * so the alternation is worn down at exactly the rate the gaps in it
-         * are closed, and there is no number of passes that gets one without
-         * the other. Settling along the band only, the arm knits together
-         * down its own length and nothing at all happens across it.
-         *
-         * That is the preference, in one line: a place takes after what
-         * continues through it. A neck between two lumps of one arm has arm
-         * on both sides along the way it runs and fills in; a speck with
-         * nothing either side of it has nothing to take after and fades.
-         * Neither is decided in advance — it is read off which way the thing
-         * is going where it is.
-         */
-        // On a copy, never on the eased field itself: that one is carried
-        // from frame to frame, and smoothing something that is then smoothed
-        // again next frame is not a smoothing, it is a slow erasure — after a
-        // few seconds there would be nothing left of the field at all.
-        const f = eased.slice();
-
-        // The field between its samples, so a step of a fraction of one is a
-        // step rather than a rounding — the directions below are not the
-        // grid's and almost never land on it.
-        const sample = (a: Float32Array, x: number, y: number) => {
-          const px = Math.min(Math.max(x, 0), cols - 1);
-          const py = Math.min(Math.max(y, 0), rows - 1);
-
-          const x0 = Math.floor(px), y0 = Math.floor(py);
-          const x1 = Math.min(x0 + 1, cols - 1), y1 = Math.min(y0 + 1, rows - 1);
-          const fx = px - x0, fy = py - y0;
-
-          return (a[y0 * cols + x0] * (1 - fx) + a[y0 * cols + x1] * fx) * (1 - fy)
-            + (a[y1 * cols + x0] * (1 - fx) + a[y1 * cols + x1] * fx) * fy;
-        };
-
-        // One pass of it, in whichever of the two directions is asked for.
-        const drift = (a: Float32Array, passes: number, reach: number, round: boolean) => {
-          const next = new Float32Array(a.length);
-
-          for (let pass = 0; pass < passes; pass++) {
-            for (let y = 0; y < rows; y++) {
-              for (let x = 0; x < cols; x++) {
-                const i = y * cols + x;
-
-                // Held to the arm there is, close in, for the same reason the
-                // kernel's long axis is.
-                const r = round ? Math.min(reach, rad[i] * 0.5) : reach;
-
-                const dx = (round ? runX[i] : -runY[i]) * r;
-                const dy = (round ? runY[i] : runX[i]) * r;
-
-                next[i] = (
-                  a[i] * 2
-                  + sample(a, x + dx, y + dy)
-                  + sample(a, x - dx, y - dy)
-                ) / 4;
-              }
-            }
-
-            a.set(next);
-          }
-
-          return a;
-        };
-
-        drift(f, 10, 1.8, true);
-
-        /**
-         * Where the alternation actually is, before anything is done that
-         * could cost some of it.
-         *
-         * Everything from here on is one of two opposite pressures. Closing a
-         * gap wants a place to take after what is around it; keeping the
-         * winding wants a place to stay unlike what is around it. Applied at
-         * one strength everywhere, they are the beads-or-porridge choice
-         * again in a different guise, and whichever is turned up wrecks the
-         * half of the picture the other was for.
-         *
-         * But which of the two a place needs is a thing that can be looked
-         * at. Somewhere in the body of a band has one charge all round it out
-         * to the distance the bands repeat over; somewhere between two has
-         * both, in comparable amounts. So: how much of each is nearby, and
-         * how near they come to being equal.
-         *
-         * Measured on the field rather than assumed from the geometry, which
-         * matters where the geometry is not the whole story — near a source,
-         * where the arms have not separated yet, or out where two magnets'
-         * fields have run into each other and the alternation is nothing so
-         * tidy as one spiral's. Where there IS alternation it is protected,
-         * wherever it came from and whichever way round it lies. Where there
-         * is none, there is nothing to protect and the gaps can be closed as
-         * hard as it takes.
-         */
-        const alt = new Float32Array(f.length);
-
-        {
-          const warm = new Float32Array(f.length);
-          const cold = new Float32Array(f.length);
-
-          for (let i = 0; i < f.length; i++) {
-            warm[i] = Math.max(f[i], 0);
-            cold[i] = Math.max(-f[i], 0);
-          }
-
-          // Out to most of the way to the next band, which is the scale the
-          // question is being asked at. A cell either side finds alternation
-          // only where the two are already touching; two thirds of a band
-          // finds it while there is still something between them, which is
-          // while there is still something to keep.
-          const look = Math.max(Math.round(band / 2.2), 2);
-
-          box(warm, look);
-          box(cold, look);
-
-          for (let i = 0; i < f.length; i++) {
-            const lo = Math.min(warm[i], cold[i]);
-            const hi = Math.max(warm[i], cold[i]);
-
-            // Nothing at all nearby is not alternation; it is emptiness, and
-            // emptiness gets closed like anything else.
-            alt[i] = hi > 1e-3 ? Math.min((2 * lo) / (lo + hi) * 2.8, 1) : 0;
-          }
-        }
-
-        /**
-         * And then the gaps are bridged outright, rather than diffused shut.
-         *
-         * Smoothing along an arm closes a gap by moving what is on either
-         * side of it into the middle, which means the middle ends up weaker
-         * than either side — and a gap wide enough to be worth closing ends
-         * up filled with something under the level anything is traced at. The
-         * hole is smaller and blurrier and still a hole. Pushing the
-         * smoothing harder to get through it takes the arm's own strength
-         * down with it, because a diffusion cannot tell which of its
-         * neighbours it is supposed to be taking after.
-         *
-         * A gap is not an average, though. It is a place where something
-         * runs THROUGH — the arm arrives at one side of it and leaves from
-         * the other — and that is a thing to test for rather than to hope
-         * comes out of an average. So each place looks out along the band,
-         * both ways at once, for a distance the same charge is found in both
-         * directions, and takes the weaker of the two.
-         *
-         * Both ways at once is the whole of what makes it safe. A speck with
-         * nothing either side of it finds nothing that agrees and is left as
-         * it is; the far end of an arm finds arm behind it and empty space
-         * ahead and is not extended past where it ends; a seam between two
-         * bands has opposite signs across it and never had them along it, so
-         * it is not something this can reach through. Only a place with the
-         * same thing on both sides of it is filled, and a place with the same
-         * thing on both sides of it is the inside of an arm.
-         *
-         * Taking the weaker end rather than the stronger keeps it honest: a
-         * bridge is only ever as much as the thinner of the two things it
-         * joins, so a wisp joined to a bright arm does not come out bright.
-         *
-         * And the looking stops at the first thing of the other charge it
-         * meets, rather than running the whole way and asking about the far
-         * end. That is the one way this could do damage — a stripe of the
-         * other charge lying across the arm, with more arm beyond it, is two
-         * things with something between them and not one thing with a gap in
-         * it, and reaching over the stripe would paint it out. Stopped at it,
-         * the two sides come back disagreeing and nothing happens. So the
-         * alternation is not weighed against the closing here; it is simply
-         * in the way of it, which is what alternation ought to be.
-         */
-        /**
-         * And it is a preference for that direction, not a rule about it.
-         *
-         * A shell is not a perfect arc. It is a couple of dozen directions
-         * off a lattice, fanning as they go and passing through space that
-         * other charges have been eating, so the line through its members
-         * wanders by some tens of degrees from the one thing perpendicular to
-         * any one of them. Looking along a single exact direction, half the
-         * gaps in it are at an angle to what is being looked down and are
-         * missed — while looking down a wide fan of directions at once finds
-         * the next shell as readily as its own, which is the merge along the
-         * path that must not happen.
-         *
-         * So each pass looks slightly differently: straight across the path,
-         * then a little to one side of that, then a little to the other. A
-         * gap that lies square on is closed by the first and closed again by
-         * the other two; one on a slant is closed by whichever pass is
-         * pointing at it; nothing anywhere gets a look down the path itself,
-         * which is off the end of the fan in both directions. Preference by
-         * how much of the ink each direction gets, which is what a preference
-         * is, rather than by which directions exist.
-         */
-        const bridge = (a: Float32Array, taps: number, reach: number, tilt: number) => {
-          const next = a.slice();
-
-          // What counts as something rather than as the tail of something.
-          // Under the level anything is traced at, so a gap in an arm — which
-          // is by definition below that level — is still a gap to be crossed
-          // and not an obstacle to stop at.
-          const lip = 0.07;
-
-          // The strongest thing one way along the band, or whatever stopped
-          // us getting to it, and how far off that was. Answered into these
-          // rather than returned: it is called twice per sample of the
-          // picture and a pair of objects a sample is a great many objects.
-          let found = 0, at = 1;
-
-          const seek = (x: number, y: number, dx: number, dy: number) => {
-            found = 0; at = 1;
-
-            for (let t = 1; t <= taps; t++) {
-              const v = sample(a, x + dx * t, y + dy * t);
-
-              if (found !== 0 && v * found < 0 && Math.abs(v) > lip) break;
-              if (Math.abs(v) > Math.abs(found)) { found = v; at = t; }
-            }
-          };
-
-          for (let y = 0; y < rows; y++) {
-            for (let x = 0; x < cols; x++) {
-              const i = y * cols + x;
-
-              /**
-               * Softened, though not stopped, where the alternation is thick.
-               *
-               * The frame is least trustworthy exactly where it matters most
-               * — near a source, where the arms have not come apart yet, and
-               * out where two magnets' fields have run into each other — and
-               * there what lies "along" may well be the next band round. The
-               * test above catches that whenever the other charge is actually
-               * between the two, which is most of the time; this is for the
-               * rest of it. Not a veto, because a thin arm has the other
-               * charge close by on both sides of it by construction, and a
-               * thin arm is exactly the thing with the worst gaps in it.
-               */
-              const room = 1 - alt[i] * 0.9;
-
-              const r = Math.min(reach, Math.max(rad[i] * 0.5, 0.5));
-
-              const c = Math.cos(tilt), sn = Math.sin(tilt);
-              const dx = (runX[i] * c - runY[i] * sn) * r;
-              const dy = (runX[i] * sn + runY[i] * c) * r;
-
-              seek(x, y, dx, dy);
-              const fv = found, fat = at;
-
-              seek(x, y, -dx, -dy);
-              const bv = found, bat = at;
-
-              // Nothing runs through here.
-              if (fv * bv <= 0) continue;
-
-              const v = Math.abs(fv) < Math.abs(bv) ? fv : bv;
-
-              // Already at least this much of it, or of the other charge and
-              // meaning it — either way, not a gap.
-              if (Math.abs(v) <= Math.abs(a[i])) continue;
-              if (a[i] * v < 0 && Math.abs(a[i]) > lip) continue;
-
-              // And reaching costs something, so a gap is closed by what is
-              // just past it rather than by whatever is furthest away.
-              const far = Math.max(fat, bat) / taps;
-
-              next[i] = a[i] + (v * (1 - 0.22 * far) - a[i]) * room;
-            }
-          }
-
-          return next;
-        };
-
-        // Twice, which is not the same as once with twice the reach: what the
-        // first pass closes is arm by the time the second runs, so a run of
-        // gaps with slivers between them mends from both ends inwards rather
-        // than each gap having to be spanned in one go from whatever is left
-        // either side of it.
-        f.set(bridge(f, 9, 2.6, 0));
-        f.set(bridge(f, 9, 2.6, 0.42));
-        f.set(bridge(f, 9, 2.6, -0.42));
-
-        /**
-         * And the valley between two bands is deepened until it separates
-         * them.
-         *
-         * Where an arm of one charge passes close to another arm of the same
-         * charge, what lies between them is a thin band of the other — and
-         * thin means weak, because the two sides of it are pulling the
-         * average back towards themselves. If it is weak enough that the
-         * field never quite crosses the level being traced, the two arms are
-         * drawn as one: an island that is really two islands with a seam in
-         * it that did not print.
-         *
-         * Comparing the field against a blurred copy of itself says exactly
-         * where that is happening. A place in the middle of a wide band looks
-         * like its own surroundings and the two agree; a place in a narrow
-         * gap is much less positive than its surroundings, because its
-         * surroundings are the arms on either side of it. Taking the
-         * difference and pushing it back in leaves the middles of the bands
-         * where they were and drives the gaps between them down through zero
-         * — which is where a boundary is, so a boundary is what gets drawn,
-         * and the two arms come apart into the two islands they are.
-         *
-         * Compared ACROSS itself, though, and not in the round. The gap that
-         * wants deepening is the one between one turn of the spiral and the
-         * next, and that is out from the source by construction. A round
-         * comparison finds a second kind of thin place the arm has — the neck
-         * where it happens to be narrow along its own length — and deepens
-         * that one too, which cuts the arm in half. Every island this used to
-         * make was made honestly, by a rule that could not tell the gap it
-         * was for from the arm it was cutting.
-         *
-         * And turned up where there is alternation to keep and down where
-         * there is not.
-         *
-         * Sharpening is a separator, and a separator applied where there is
-         * nothing to separate has only one thing left to do: find whatever is
-         * weakest in a body of one charge and drive it below the level, which
-         * is a hole opened in the middle of something solid. That is the same
-         * ink the bridge above just spent closing gaps, spent undoing it.
-         *
-         * Where the two charges genuinely lie against each other it is the
-         * whole reason there are two shapes in the picture instead of one, so
-         * there it goes harder than it did before. The two are not in
-         * competition once they are asked separately.
-         *
-         * And hardest of all where the change is ALONG the way the charges
-         * are going, which is the other half of the same preference the
-         * bridging is the first half of.
-         *
-         * A shell alternates with the shells in front of it and behind it,
-         * because those are the ones thrown off a moment earlier and a moment
-         * later, when the source was pointing somewhere else or had turned
-         * over. It does not alternate with itself. So a change of charge
-         * encountered by going along the path is the real thing, worth
-         * driving apart until it separates; one encountered by going across
-         * the path — round the shell — is more likely to be two arcs at
-         * different radii happening to pass, or the edge of a gap, and
-         * sharpening it is how a ring gets cut into beads.
-         *
-         * Which of the two it is, is the direction the field changes in,
-         * against the direction the charges here are travelling in. Squared,
-         * so it falls away smoothly rather than at some angle, and floored,
-         * because none of this is exact: a shell is a couple of dozen lattice
-         * directions and a change square across the path is only ever
-         * approximately square across it.
-         */
-        const wide = drift(f.slice(), 12, 2.0, false);
-        const before = f.slice();
-
-        for (let y = 0; y < rows; y++) {
-          for (let x = 0; x < cols; x++) {
-            const i = y * cols + x;
-
-            // Which way the field changes here.
-            const gx = before[y * cols + Math.min(x + 1, cols - 1)]
-              - before[y * cols + Math.max(x - 1, 0)];
-            const gy = before[Math.min(y + 1, rows - 1) * cols + x]
-              - before[Math.max(y - 1, 0) * cols + x];
-
-            const gl = Math.hypot(gx, gy);
-
-            // And which way the charges here are going, which is across the
-            // way their shell runs.
-            const mx = -runY[i], my = runX[i];
-
-            const par = gl > 1e-5 ? ((gx * mx + gy * my) / gl) ** 2 : 0;
-
-            // Between linear and squared: squared alone ignores everything
-            // but the thickest alternation, and half of what wants keeping
-            // here is the thin seam between two arcs that have nearly closed
-            // on each other — which is faint precisely because it is about to
-            // be lost, and is the last moment it can be saved.
-            const a2 = alt[i] * (0.4 + 0.6 * alt[i]);
-
-            const gain = 0.3 + a2 * 5.2 * (0.35 + 0.65 * par);
-
-            f[i] = Math.max(Math.min(f[i] + (f[i] - wide[i]) * gain, 1), -1);
-          }
-        }
-
-        // And nothing survives where two charges are about to meet: the field
-        // there belongs to neither of them, because in a tick it will belong
-        // to whatever they become.
-        for (let i = 0; i < f.length; i++) f[i] *= 1 - cut[i] * 0.9;
-
-        /**
-         * And where the two charges lie against each other, both give ground.
-         *
-         * Everything above works on the field, and the field is traced at a
-         * level — so two bodies that meet cleanly are drawn with their
-         * outlines touching, one line doing for the pair of them, and what
-         * the eye gets is one shape with a crease in it. The alternation is
-         * there in the reading and gone from the picture.
-         *
-         * The last thing done, then, is the cheapest and the most direct:
-         * where the two are near equal, both are pushed back from zero by the
-         * same amount before the outlines are found. Neither loses anything
-         * to the other — the place they part is exactly where it was, since
-         * both give the same ground — and what opens between them is a
-         * channel of the width of what was given. Away from any seam it does
-         * nothing at all, because there is nothing there for both to be near.
-         *
-         * It is a drawing decision and says so: no charge has moved and no
-         * region has changed hands. Two things that touch are drawn as two
-         * things that touch, which is what they are.
-         */
-        for (let i = 0; i < f.length; i++) {
-          const give = alt[i] * 0.2;
-
-          f[i] = f[i] > 0 ? Math.max(f[i] - give, 0) : Math.min(f[i] + give, 0);
-        }
-
-        // And the pulses they were emitted in, kept separately, so the grain
-        // of the thing can be drawn under its shape.
-        const waves = new Map<string, {
-          at: { x: number, y: number }[], out: number, n: number, polarity: Polarity,
-        }>();
-
-        for (const nd of graph.nodes) {
-          if (!graph.inFocus(nd)) continue;
-
-          for (const ray of nd) {
-            if (ray.magnet || !ray.moving || ray.wave === undefined) continue;
-            if (ray.moving.polarity === Polarity.Neutral) continue;
-
-            const p = pts.get(nd);
-            if (!p || p.clipped) continue;
-
-            const key = `${ray.wave}|${ray.moving.polarity}`;
-
-            let wave = waves.get(key);
-            if (!wave) waves.set(key, wave = {
-              at: [], out: 0, n: 0, polarity: ray.moving.polarity,
-            });
-
-            wave.at.push({ x: p.x, y: p.y });
-
-            const wp = layout.get(nd);
-            if (wp) wave.out += Math.hypot(...wp) / ((graph.focus ?? 12) * LATTICE_STEP);
-            wave.n++;
-
-            break;
-          }
-        }
-
-
-        /**
-         * The line along which the field crosses a value.
-         *
-         * Marching squares: each little square of four neighbouring samples
-         * is wholly above the value, wholly below, or cut by it — and which
-         * of its sides the cut passes through follows from which corners are
-         * on which side. Where on a side is solved for rather than snapped to
-         * the grid, so the curve is placed to a fraction of a sample and does
-         * not come out looking like stairs.
-         *
-         * The segments come out unordered, so they are then strung together
-         * end to end into runs. That is what turns a scatter of little lines
-         * into a curve that can be smoothed and filled — and a run that
-         * arrives back where it began is a closed one, which is what the
-         * boundary of a body is.
-         */
-        const trace = (level: number) => {
-          const segs: [number, number, number, number][] = [];
-
-          for (let y = 0; y + 1 < rows; y++) {
-            for (let x = 0; x + 1 < cols; x++) {
-              const v = [
-                f[y * cols + x], f[y * cols + x + 1],
-                f[(y + 1) * cols + x + 1], f[(y + 1) * cols + x],
-              ];
-
-              let mask = 0;
-              for (let c = 0; c < 4; c++) if (v[c] > level) mask |= 1 << c;
-              if (mask === 0 || mask === 15) continue;
-
-              const corner = [[x, y], [x + 1, y], [x + 1, y + 1], [x, y + 1]];
-
-              const cut = (a: number, b: number): [number, number] => {
-                const t = Math.max(Math.min((level - v[a]) / ((v[b] - v[a]) || 1e-9), 1), 0);
-
-                return [
-                  (corner[a][0] + (corner[b][0] - corner[a][0]) * t) * CELL,
-                  (corner[a][1] + (corner[b][1] - corner[a][1]) * t) * CELL,
-                ];
-              };
-
-              const on: [number, number][] = [];
-              for (let c = 0; c < 4; c++) {
-                const d = (c + 1) % 4;
-                if (((mask >> c) & 1) !== ((mask >> d) & 1)) on.push(cut(c, d));
-              }
-
-              if (on.length === 2) segs.push([on[0][0], on[0][1], on[1][0], on[1][1]]);
-              else if (on.length === 4) {
-                segs.push([on[0][0], on[0][1], on[1][0], on[1][1]]);
-                segs.push([on[2][0], on[2][1], on[3][0], on[3][1]]);
-              }
-            }
-          }
-
-          // Strung end to end. Endpoints are shared exactly between
-          // neighbouring squares, so matching them to the nearest tenth of a
-          // pixel is enough to find which segment continues which.
-          const key = (x: number, y: number) => `${Math.round(x * 10)},${Math.round(y * 10)}`;
-          const ends = new Map<string, number[]>();
-
-          segs.forEach(([ax, ay, bx, by], i) => {
-            for (const k of [key(ax, ay), key(bx, by)]) {
-              const list = ends.get(k);
-              if (list) list.push(i); else ends.set(k, [i]);
-            }
-          });
-
-          const used = new Array(segs.length).fill(false);
-          const runs: { x: number, y: number }[][] = [];
-
-          for (let i = 0; i < segs.length; i++) {
-            if (used[i]) continue;
-            used[i] = true;
-
-            const [ax, ay, bx, by] = segs[i];
-            const run = [{ x: ax, y: ay }, { x: bx, y: by }];
-
-            // Follow it forwards, then turn round and follow the other way.
-            for (let pass = 0; pass < 2; pass++) {
-              for (; ;) {
-                const tip = run[run.length - 1];
-                const next = (ends.get(key(tip.x, tip.y)) ?? []).find(j => !used[j]);
-                if (next === undefined) break;
-
-                used[next] = true;
-
-                const [cx2, cy2, dx2, dy2] = segs[next];
-                const near = Math.hypot(cx2 - tip.x, cy2 - tip.y) < Math.hypot(dx2 - tip.x, dy2 - tip.y);
-
-                run.push(near ? { x: dx2, y: dy2 } : { x: cx2, y: cy2 });
-              }
-
-              run.reverse();
-            }
-
-            if (run.length >= 4) runs.push(run);
-          }
-
-          return runs;
-        };
-
-        /**
-         * A run, eased.
-         *
-         * Marching squares places every point on the edge of a sample square,
-         * so a curve through them carries the grid's own fret in it — a
-         * regular little waver at the scale of one sample, which is nothing
-         * about the field and everything about how it was measured. A few
-         * passes of each point drifting towards the middle of its neighbours
-         * takes that out and leaves the shape, which is at the scale of a
-         * band and untouched by it.
-         */
-        const ease = (run: { x: number, y: number }[], closed: boolean) => {
-          let cur = run;
-
-          for (let pass = 0; pass < 10; pass++) {
-            const next = cur.map((p, i) => {
-              if (!closed && (i === 0 || i === cur.length - 1)) return p;
-
-              const a = cur[(i - 1 + cur.length) % cur.length];
-              const b = cur[(i + 1) % cur.length];
-
-              return { x: (a.x + 2 * p.x + b.x) / 4, y: (a.y + 2 * p.y + b.y) / 4 };
-            });
-
-            cur = next;
-          }
-
-          return cur;
-        };
-
-        const prev = ctx.globalCompositeOperation;
-        ctx.globalCompositeOperation = "lighter";
-
-        /**
-         * The waves themselves, underneath and barely there.
-         *
-         * The spirals are what the field IS, and they are drawn above. But a
-         * spiral is made of something — one shell after another, each thrown
-         * off a moment later than the last and a little further round — and
-         * with only the boundaries drawn there is nothing in the picture that
-         * says so. A faint outline per pulse puts that back: the rings are
-         * the grain of the thing, and the winding is the thing.
-         */
-        for (const [id, wave] of waves) {
-          if (wave.at.length < 3) continue;
-
-          const hull = outline(wave.at);
-          if (hull.length < 3) continue;
-
-          const tint = wave.polarity === Polarity.Positive ? "255,122,69" : "61,220,255";
-          const at = (i: number) => hull[(i % hull.length + hull.length) % hull.length];
-
-          ctx.beginPath();
-          ctx.moveTo(hull[0].x, hull[0].y);
-
-          for (let i = 0; i < hull.length; i++) {
-            const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
-
-            ctx.bezierCurveTo(
-              p1.x + (p2.x - p0.x) / 6, p1.y + (p2.y - p0.y) / 6,
-              p2.x - (p3.x - p1.x) / 6, p2.y - (p3.y - p1.y) / 6,
-              p2.x, p2.y,
-            );
-          }
-
-          ctx.closePath();
-          /**
-           * And the older ones stop being drawn rather than piling up.
-           *
-           * A dozen pulses in the air at once is a dozen rings, and the
-           * further out they are the longer their outlines are and the more
-           * of them cross each other — so the outside of the picture ends up
-           * carrying most of the ink for the part of the field that has least
-           * in it. Cut off once they are past halfway out, what is left is
-           * the handful nearest the source, which are the ones that read as
-           * pulses.
-           */
-          const lift = Math.max(1 - wave.out / wave.n, 0);
-          if (lift < 0.45) continue;
-
-          // Faint enough to be texture. There are several of these to every
-          // band and their outlines run alongside it, so at anything like the
-          // band's own weight they stop being the grain of it and become a
-          // second set of edges arguing with the first.
-          ctx.strokeStyle = `rgba(${tint},${lift * lift * 0.18})`;
-          ctx.lineWidth = 0.9;
-          ctx.stroke();
-        }
-
-        // Traced where the field is only weakly one thing rather than
-        // firmly so. A high level draws a line well inside each band and the
-        // arm comes out thin, broken wherever it happens to be weak; a low
-        // one follows the band right out to where it gives way to its
-        // neighbour, which is where the two actually meet.
-        /**
-         * A fill that dims with distance from the source rather than with
-         * which island it belongs to.
-         *
-         * A fill takes one colour for the whole shape it fills, so a band
-         * cannot be shaded along itself the way its edge can. What it can be
-         * given is a colour that is already a gradient — bright at the middle
-         * of the picture and thin at the rim — and then every band is dim
-         * where it is far out and bright where it is close in, including the
-         * ones that are both.
-         */
-        const centre = origin.size
-          ? [...origin.values()].reduce((a, p) => ({
-            x: a.x + p.x / origin.size, y: a.y + p.y / origin.size,
-          }), { x: 0, y: 0 })
-          : { x: w / 2, y: h / 2 };
-
-        const span2 = (graph.focus ?? 12) * LATTICE_STEP * cam.scale;
-
-        const wash = (tint: string) => {
-          const g = ctx.createRadialGradient(
-            centre.x, centre.y, 0, centre.x, centre.y, Math.max(span2, 1),
-          );
-
-          g.addColorStop(0, `rgba(${tint},0.3)`);
-          g.addColorStop(0.45, `rgba(${tint},0.14)`);
-          g.addColorStop(1, `rgba(${tint},0.03)`);
-
-          return g;
-        };
-
-        const strength = (p: { x: number, y: number }) => {
-          const i = Math.min(Math.max(Math.round(p.y / CELL), 0), rows - 1) * cols
-            + Math.min(Math.max(Math.round(p.x / CELL), 0), cols - 1);
-
-          const lift = near[i];
-
-          return 0.08 + lift * lift * 0.92;
-        };
-
-        for (const [level, tint] of [[0.17, "255,122,69"], [-0.17, "61,220,255"]] as [number, string][]) {
-          const runs = trace(level).map(raw => {
-            const closed = Math.hypot(
-              raw[0].x - raw[raw.length - 1].x, raw[0].y - raw[raw.length - 1].y,
-            ) < CELL * 2;
-
-            return { run: ease(raw, closed), closed };
-          });
-
-          const curve = (into: Path2D, run: { x: number, y: number }[], closed: boolean) => {
-            const at = (i: number) => run[closed
-              ? (i % run.length + run.length) % run.length
-              : Math.max(Math.min(i, run.length - 1), 0)];
-
-            into.moveTo(run[0].x, run[0].y);
-
-            for (let i = 0; i < run.length - (closed ? 0 : 1); i++) {
-              const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
-
-              into.bezierCurveTo(
-                p1.x + (p2.x - p0.x) / 6, p1.y + (p2.y - p0.y) / 6,
-                p2.x - (p3.x - p1.x) / 6, p2.y - (p3.y - p1.y) / 6,
-                p2.x, p2.y,
-              );
-            }
-
-            if (closed) into.closePath();
-          };
-
-          /**
-           * All of one charge's boundaries filled as ONE shape, with the
-           * even-odd rule.
-           *
-           * A body of one charge is not simply a blob with an edge. An arm
-           * that winds round has the other charge inside the loop it makes,
-           * and that shows up here as a second closed curve lying within the
-           * first — the hole, not another island. Filled one curve at a time,
-           * the hole gets filled too, and amber is painted straight over the
-           * cyan that lives there: two regions that cannot overlap in the
-           * field, overlapping in the picture, purely as an artefact of
-           * filling their boundaries separately.
-           *
-           * Taken together under the even-odd rule, a place is inside the
-           * body when the boundary wraps it an odd number of times — so the
-           * inside of the arm is filled, the hole within it is not, and what
-           * is drawn is the region rather than everything its edges happen to
-           * enclose.
-           */
-          const body = new Path2D();
-          for (const { run, closed } of runs) if (closed) curve(body, run, closed);
-
-          ctx.fillStyle = wash(tint);
-          ctx.fill(body, "evenodd");
-
-          // A brighter rim on top of it, stroked span by span so that its
-          // strength is the strength of the field where each piece of it
-          // actually lies rather than the average over the whole run.
-          ctx.lineWidth = 1.4;
-          ctx.lineCap = "round";
-
-          for (const { run, closed } of runs) {
-            const at = (i: number) => run[closed
-              ? (i % run.length + run.length) % run.length
-              : Math.max(Math.min(i, run.length - 1), 0)];
-
-            for (let i = 0; i + 1 < run.length + (closed ? 1 : 0); i++) {
-              const a = at(i), b = at(i + 1);
-
-              ctx.strokeStyle = `rgba(${tint},${0.75 * strength(a)})`;
-              ctx.beginPath();
-              ctx.moveTo(a.x, a.y);
-              ctx.lineTo(b.x, b.y);
-              ctx.stroke();
-            }
-          }
-
-          ctx.lineCap = "butt";
-        }
-
-        ctx.globalCompositeOperation = prev;
-      }
-
-      for (const n of graph.nodes) {
-        const p = pts.get(n);
-        if (!p || p.clipped || !onScreen(p)) continue;
-        const depth = Math.min(Math.max(p.depth, 0.4), 1.6);
-
-        // In field mode everything in flight has already been drawn, as the
-        // surface it belongs to. What is left to draw one point at a time is
-        // what isn't a surface: the sources, and (below) the places where
-        // something is about to happen.
-        const magnet = n.some(r => r.magnet);
-        if (field && !magnet) continue;
-
-        // The origin of the waves. Everything charged in this universe came
-        // out of one of these, so it is the one thing that isn't an event but
-        // a cause of them — drawn as its own colour rather than as a polarity,
-        // since it has none.
-        if (magnet) {
-          const r = Math.min(Math.max(cam.scale * 0.2 * depth, 2), 30);
-
-          const halo = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3.2);
-          halo.addColorStop(0, "rgba(255,214,66,0.85)");
-          halo.addColorStop(0.35, "rgba(255,186,40,0.3)");
-          halo.addColorStop(1, "rgba(255,186,40,0)");
-          ctx.fillStyle = halo;
-          ctx.beginPath();
-          ctx.arc(p.x, p.y, r * 3.2, 0, Math.PI * 2);
-          ctx.fill();
-
-          ctx.fillStyle = "#FFE066";
-          ctx.beginPath();
-          ctx.arc(p.x, p.y, Math.max(r * 0.4, 1.6), 0, Math.PI * 2);
-          ctx.fill();
-        }
-
-        // Center seed: a soft glow marking where the universe started. In
-        // field mode the origin is only the point halfway between the two
-        // sources, and glowing there would read as a third one.
-        if (!field && isCenterNode(n)) {
-          const r = Math.min(Math.max(cam.scale * 0.16 * depth, 0.8), 26);
-          const g = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3);
-          g.addColorStop(0, "rgba(255,217,168,0.9)");
-          g.addColorStop(1, "rgba(255,217,168,0)");
-          ctx.fillStyle = g;
-          ctx.beginPath();
-          ctx.arc(p.x, p.y, r * 3, 0, Math.PI * 2);
-          ctx.fill();
-        }
-
-        // Boundaries: EVERY boundary of every ray is drawn as a segment
-        // towards the node on the far side of its connection, coloured by
-        // its own polarity (Positive amber, Negative cyan), reaching 25% of
-        // the way along it. So each lattice connection shows two of them —
-        // one from each end, with a gap in between. The single boundary the
-        // ray is currently `moving` along is drawn at full opacity (and
-        // thicker) on top; the rest are faded down.
-        ctx.lineCap = "round";
-        const stub = (bd: Boundary, moving: boolean) => {
-          // Connected boundaries aim at their neighbour; unconnected ones at
-          // a point one lattice step along their bare `outward` direction, so
-          // "moving away from every connection" is visible rather than blank.
-          const wp = layout.get(n);
-          const wt = bd.target
-            ? layout.get(bd.target.at.node)
-            : (wp && bd.outward ? wp.map((v, i) => v + (bd.outward![i] || 0) * LATTICE_STEP) : undefined);
-          if (!wp || !wt) return;
-
-          const tp = bd.target ? pts.get(bd.target.at.node) : screenOf(wt);
-          if (!tp || tp.clipped) return;
-
-          const dx = tp.x - p.x, dy = tp.y - p.y;
-          const len = Math.hypot(dx, dy);
-          if (len < 1) return;
-          const ux = dx / len, uy = dy / len;
-          const L = len * BOUNDARY_STUB;
-
-          // Positive amber, Negative cyan, and space that hasn't been charged
-          // by anything a plain grey.
-          ctx.strokeStyle = moving
-            ? (bd.polarity === Polarity.Positive ? "#FF7A45"
-              : bd.polarity === Polarity.Negative ? "#3DDCFF"
-                : "#8C93A8")
-            : (bd.polarity === Polarity.Positive ? "rgba(255,122,69,0.3)"
-              : bd.polarity === Polarity.Negative ? "rgba(61,220,255,0.3)"
-                : "rgba(140,147,168,0.25)");
-          ctx.lineWidth = 2 * depth;
-          ctx.beginPath();
-          ctx.moveTo(p.x, p.y);
-          ctx.lineTo(p.x + ux * L, p.y + uy * L);
-          ctx.stroke();
-
-          if (!moving) return;
-
-          // An arrow head sitting ON the node, naming which of its lattice
-          // directions the ray is actually moving in. Its base is centred on
-          // the node's own position and it points off along the connection,
-          // so the direction is read at the point it belongs to rather than
-          // out at the far end of the stub.
-          //
-          // It is the silhouette of a cone, so it foreshortens like one: the
-          // width of the base is fixed, but the length shrinks as the
-          // direction turns towards or away from the camera. That ratio is
-          // measured, not guessed — the drawn length of the connection over
-          // the length it would have had square to the camera. Without it
-          // every head is drawn at full length whatever it points at, which
-          // is what makes them read wrong in 3D.
-          const worldLen = Math.hypot(...wt.map((v, i) => v - wp[i]));
-          const square = worldLen * cam.scale * depth;
-          const foreshortening = square > 0 ? Math.min(len / square, 1) : 1;
-
-          const size = Math.min(Math.max(10, ctx.lineWidth * 5), L * 0.7);
-          const head = size * Math.max(foreshortening, 0.3);
-          const nx = -uy * size * 0.46, ny = ux * size * 0.46;
-
-          ctx.fillStyle = ctx.strokeStyle;
-          ctx.beginPath();
-          ctx.moveTo(p.x + ux * head, p.y + uy * head);
-          ctx.lineTo(p.x + nx, p.y + ny);
-          ctx.lineTo(p.x - nx, p.y - ny);
-          ctx.closePath();
-          ctx.fill();
-        };
-
-        // One stub per direction — per neighbouring node, or per outward
-        // direction. After a merge a node holds many rays whose boundaries
-        // all face the same neighbour; stroking that one segment once per
-        // boundary stacks the 0.3-alpha passes into an opaque line, and mixed
-        // polarities towards the same neighbour blend amber over cyan into a
-        // washed-out white. A `moving` boundary always wins the slot, so the
-        // highlight is never lost to a resting one sharing its direction.
-        const slots = new Map<string, { bd: Boundary; moving: boolean }>();
-        for (const ray of n) {
-          for (const bd of ray.boundaries) {
-            const other = bd.target?.at.node;
-
-            let key: string;
-            if (other && other !== n) key = "n" + idxOf.get(other);
-            else if (!other && bd.outward) key = "o" + bd.outward.join(",");
-            else continue;
-
-            const moving = ray.moving === bd;
-            const cur = slots.get(key);
-            if (!cur || (moving && !cur.moving)) slots.set(key, { bd, moving });
-          }
-        }
-
-        // Dim pass first, so the highlighted one is never overdrawn by it —
-        // and skipped entirely in field mode, where the twenty-five
-        // directions a charge ISN'T going are twenty-five stubs saying
-        // nothing, per charge, per frame.
-        for (const { bd, moving } of slots.values())
-          if (!moving && !field) stub(bd, false);
-
-        for (const { bd, moving } of slots.values())
-          if (moving) stub(bd, true);
-
-        ctx.lineCap = "butt";
-      }
-
-      // What is about to happen — and only ever one thing.
-      //
-      // Everything in this universe is charges moving, and almost all of the
-      // time a charge moving is nothing happening: it swaps places with the
-      // space in front of it and the world is as it was. Two alike meeting
-      // head-on and turning each other round is barely more than that —
-      // nothing is lost by it, the pair carry on the other way, and there are
-      // thousands of them a tick all over the field.
-      //
-      // Cancelling is the only event that leaves the world a different size.
-      // It is the whole of what gravity is here, and marking anything else
-      // alongside it buries it in the general bustle.
-      if (field) {
-        // Drawn plainly, NOT added together like the shells above.
-        //
-        // Additive blending is right for a few translucent surfaces and wrong
-        // for a thousand marks: where the fields properly meet there are
-        // hundreds of these on top of one another, and adding a hundred faint
-        // whites gives solid white. The middle of the picture — which is the
-        // part being watched — turns into a lamp. Ordinary alpha means a
-        // hundred stacked marks are no brighter than a few, so a dense region
-        // reads as dense rather than as blown out.
-        const prev = ctx.globalCompositeOperation;
-
-        for (const nd of graph.nodes) {
-          for (const ray of nd) {
-            const a = ray.moving;
-            const b = a?.target;
-            if (!a || !b) continue;
-
-            const other = b.at.node;
-            if (other === nd) continue;
-
-            // Each moving into where the other is — the same test the tick
-            // itself uses, so what is marked is what will actually happen.
-            const met = other.find(x => x.moving?.target?.at.node === nd);
-            if (!met) continue;
-
-            // Found from both ends; drawn from one.
-            if (idxOf.get(nd)! > idxOf.get(other)!) continue;
-
-            // Against what the other one is actually carrying towards us,
-            // which is its own moving boundary — the same pair of polarities
-            // the tick will compare. Only one of each cancels; everything
-            // else meeting head-on turns around, and turning around leaves
-            // the world exactly as big as it was.
-            const facing = met.moving!.polarity;
-
-            const opposed =
-              (a.polarity === Polarity.Positive && facing === Polarity.Negative) ||
-              (a.polarity === Polarity.Negative && facing === Polarity.Positive);
-
-            if (!opposed) continue;
-
-            const p = pts.get(nd), q = pts.get(other);
-            if (!p || !q || p.clipped || q.clipped) continue;
-
-            const x = (p.x + q.x) / 2, y = (p.y + q.y) / 2;
-            if (!onScreen({ x, y })) continue;
-
-            // Sized in pixels with only a little from the zoom. These are
-            // marks ON the picture rather than things in it — scaled to the
-            // lattice they are two or three pixels across on a ball this big,
-            // which is to say invisible, which is to say the one thing the
-            // picture is for isn't in it.
-            // Sized in pixels rather than scaled to the lattice, but only
-            // just: there are a great many of these once the fields properly
-            // meet, and at full brightness they stop being marks on the
-            // picture and become the picture.
-            const r = 3 + cam.scale * 0.012 * p.depth;
-
-            const flash = ctx.createRadialGradient(x, y, 0, x, y, r);
-            flash.addColorStop(0, "rgba(255,240,214,0.28)");
-            flash.addColorStop(0.4, "rgba(255,240,214,0.1)");
-            flash.addColorStop(1, "rgba(255,240,214,0)");
-            ctx.fillStyle = flash;
-            ctx.beginPath();
-            ctx.arc(x, y, r, 0, Math.PI * 2);
-            ctx.fill();
-
-            // A small hard centre, so it still reads as a point where
-            // something is happening rather than as one more soft glow.
-            ctx.fillStyle = "rgba(255,244,224,0.4)";
-            ctx.beginPath();
-            ctx.arc(x, y, 1, 0, Math.PI * 2);
-            ctx.fill();
-          }
-        }
-
-        // And what DID happen — the same events a tick later, at the place
-        // they happened, fading. An annihilation is over inside the tick it
-        // occurs in and takes both of the points it occurred between with it,
-        // so without this the one thing in this universe that changes how
-        // much space there is is the one thing never shown happening.
-        for (const event of graph.events) {
-          if (event.kind !== 'annihilate') continue;
-
-          const age = graph._tickId - event.tick;
-          if (age > 1) continue;
-
-          const pr = place(project(event.at, cam.rot, cam.tilt, cam.dist || 1));
-          if (pr.clipped || !onScreen(pr)) continue;
-
-          const fade = age === 0 ? 0.3 : 0.12;
-          const r = 5 + cam.scale * 0.018 * pr.depth;
-
-          const burst = ctx.createRadialGradient(pr.x, pr.y, 0, pr.x, pr.y, r);
-          burst.addColorStop(0, `rgba(255,236,196,${fade})`);
-          burst.addColorStop(0.35, `rgba(255,236,196,${0.35 * fade})`);
-          burst.addColorStop(1, "rgba(255,236,196,0)");
-          ctx.fillStyle = burst;
-          ctx.beginPath();
-          ctx.arc(pr.x, pr.y, r, 0, Math.PI * 2);
-          ctx.fill();
-        }
-
-        ctx.globalCompositeOperation = prev;
-
-        // What the last tick actually consisted of. "Nothing is happening"
-        // has several quite different causes that look identical on screen,
-        // and these are what tell them apart: emitted 0 means the sources are
-        // walled in, moved 0 with blocked high means everything has jammed,
-        // and annihilated 0 with both of those healthy means the waves are
-        // travelling perfectly well and simply never meeting.
-        const s = graph.stats;
-        const line = `t${graph._tickId}  pts ${graph.nodes.length}  emit ${s.emitted}  move ${s.moved}  block ${s.blocked}  kill ${s.annihilated}  turn ${s.turned}  holes ${s.holes}`;
-
-        ctx.font = "11px ui-monospace, SFMono-Regular, Menlo, monospace";
-        ctx.textBaseline = "top";
-        ctx.fillStyle = "rgba(150,158,180,0.75)";
-        ctx.fillText(line, 10, 8);
-
-        /**
-         * How far apart the two sources are, in steps through the structure,
-         * plotted against time.
-         *
-         * Flat means they are not gravitating, whatever the picture above it
-         * appears to be doing. Every step down is space between them that has
-         * been annihilated and is not there any more. It is the one reading
-         * here that cannot be argued with by looking harder: the layout is a
-         * solve and can be stiff or slow, and the coordinates never move at
-         * all, but a path is a count of points and either there are fewer of
-         * them than there were or there are not.
-         */
-        const history = graph.history;
-
-        // Nothing to measure with one source: there is no "apart".
-        if (history.length > 1 && graph.route.length > 1) {
-          const W = 150, H = 38, X = 10, Y = h - H - 12;
-
-          const top = Math.max(...history, 1);
-          const now = history[history.length - 1];
-
-          ctx.strokeStyle = "rgba(150,158,180,0.22)";
-          ctx.lineWidth = 1;
-          ctx.strokeRect(X, Y, W, H);
-
-          ctx.strokeStyle = "rgba(120,230,180,0.85)";
-          ctx.lineWidth = 1.4;
-          ctx.beginPath();
-
-          for (let i = 0; i < history.length; i++) {
-            const x = X + (i / Math.max(history.length - 1, 1)) * W;
-            const y = Y + H - (Math.max(history[i], 0) / top) * (H - 4) - 2;
-
-            if (i) ctx.lineTo(x, y); else ctx.moveTo(x, y);
-          }
-
-          ctx.stroke();
-
-          ctx.fillStyle = "rgba(150,158,180,0.75)";
-          ctx.fillText(`source to source: ${now} steps (from ${history[0]})`, X, Y - 15);
-        }
-      }
-    }
-
-    function frame(now) {
-      const dt = Math.min((now - last) / 1000, 0.05);
-      last = now;
-
-      latest.current.onFrame?.(dt);
-      draw();
-
-      raf = requestAnimationFrame(frame);
-    }
-
-    /**
-     * And none of it happens at all while nobody is looking.
-     *
-     * A frame loop is a claim on the machine for as long as it is alive, and
-     * an article like this one is thirty-odd universes stacked up a page
-     * where at most two of them are on screen at a time. Left running, the
-     * twenty-eight that cannot be seen go on ticking, projecting every point
-     * they have, reconstructing a field over every sample of a canvas nobody
-     * is looking at, sixty times a second — which is most of the cost of the
-     * page spent on nothing, and it is the reason scrolling this article got
-     * slower the further down it went.
-     *
-     * So the loop is not merely paused off screen: it is not scheduled, and
-     * whatever the drawing was holding on to is dropped. What comes back
-     * when it returns is a new one — see `onVisible`, and what
-     * `CalculusPlayer` does with it.
-     *
-     * A margin, so that a view is running by the time it is looked at rather
-     * than starting the moment it is. Half a screen is enough at any speed a
-     * page is read at, and it costs nothing when it is wrong.
-     */
-    const start = () => {
-      if (raf) return;
-
-      last = performance.now();
-      raf = requestAnimationFrame(frame);
-    };
-
-    const stop = () => {
-      if (!raf) return;
-
-      cancelAnimationFrame(raf);
-      raf = 0;
-    };
-
-    const show = (visible: boolean) => {
-      if (visible === seen) return;
-      seen = visible;
-
-      latest.current.onVisible?.(visible);
-
-      if (visible) {
-        resize();             // the pixels, given back below, taken again
-
-        if (animate) start();
-        else draw();          // a still, drawn the once, now that it is worth it
-        return;
-      }
-
-      stop();
-
-      // The field as drawn, which is the one thing this view keeps between
-      // frames. Everything else it allocates lives and dies inside a draw.
-      eased = null;
-
-      /**
-       * And the pixels, which are the larger half of it by some way.
-       *
-       * A canvas of this size on a display of this density is several
-       * megabytes of buffer, and there are thirty of them down the page —
-       * comfortably more than every universe on it put together. Clearing it
-       * frees nothing; the buffer is the same size empty. Setting it to no
-       * size at all is what hands it back, and asking for the size again is
-       * what takes it.
-       *
-       * The element's own layout is unaffected, since that comes from the
-       * style rather than from the attributes, so the box stays exactly where
-       * it was and exactly the size it was — which it has to, or the thing
-       * watching for it to come back on screen would have nothing to watch.
-       */
-      canvas.width = 0;
-      canvas.height = 0;
-    };
-
-    const unwatch = whileOnScreen(canvas, show);
-
-    return () => {
-      unwatch();
-      stop();
-      window.removeEventListener("resize", onResizeIfSeen);
-      // canvas.removeEventListener("wheel", onWheel);
-      // canvas.removeEventListener("contextmenu", onContextMenu);
-      // canvas.removeEventListener("mousedown", onMouseDown);
-      // window.removeEventListener("mousemove", onMouseMove);
-      // window.removeEventListener("mouseup", onMouseUp);
-    };
-  }, [animate, density, mode]);
-
-
-  return <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%" }} />;
-}
-
-/**
- * The animated form: one universe, ticking, with transport controls.
- */
-const CalculusPlayer = ({
-  graph: seed = () => Graph.expandingGrid(3),
-  repeated = false,
-  autoplay = repeated !== false,
-  height = 150,
-  density = true,
-  mode = 'lattice',
-  interval = 0.45,
-}: CalculusVisualizationProps) => {
-  const [running, setRunning] = useState(autoplay);
-
-  /**
-   * The live universe. Held in a ref rather than state because resetting
-   * swaps the whole graph out mid-animation-frame — the render loop reads it
-   * afresh every frame, so it picks the new one up without tearing down.
-   *
-   * And nothing at all while the view is off screen. A universe here is some
-   * thousands of points, each with twenty-six boundaries and a projection
-   * cached against it, and there are thirty of these on the page — so what
-   * is being held between the reader scrolling past a picture and scrolling
-   * back to it is tens of megabytes of a thing nobody can see. Dropped, it
-   * is a null and a re-seed.
-   *
-   * Which is not a loss of anything, because there is nothing here to lose.
-   * The dynamics are stochastic, and a repeating example throws its universe
-   * away and re-seeds every `cycle` ticks anyway: coming back to one of
-   * these is coming back to a fresh run whether it was let go of or not.
-   * Seeded lazily rather than eagerly for the same reason as everything else
-   * in this — thirty seeds built at mount is thirty universes' worth of work
-   * for the one or two that can be seen.
-   */
-  const graphRef = useRef<Graph | null>(null);
-
-  // Ticks taken since the last reset, against which `repeated` is measured.
-  const stepsRef = useRef(0);
-
-  const cycle = typeof repeated === 'number' ? repeated : DEFAULT_STEPS;
-  const loops = repeated !== false;
-
-  const reset = () => {
-    graphRef.current = seed();
-    stepsRef.current = 0;
-  };
-
-  const step = () => {
-    graphRef.current?.tick();
-    stepsRef.current++;
-  };
-
-  // Step the polarity dynamics once every `interval` seconds while running —
-  // annihilation / turn-around / structure-absorption.
-  const accum = useRef(0);
-
-  /**
-   * Made when it is first looked at, and let go of the moment it is not.
-   *
-   * Except when it is paused, which is the one case where the state on
-   * screen is something the reader chose. Stopping a run at a particular
-   * tick to look at it, scrolling a little too far, and coming back to a
-   * fresh one would be losing the thing they stopped for. A running view has
-   * no such state — it is somewhere in the middle of a loop that resets
-   * every `cycle` ticks regardless — so there is nothing to lose in letting
-   * it go, and coming back to it starts the run again from the top, which is
-   * where it wants to be watched from anyway.
-   */
-  const onVisible = (visible: boolean) => {
-    if (!visible) {
-      if (!running) return;
-
-      graphRef.current = null;
-      accum.current = 0;
-      return;
-    }
-
-    if (running || !graphRef.current) reset();
-  };
-
-  const onFrame = (dt: number) => {
-    if (!running || !graphRef.current?.nodes.length) return;
-
-    accum.current += dt;
-    while (accum.current >= interval) {
-      accum.current -= interval;
-
-      // A repeating pattern spends one interval showing the seed again
-      // before stepping on, so the loop point is legible rather than an
-      // instant jump back.
-      if (loops && stepsRef.current >= cycle) reset();
-      else step();
-    }
-  };
-
-  return <div>
-    <div style={{ height }}>
-      <GraphView
-        graph={() => graphRef.current}
-        animate
-        density={density}
-        mode={mode}
-        onFrame={onFrame}
-        onVisible={onVisible}
-      />
-    </div>
-    <Row end="xs" className="child-px-2">
-      {running
-        ? <>
-          <div style={{ width: '1em' }}></div>
-          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }} onClick={() => setRunning(false)}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M176 96C149.5 96 128 117.5 128 144L128 496C128 522.5 149.5 544 176 544L240 544C266.5 544 288 522.5 288 496L288 144C288 117.5 266.5 96 240 96L176 96zM400 96C373.5 96 352 117.5 352 144L352 496C352 522.5 373.5 544 400 544L464 544C490.5 544 512 522.5 512 496L512 144C512 117.5 490.5 96 464 96L400 96z" /></svg></Button>
-          <div style={{ width: '1em' }}></div>
-        </>
-        : <>
-          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }} onClick={reset}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M491 100.8C478.1 93.8 462.3 94.5 450 102.6L192 272.1L192 128C192 110.3 177.7 96 160 96C142.3 96 128 110.3 128 128L128 512C128 529.7 142.3 544 160 544C177.7 544 192 529.7 192 512L192 367.9L450 537.5C462.3 545.6 478 546.3 491 539.3C504 532.3 512 518.8 512 504.1L512 136.1C512 121.4 503.9 107.9 491 100.9z" /></svg></Button>
-          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }} onClick={() => setRunning(true)}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M187.2 100.9C174.8 94.1 159.8 94.4 147.6 101.6C135.4 108.8 128 121.9 128 136L128 504C128 518.1 135.5 531.2 147.6 538.4C159.7 545.6 174.8 545.9 187.2 539.1L523.2 355.1C536 348.1 544 334.6 544 320C544 305.4 536 291.9 523.2 284.9L187.2 100.9z" /></svg></Button>
-          <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }} onClick={step}><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">{/* <!--!Font Awesome Free v7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--> */}<path d="M149 100.8C161.9 93.8 177.7 94.5 190 102.6L448 272.1L448 128C448 110.3 462.3 96 480 96C497.7 96 512 110.3 512 128L512 512C512 529.7 497.7 544 480 544C462.3 544 448 529.7 448 512L448 367.9L190 537.5C177.7 545.6 162 546.3 149 539.3C136 532.3 128 518.7 128 504L128 136C128 121.3 136.1 107.8 149 100.8z" /></svg></Button>
-        </>
-      }
-    </Row>
-  </div>
-}
-
-/**
- * The static form: the same pattern, but every step of it laid out at once.
- *
- * The dynamics are stochastic (which boundary a ray turns around to, what
- * polarity a newly created point gets), so the states can't be re-derived by
- * re-running the seed — running it again gives a different history. One run
- * is stepped through, and each state along the way is cloned out of it, so
- * the strip really is consecutive states of a single universe.
- */
-const CalculusFilmstrip = ({
-  graph: seed = () => Graph.expandingGrid(3),
-  repeated = false,
-  height = 150,
-  density = true,
-  mode = 'lattice',
-}: CalculusVisualizationProps) => {
-  const cycle = typeof repeated === 'number' ? repeated : DEFAULT_STEPS;
-
-  const frames = useMemo(() => {
-    const graph = seed();
-    const states = [graph.clone()];
-
-    for (let i = 0; i < cycle; i++) {
-      graph.tick();
-      states.push(graph.clone());
-    }
-
-    return states;
-  }, []);
-
-  return <div style={{ display: 'flex', flexWrap: 'wrap', alignItems: 'center' }}>
-    {frames.map((graph, i) => (
-      <Fragment key={i}>
-        {i > 0
-          ? <div style={{ flex: '0 0 auto', padding: '0 0.5em', color: '#515254' }}>→</div>
-          : null}
-        <div style={{ flex: '1 1 120px', height }}>
-          <GraphView graph={() => graph} density={density} mode={mode} />
-        </div>
-      </Fragment>
-    ))}
-  </div>
-}
-
-const CalculusVisualization = ({ filmstrip, ...props }: CalculusVisualizationProps) =>
-  filmstrip
-    ? <CalculusFilmstrip {...props} />
-    : <CalculusPlayer {...props} />;
-
-/**
- * The whole of it as one expression, which is the other way of having it.
- *
- * Everything above is the model run: a few thousand points, each one moved
- * or not moved by a rule that looks only at its neighbours, and a picture
- * reconstructed afterwards from where they all ended up. That is the honest
- * order to do it in — the rules are the claim, and the shape is whatever
- * comes out of them — but it is expensive twice over. Once in the running,
- * and once in the reading: a field made of points has to be turned back into
- * a field, and every choice in that reconstruction is a chance to draw
- * something the rules did not say.
- *
- * There is a second way, available only once you already know what the rules
- * make, and it is worth having precisely because it is derived rather than
- * assumed. A source at the origin turning at ω radians a tick, emitting the
- * charge of whichever pole faces a direction, and a wave that travels one
- * cell a tick. Then the charge at distance r in direction θ at time t is the
- * charge that left the source r ticks ago, when its axis pointed at
- * α + ω(t − r) rather than at α + ωt. So the field is
- *
- *     F(r, θ, t) = cos( lobes·θ − ω·(t − r) − α )
- *
- * and there is nothing else to it. No points, no reconstruction, no
- * neighbours to decide between: at any place and any moment the answer is
- * one cosine, and the picture is that cosine evaluated at every pixel.
- *
- * `lobes` is the only thing that separates the two cases in this article, and
- * it is not a parameter so much as a question about the source. One: it has
- * an axis, so what it emits depends on the direction — the field carries a θ
- * in it, the zero set is θ = ω(t − r) + const, and that is an Archimedean
- * spiral. Nought: it has no sides, so direction drops out altogether, the
- * zero set is r = t − const, and that is a set of rings travelling outward.
- * A spiral and a ring are the same function with and without an angle in it,
- * which is what it means to say the difference between the two sources is
- * that one turns and the other only flips.
- *
- * Several of them add. That is a claim rather than a definition, and it is
- * the one place this parts company with the model above: charges there do
- * not superpose, they meet and annihilate. But annihilation IS what addition
- * does to two opposite numbers, and the thing that survives it — the region
- * where one charge is left over — is what a sum of cosines has where they do
- * not cancel. So it is the right continuous shadow of a discrete rule, and
- * the places where the two disagree are exactly the places worth looking at.
- */
-const LIGHT = 1;                                  // cells a wave goes in a tick
-
-type Emitter = {
-  // Where it is, in cells.
-  at: [number, number];
-
-  // One if it has an axis and so has sides; nought if it puts out the same
-  // thing in every direction at once.
-  lobes: 0 | 1;
-
-  // Radians of pattern per tick, signed. Which way round it turns, for a
-  // source with sides; how fast it flips over, for one without.
-  omega: number;
-
-  // Where in the cycle it starts, which is the only thing one source can be
-  // against another.
-  phase: number;
-
-  /**
-   * How it is already going, in cells a tick, and it keeps going that way.
-   *
-   * There is no force in this model and so there is nothing for a velocity to
-   * be changed BY. A source that was set moving carries on moving, at the one
-   * speed its mass allows, in the direction it was sent; nothing here
-   * accelerates anything, and nothing here can slow anything down. What
-   * happens to a pair with momentum is not that they are pulled off course —
-   * it is that the space they are crossing goes on being eaten while they
-   * cross it, so the two end up closer together than their courses would have
-   * left them, without either having gone anywhere it was not already going.
-   *
-   * Which is a strange enough thing to be worth watching, and is the whole
-   * reason for these cases. An orbit that comes out of this is not a balance
-   * of a pull against an inertia. It is a drift that keeps carrying the two
-   * sideways while the gap between them keeps shortening underneath.
-   */
-  drift?: [number, number];
-
-  /**
-   * Ticks between one pulse and the next, or nothing for a source whose
-   * emission is continuous.
-   *
-   * The cases above emit without pause: the cosine is defined everywhere, so
-   * every point in the field is carrying something and there are no shells,
-   * only a phase that varies. That is the smooth reading of the model and it
-   * is a fair one, but it hides the thing the lattice version makes obvious —
-   * that what is emitted is a shell, that shells are discrete, and that
-   * annihilation is one of them meeting one of them.
-   *
-   * Given a beat, the emission becomes a train: a pulse leaves at every
-   * multiple of it and nothing leaves in between, so what travels out is a
-   * set of rings with space between them rather than a filled field. Which
-   * changes the arithmetic of the eating, and changes it in the direction
-   * that matters. Two sources pulsing every tick have a meeting every tick;
-   * two pulsing every OTHER tick have a meeting every other tick, so the gap
-   * between them goes at half the rate while their courses carry them along
-   * at exactly the speed they did. Moving as fast and eating half as quickly
-   * is the difference between a pair that is captured and a pair that has
-   * time to get somewhere first.
-   */
-  beat?: number;
-};
-
-// How wide a pulse is, in ticks — so a ring is about this many cells thick to
-// either side of where its front is.
-const PULSE = 0.5;
-
-/**
- * As fast as a source goes, and here it goes almost as fast as anything can.
- *
- * One step a tick is this model's ceiling — a ray moves at most once per tick,
- * so nothing outruns the wave it emits — and mass is the only thing that
- * keeps anything under it: a step costs a source `MAGNET_MASS`, a tick pays
- * one, so a heavy source crawls. Set to within a percent of the ceiling
- * instead, these are as light as a thing can be and still be a thing.
- *
- * Not a percent short for safety's sake. At the ceiling exactly, everything a
- * source ever emitted in the direction it is going arrives at the same
- * moment, and the retarded time ahead of it stops having one answer — that is
- * a real feature of moving at the speed of your own light and not a numerical
- * complaint, but it is also the point past which nothing can be drawn,
- * because what is being asked for is not a number. A percent under, the
- * pile-up ahead is a hundredfold compression, which is a great deal to look
- * at and is still a finite thing.
- */
-const PACE = 0.5 * LIGHT;
-
-
-
-/**
- * A source as it currently stands, and everywhere it has been.
- *
- * The past is not optional here. What is at distance r left r ticks ago, from
- * wherever the source was then — so a ring already in the air belongs to a
- * place, and that place does not move again however the thing that made it
- * carries on. Once these start eating they travel at half of light, and a
- * ring emitted twenty ticks ago is centred ten cells from where its source
- * now is; drawn from the present position instead, the whole field is hauled
- * about every time the speed changes, which is every frame, and what should
- * be a stack of settled layers becomes one object flapping.
- *
- * So it is remembered rather than extrapolated, at a couple of samples a
- * tick, which is finer than anything in the picture varies over.
- */
-const TRAIL = 0.5;                                // ticks between remembered places
-
-type Live = Emitter & {
-  // x then y, one pair per TRAIL of t, from the beginning of the run.
-  path: number[];
-
-  // How it is going now, which starts as its `drift` and is then turned by
-  // the space it is going through. Nothing ever changes its SPEED; see the
-  // flow below.
-  vel: [number, number];
-};
-
-// The corner and spacing of the grid every shadow is sampled on, which is the
-// survey's grid — they are the same question asked at the same places.
-let GRID = 0, GRID_X = 0, GRID_Y = 0, GRID_STEP = 1;
-
-// Where it was at a given moment, and how fast it was going then. Between
-// samples, and before the run began, the nearest thing it can honestly say.
-const RETARD: [number, number] = [0, 0];
-const CARRY: [number, number] = [0, 0];
-
-// Which way the thing `emit` just reported on is going.
-const WAY: [number, number] = [0, 0];
-
-const was = (s: Live, when: number) => {
-  const last = s.path.length / 2 - 1;
-  const k = Math.min(Math.max(when / TRAIL, 0), last);
-
-  const i = Math.floor(k), j = Math.min(i + 1, last);
-  const f = k - i;
-
-  RETARD[0] = s.path[2 * i] * (1 - f) + s.path[2 * j] * f;
-  RETARD[1] = s.path[2 * i + 1] * (1 - f) + s.path[2 * j + 1] * f;
-};
-
-const wasGoing = (s: Live, when: number) => {
-  was(s, when);
-
-  const ax = RETARD[0], ay = RETARD[1];
-
-  was(s, when - TRAIL);
-
-  CARRY[0] = (ax - RETARD[0]) / TRAIL;
-  CARRY[1] = (ay - RETARD[1]) / TRAIL;
-
-  RETARD[0] = ax; RETARD[1] = ay;
-};
-
-/**
- * When what is at a point now left the source that made it.
- *
- * The retarded time is the root of |x − p(te)| = t − te, and how it is found
- * matters entirely at these speeds. The obvious way — guess r from where the
- * source is now, look up where it was that long ago, measure again — walks
- * towards the answer, and how fast it walks is exactly the source's speed:
- * each round takes off a fraction v of what is left. At a third of light that
- * is three good rounds and done. At ninety-nine hundredths it is six hundred,
- * which is not a thing that can be done once per source per sample of a
- * picture, sixty times a second.
- *
- * So it is solved rather than approached. Over the short stretch of trail the
- * answer lies in, the source is going in a straight line at a steady rate,
- * and for a straight line the equation is a quadratic in te and can simply be
- * written down. Two rounds of that — one to find roughly where to look, one
- * to solve properly with the velocity found there — lands on the answer
- * regardless of how near the ceiling the thing is travelling.
- *
- * The position is then read from the trail rather than from the straight
- * line, so the answer is still a record of where the source actually was.
- * Nothing already emitted moves, which was the whole reason for keeping a
- * trail; the straight line is only ever used to work out WHEN to look.
- */
-const retard = (s: Live, x: number, y: number, t: number) => {
-  let te = t - Math.hypot(x - s.at[0], y - s.at[1]) / LIGHT;
-
-  /**
-   * Two passes, and the second one earned rather than assumed.
-   *
-   * The quadratic below is exact for a source going in a straight line at a
-   * steady rate — but the FIRST guess it starts from is taken from where the
-   * source is now, and for one travelling at ninety-nine hundredths of the
-   * speed of its own light that guess can be most of the picture out. The
-   * velocity then gets looked up at the wrong moment, the quadratic is solved
-   * for the wrong straight line, and the answer is wrong by however far the
-   * source moved in between. Which is not a small error politely spread
-   * about: it is a radius, so it comes out as rings in the wrong place, and
-   * they go wrong only where the source has been quick, which is why it looks
-   * like something tearing rather than something blurred.
-   *
-   * A second pass starts from an answer that is already close and settles it.
-   * Standing still, though, the first pass is exact and the second is a
-   * measurement of nothing — so it is skipped, which is most of the time in
-   * most of these pictures.
-   */
-  for (let pass = 0; pass < 2; pass++) {
-    wasGoing(s, te);
-
-    if (pass > 0 && Math.abs(CARRY[0]) + Math.abs(CARRY[1]) < 1e-6) break;
-
-    const ex = x - RETARD[0], ey = y - RETARD[1];
-    const vx = CARRY[0], vy = CARRY[1];
-
-    // How long there is between te and now, which is what the light has to
-    // cover — less however much further back the answer turns out to be.
-    const a = t - te;
-
-    const A = vx * vx + vy * vy - LIGHT * LIGHT;
-    const B = 2 * (a * LIGHT * LIGHT - (ex * vx + ey * vy));
-    const C = ex * ex + ey * ey - a * a * LIGHT * LIGHT;
-
-    let step = 0;
-
-    if (Math.abs(A) < 1e-9) {
-      if (Math.abs(B) > 1e-9) step = -C / B;
-    } else {
-      const disc = B * B - 4 * A * C;
-      if (disc < 0) break;
-
-      /**
-       * Solved the stable way, which at these speeds is not a nicety.
-       *
-       * A is v² − 1, and a source travelling at ninety-nine hundredths of
-       * light makes that about a fiftieth. Dividing by it is the textbook
-       * formula and it is exactly where the textbook formula falls apart:
-       * one of the two roots comes out as a small difference of two nearly
-       * equal numbers divided by a nearly vanishing one, and what it returns
-       * is not an approximation of the answer, it is thousands of cells of
-       * nonsense. Which is then used as a radius, so the rings it draws are
-       * nowhere near where anything is — and only where the source has been
-       * quick, which is why it tore rather than blurred.
-       *
-       * Taking the well-conditioned root first and getting the other from
-       * the product of the two has neither subtraction of like quantities nor
-       * division by the small coefficient.
-       */
-      const root = Math.sqrt(disc);
-      const q = -0.5 * (B + (B >= 0 ? root : -root));
-
-      const p1 = q / A, p2 = Math.abs(q) > 1e-12 ? C / q : q / A;
-
-      // Of the two, the one that leaves the light a non-negative time to
-      // travel in. The other is the advanced solution, which is the same
-      // algebra describing something arriving before it left.
-      const ok1 = a - p1 >= 0, ok2 = a - p2 >= 0;
-
-      step = ok1 && ok2 ? (Math.abs(p1) < Math.abs(p2) ? p1 : p2)
-        : ok1 ? p1
-          : ok2 ? p2
-            : 0;
-    }
-
-    te = Math.min(te + step, t);
-  }
-
-  return te;
-};
-
-/**
- * What ONE source puts at a point.
- *
- * Two things temper the bare cosine, and both are properties of the world
- * above rather than decoration. A wave has not arrived yet where r > t·c, so
- * there is nothing there — softened over a cell, since a lattice front is not
- * a razor either. And it thins as it goes, because the same emission is
- * spread over a bigger and bigger circle; in the model that shows up as the
- * shells growing apart, here as one over the distance.
- *
- * And it is measured from where the source WAS, not from where it is: the
- * ring through this point left when the source was at p(t − r), and it is
- * centred there for good. Which is what makes a moving source's rings bunch
- * up ahead of it and stretch out behind, and at the speeds these reach once
- * they start eating, that bunching is most of what the picture shows.
- *
- * r is on both sides of that, so it is solved for rather than computed —
- * guess it from where the source is now, look up where it was that long ago,
- * measure again. Three rounds, because a source that is eating closes at the
- * speed of its own light and the answer directly ahead of it is then a near
- * thing: everything it emitted on the way arrives at once, which is a real
- * pile-up and not an artefact, and it takes a round or two to find. The trail
- * it looks things up in is a record rather than a projection, so nothing
- * already emitted can move again however hard the solve works.
- */
-const emit = (
-  s: Live, w: Emitter, x: number, y: number, t: number, reach: number,
-  known?: number,
-) => {
-  // Solving the retarded time is the most expensive thing here, and whoever
-  // called this has usually just done it — for the ray, for the cut, for the
-  // meeting surface. Told the answer, this does not do it a second time.
-  let te = known === undefined ? retard(s, x, y, t) : known;
-
-  was(s, te);
-
-  const dx = x - RETARD[0], dy = y - RETARD[1];
-  const r = Math.hypot(dx, dy);
-
-  // Which way what is here is travelling, which is out from wherever it left.
-  // Local, and needed by anything asking whether two things are meeting or
-  // merely crossing.
-  WAY[0] = r > 1e-9 ? dx / r : 1;
-  WAY[1] = r > 1e-9 ? dy / r : 0;
-
-  /**
-   * Nothing has arrived where the wave has not reached yet, softened over a
-   * cell because a lattice front is not a razor either.
-   *
-   * Only for a source emitting without pause. A pulse train has its own
-   * edges — the shape below is nought outside the pulse and that is the whole
-   * of where it is not — and applying this to one as well says something
-   * false about the first pulse of the train, which left at the very
-   * beginning and so IS the front: its own arrival is used as evidence that
-   * it has not arrived, and it is never drawn at all.
-   */
-  const front = w.beat ? 1 : Math.min((t * LIGHT - r) / 1.5, 1);
-  if (front <= 0) return 0;
-
-  const fade = 1 / (1 + r / reach);
-
-  /**
-   * cos(θ − ψ) without ever working out θ.
-   *
-   * The direction to here is wanted only inside a cosine, and cos(θ − ψ) is
-   * cos θ·cos ψ + sin θ·sin ψ — where cos θ and sin θ are dx/r and dy/r,
-   * which are already to hand. So the arctangent, which is the most expensive
-   * thing in this whole expression and is evaluated once per source per
-   * sample of the picture, is not needed at all.
-   */
-  /**
-   * When what is here left, and — if this source pulses — whether anything
-   * left then at all.
-   *
-   * A pulse train is not a sum over pulses. The nearest multiple of the beat
-   * to the emission time IS the pulse this point could belong to, since the
-   * pulses are narrower than the gaps between them, so one rounding finds it
-   * and one bump says how much of it is here. Everything stays O(1) in the
-   * number of pulses in the air, which by now is a great many.
-   */
-  let shape = 1;
-
-  if (w.beat) {
-    const beat = Math.round(te / w.beat) * w.beat;
-    const u = (te - beat) / PULSE;
-
-    if (u <= -1 || u >= 1 || beat < 0) return 0;
-
-    shape = (1 - u * u) ** 2;
-    te = beat;
-  }
-
-  const psi = w.omega * te + w.phase;
-
-  const wave = w.lobes
-    ? (dx * Math.cos(psi) + dy * Math.sin(psi)) / (r || 1)
-    : Math.cos(psi);
-
-  return front * fade * shape * wave;
-};
-
-/**
- * And what the two of them do to each other when they are ALIKE, which the
- * sum on its own does not contain.
- *
- * Opposite charges meeting head-on annihilate, and that is the gravity above.
- * Like charges meeting head-on turn each other around, and nothing so far has
- * said so — the closed form adds the two contributions and lets them through
- * one another.
- *
- * For most of these pictures that is not the omission it looks like. Two
- * identical shells bouncing off each other are indistinguishable from two
- * shells passing through and swapping names: A's charge ends up where B's
- * would have been and B's where A's would have been, so the set of places
- * that are charged is the same either way, and so is the phase at each of
- * them — the bounced charge has travelled exactly as far as the one that came
- * the other way. The field cannot tell, because the field does not record
- * which source anything belongs to. Superposition is already right, and the
- * waves not visibly turning around is not a thing going wrong.
- *
- * It stops being right the moment the two are not interchangeable. A bounced
- * wave carries the phase and the cadence of the source it came from, and
- * fades with the distance IT has travelled — and if the two sources are half
- * a cycle apart, or pulsing at different rates, or one of them is moving and
- * the other is not, then what comes back is not what would have gone through
- * and the exchange does not cancel.
- *
- * A reflection is an image: the wave that bounced arrives as though it had
- * come from the mirror of its source in the surface it bounced off. That
- * surface, for a pair, is the plane halfway between them — so the mirror of
- * one source is the position of the other, and what comes back is the OTHER
- * one's geometry carrying THIS one's phase. Which is why the two swap out
- * exactly when they are alike, and why they do not otherwise.
- *
- * So the field is the two readings blended by how much of the meeting is
- * alike rather than opposite, which `survey` measures on its way past. For
- * matched sources the reflected pair is the direct pair with the names
- * exchanged, the blend is between a thing and itself, and it reduces to the
- * plain sum with nothing left over.
- */
-/**
- * How far a wave of `a`'s gets before it runs into one of `b`'s.
- *
- * Both travel a cell a tick, so waves that left at the same moment meet
- * halfway — and along a ray that is not aimed straight at the other source,
- * further, because the surface they meet on is a plane and a slanted ray has
- * further to go to reach it. Aimed away from the other source it never meets
- * anything at all, and goes on for ever.
- *
- * This is the only thing that stops a wave, and it stops it completely. There
- * is no thinning, no optical depth, no fraction getting through. A charge
- * meets another charge and one of two things happens, and neither of them is
- * "carries on a bit weaker".
- */
-const HERE: [number, number] = [0, 0];
-const THERE: [number, number] = [0, 0];
-
-const meets = (
-  a: Live, b: Live, dx: number, dy: number, when: number,
-) => {
-  /**
-   * Worked out from where the two of them WERE, not from where they are.
-   *
-   * This is the whole of what makes it local, and getting it wrong is
-   * unmistakable: a wave that left long ago has its stopping place decided by
-   * a surface built out of the sources' present positions, so every time
-   * either of them turns or drifts, the surface swings and every wave already
-   * in the air swings with it. Rings that were laid down years of ticks ago
-   * get up and rotate, which is not a thing waves do. Nothing that has
-   * already happened is allowed to depend on anything that happened after it.
-   *
-   * So both are asked where they were when this wave was in the air, and the
-   * answer is a record — see the trail — rather than anything derived from
-   * now. What was decided then stays decided.
-   */
-  was(a, when);
-  HERE[0] = RETARD[0]; HERE[1] = RETARD[1];
-
-  was(b, when);
-  THERE[0] = RETARD[0]; THERE[1] = RETARD[1];
-
-  let ux = THERE[0] - HERE[0], uy = THERE[1] - HERE[1];
-  const gap = Math.hypot(ux, uy);
-  if (gap < 1e-6) return Infinity;
-
-  ux /= gap; uy /= gap;
-
-  const aim = dx * ux + dy * uy;
-
-  /**
-   * And only where the two would actually be head-on when they got there.
-   *
-   * The surface halfway between a pair is a whole plane, and it is tempting
-   * to stop everything at it — but two waves arriving at a point far out on
-   * that plane are not meeting, they are travelling side by side. Their
-   * directions there are mirror images about the plane, so the angle between
-   * them is set by how squarely the ray was aimed: dead at the other source
-   * they are exactly opposed, and at forty-five degrees off they are already
-   * at right angles and past caring about each other.
-   *
-   * Beyond that the encounter is a crossing. Charges crossing at an angle do
-   * nothing to each other in this model — they pass, and both carry on — so
-   * stopping them there would put a seam down the middle of every picture
-   * where none belongs, and it is why the arms far from the axis have to go
-   * through one another. They are not meeting. They are just both there.
-   */
-  if (aim <= 0.71) return Infinity;
-
-  return (gap / 2) / aim;
-};
-
-/**
- * A wave of `a`'s that has met one of `b`'s and turned around.
- *
- * Which of the two things happened at that meeting is decided THERE, by what
- * the two of them were, and not by any running average over the picture. Two
- * charges meeting head-on are alike or they are opposite; alike, they turn
- * each other round and both go back the way they came; opposite, they
- * annihilate and neither of them is anywhere afterwards. So this asks the
- * question at the place and the moment it was settled: what was `a` putting
- * out along this ray when it got to the meeting, and what was `b` putting
- * into the same spot at the same instant. Same sign, and there is a wave
- * coming home. Opposite, and there is nothing — which is the annihilation,
- * and it needs no separate machinery, because a thing that annihilated simply
- * has no return.
- *
- * And what comes home runs into the shells its own source has emitted since,
- * head-on, going the other way. A source that turns over is putting out the
- * opposite charge by then, so what the returning wave meets is its opposite,
- * and the two cancel. That is the second half of what makes the space between
- * a pair empty, and it falls out of the arithmetic rather than being put in:
- * these are all terms in one sum, and terms of opposite sign cancel.
- *
- * The going-out and the coming-back are the same wave with the sign of the
- * radius flipped. Outgoing at distance r left r ago, so its phase runs on
- * t − r and crests move outward. Having gone to the meeting at R and come
- * back to r it has travelled 2R − r, so its phase runs on t − 2R + r and
- * crests move inward. One sign, and that sign is the whole of what bouncing
- * is.
- */
-const bounced = (
-  a: Live, b: Live, x: number, y: number, t: number, reach: number,
-  known?: number, given?: number,
-) => {
-  // From where it was when this left it, for the reason given in `fieldAt`.
-  const left = known === undefined ? retard(a, x, y, t) : known;
-
-  was(a, left);
-
-  let dx = x - RETARD[0], dy = y - RETARD[1];
-  const r = Math.hypot(dx, dy);
-  if (r < 1e-6) return 0;
-
-  dx /= r; dy /= r;
-
-  // Asked of the moment this wave was crossing, not of now — or handed
-  // straight over by whoever has already asked.
-  const mirror = given === undefined ? meets(a, b, dx, dy, left) : given;
-  if (!isFinite(mirror) || r >= mirror) return 0;   // nothing has come back to here
-
-  // Out to the meeting and back again: how far this has travelled, and so
-  // how long ago it left.
-  const path = 2 * mirror - r;
-  const te = t - path / LIGHT;
-  if (te < 0) return 0;
-
-  // As above: a train's own pulse shape says where it is, and this would
-  // erase the first of them.
-  const front = a.beat ? 1 : Math.min((t * LIGHT - path) / 1.5, 1);
-  if (front <= 0) return 0;
-
-  let when = te, shape = 1;
-
-  if (a.beat) {
-    const beat = Math.round(when / a.beat) * a.beat;
-    const u = (when - beat) / PULSE;
-
-    if (u <= -1 || u >= 1 || beat < 0) return 0;
-
-    shape = (1 - u * u) ** 2;
-    when = beat;
-  }
-
-  const psi = a.omega * when + a.phase;
-
-  // The angle is the one it LEFT along, since that is the half of the source
-  // it came out of.
-  const mine = a.lobes ? dx * Math.cos(psi) + dy * Math.sin(psi) : Math.cos(psi);
-  if (mine === 0) return 0;
-
-  // What the other one had at that spot when this arrived there. Same sign,
-  // and the two turned each other round; opposite, and they are both gone.
-  was(a, left);
-
-  const hitX = RETARD[0] + dx * mirror, hitY = RETARD[1] + dy * mirror;
-  const struck = t - (mirror - r) / LIGHT;
-
-  const theirs = emit(b, b, hitX, hitY, struck, reach);
-
-  const agree = (mine * theirs) / (Math.abs(mine) * Math.abs(theirs) + 1e-9);
-  const alike = Math.max(agree, 0);
-  if (alike <= 1e-3) return 0;
-
-  // Softened right at the meeting surface, which is a place and not a knife.
-  const edge = Math.min(Math.max((mirror - r) / 1.5, 0), 1);
-
-  /**
-   * Thinned by where it IS, not by how far it has been — which is the
-   * opposite of what it looks like it should be, and is why this was so hard
-   * to see.
-   *
-   * The thinning is a shell spread round a growing circle: the same emission
-   * stretched over a longer and longer ring, so it goes as the radius. A
-   * shell coming home sits on a circle exactly the size of an outgoing
-   * shell's at the same radius, and it is CONTRACTING — its charges are being
-   * gathered back onto a shorter and shorter ring, so it gets denser as it
-   * returns rather than fainter.
-   *
-   * Faded by the whole path instead, as it was, a returning wave is dimmed by
-   * twice the distance to the surface while the outgoing wave drawn at the
-   * same place is dimmed by almost nothing. It was in the arithmetic and
-   * underneath the wave it had bounced off, worst of all near the source
-   * where it should have been brightest.
-   *
-   * The path still sets the phase. How far a thing has travelled is when it
-   * left; it is not how spread out it is.
-   */
-  return alike * edge * front * shape * mine / (1 + r / reach);
-};
-
-/**
- * What is at a place: everything that got there, going out and coming back.
- *
- * A plain sum, and it can be, because nothing in it is a wave that should not
- * be there. A wave stops dead at the first thing it meets — that is `meets`
- * above, applied to every outgoing term — so two sources' waves never overlap
- * beyond their meeting surface and there is no crossing to suppress. What is
- * left to add up is a handful of waves that genuinely coexist, and adding is
- * the right thing to do with those: where two of them are opposite they
- * cancel, which is annihilation, drawn.
- *
- * Which is why the returning wave puts out the space between a pair without
- * anything being written to make it. It comes home into shells its own source
- * threw out later, and a source that turns over threw the opposite charge;
- * they are opposite terms in a sum, and they go.
- */
-const MIRRORS: number[] = [];
-
-const fieldAt = (
-  x: number, y: number, t: number, sources: Live[], reach: number,
-) => {
-  let total = 0;
-
-  for (const a of sources) {
-    /**
-     * Measured from where this source WAS when the wave here left it.
-     *
-     * Not from where it is. The two are the same thing only for a source
-     * standing still, and these travel at ninety-nine hundredths of the speed
-     * of what they emit — so the distance to the present source and the
-     * distance the wave actually came differ by most of the picture. Taking
-     * the ray and the radius from the present position while the surface it
-     * is being cut against is worked out from the past one is two different
-     * geometries compared against each other, and what that produces is a
-     * cut at the wrong radius: a hole where a wave was stopped that never met
-     * anything, standing between the pair and following them about.
-     */
-    const when = retard(a, x, y, t);
-
-    was(a, when);
-
-    let dx = x - RETARD[0], dy = y - RETARD[1];
-    const r = Math.hypot(dx, dy) || 1e-9;
-
-    dx /= r; dy /= r;
-
-    // As far as the nearest thing that was in the way when it went past, and
-    // no further.
-    let stop = Infinity;
-    let seen = 0;
-
-    for (const b of sources) {
-      if (b === a) continue;
-
-      const at = meets(a, b, dx, dy, when);
-
-      MIRRORS[seen++] = at;
-      if (at < stop) stop = at;
-    }
-
-    if (r < stop) {
-      // Faded over a cell at the surface, so the end of a wave is a place
-      // rather than an event.
-      const edge = isFinite(stop) ? Math.min((stop - r) / 1.5, 1) : 1;
-
-      total += emit(a, a, x, y, t, reach, when) * edge;
-    }
-
-    // Only where something was in the way. Over most of any of these pictures
-    // nothing is — a ray not aimed at the other source never meets it — and
-    // asking `bounced` anyway means solving a retarded time and a meeting
-    // surface all over again to be told so.
-    seen = 0;
-
-    for (const b of sources) {
-      if (b === a) continue;
-
-      const mirror = MIRRORS[seen++];
-      if (!isFinite(mirror) || r >= mirror) continue;
-
-      total += bounced(a, b, x, y, t, reach, when, mirror);
-    }
-  }
-
-  return total;
-};
-
-/**
- * Where space is being destroyed, asked of places rather than of pairs.
- *
- * This is the piece that adding cosines does not give you, and without it the
- * continuous version is not the same physics — it is the same picture with
- * the gravity left out. Two opposite charges meeting in the model do not
- * average to nothing and stay where they are. They ANNIHILATE, and
- * annihilating takes the point each of them was on out of the world, which
- * leaves whatever was on either side of them nearer together. That is the
- * whole of why two magnets attract here: not a force between them, an ongoing
- * loss of the space in between.
- *
- * The first version of this asked the question of a PAIR — walk the line
- * joining two named sources, see how much of what meets there is opposite.
- * It gives the right rate and it is the wrong question, because it is not a
- * question about anywhere. It needs to know which sources exist and which two
- * of them are being considered, and it produces one number for the pair
- * rather than a fact about each place. Nothing built on it can deflect a
- * third thing, because a third thing is not in the sum.
- *
- * Asked of a place, it is local, and everything it needs is at that place.
- * How much of each charge is here; which way each of them is travelling; and
- * therefore how much of what is here is meeting head-on rather than crossing.
- * Two things annihilate when they are opposite in charge AND opposed in
- * direction — one without the other is a crossing, not a collision — so both
- * factors are in it, and both are readable on the spot.
- *
- * What comes out is the field this model puts where mass usually goes:
- * annihilation per unit of space per tick. It is not a property anything has.
- * It is something that happens somewhere.
- */
-const SITES: number[] = [];                       // x, y, eaten, nx, ny, met — six at a time
-let siteCount = 0;
-
-/**
- * How much space a tick's worth of meeting destroys, which is the one number
- * tying the continuous rate to the discrete one.
- *
- * A source emits a shell every tick and shells travel a cell a tick, so along
- * any line between two of them one shell meets one shell every tick, and a
- * meeting of opposites takes two cells out of the world. That is the whole of
- * the rate, and it is a COUNT — one meeting, two cells — with nothing in it
- * about how large the region is where the meeting happens.
- *
- * Which is the thing the survey below cannot supply and must not be asked to.
- * It measures a density, and a density integrated over an area gives a number
- * that grows with the area: two sources far apart overlap over more of the
- * picture than two close together, and reading their annihilation off that
- * integral has them eating faster the further apart they are, which is not
- * merely wrong but backwards. Everything the survey knows is WHERE the eating
- * is happening and along what. How MUCH is set here, by the cadence, and
- * shared out over the places in proportion to what is going on at each.
- *
- * So the survey's numbers are a shape and this is the size of it. The one
- * thing left for the survey to say about magnitude is the share — how much of
- * what meets is opposite rather than alike — which is dimensionless, is
- * between nought and one, and is exactly what it should be reporting: a pair
- * eating all of what they send each other, or half of it, or none.
- */
-const BITE = 2 * LIGHT;
-
-/**
- * And how far the loss of a point is felt, which is not far.
- *
- * A collision removes the two points its charges were on and joins what was
- * behind each directly to the other. That shortens the LINE they were on and
- * does nothing whatever to a point off to the side, which is joined to the
- * world by paths that never went through the collision. So the influence of
- * an annihilation is confined to a neighbourhood of it, and this is the size
- * of that neighbourhood.
- *
- * Which is a real claim and an unusual one. Gravity here is not long-range,
- * and it is not something a mass has and radiates. It acts along the lines
- * where annihilation is actually happening, which is to say between things
- * that are cancelling each other's emissions. A body that emits nothing feels
- * nothing, however much is going on beside it.
- *
- * But it must not be smaller than the grid the annihilation was surveyed on,
- * and that is what it was. A few cells, against sites laid out one every few
- * cells, gives a field that is a row of separate little pushes with nothing
- * between them: a body sitting on the axis is either on top of one, where the
- * transverse falloff is flat because it is at the peak of it, or between two,
- * where there is nothing at all. Either way it feels no gradient, and a body
- * that feels no gradient is never turned — which was the whole complaint. The
- * loss has to be smeared over at least the spacing of the places it was
- * measured at, or what is being drawn is the grid rather than the field.
- */
-let LOCAL = 3;                                    // cells, set by the survey
-
-// How far apart the closest pair are, which is the distance the pull has to
-// work over. Also set by the survey.
-let SPREAD = 1;
-
-/**
- * Survey the framed region for it, once a tick.
- *
- * A coarse grid is enough: what is being looked for is where the annihilation
- * is, and it is spread over the overlap of two fields rather than
- * concentrated at points. Everything below a fraction of the strongest is
- * dropped, because most of any of these pictures is space where nothing is
- * meeting anything and summing a few hundred nothings into every query is the
- * whole cost of this.
- */
-const survey = (live: Live[], t: number, reach: number, span: number) => {
-  const STEPS = 22;
-
-  siteCount = 0;
-  SITES.length = 0;
-
-  if (live.length < 2) return;
-
-  // Centred on the sources, since that is where anything is.
-  let mx = 0, my = 0;
-  for (const s of live) { mx += s.at[0] / live.length; my += s.at[1] / live.length; }
-
-  /**
-   * And it looks at the pair, not at the picture.
-   *
-   * The grid was laid across the whole view, so its cells are a couple of
-   * cells of world across — which is fine while the two are far apart and
-   * useless the moment they are not. A pair three cells apart has the whole
-   * of its encounter inside ONE cell of that grid: the survey finds a site or
-   * two in roughly the right place, or none at all, and the pull collapses
-   * exactly as the two are closing on each other. They drifted together,
-   * slowed for no reason in the model, and stopped short.
-   *
-   * Framed on the pair instead, the resolution follows them down. What is
-   * being measured is where annihilation is happening, and that is between
-   * them, wherever they have got to and however little room it now takes.
-   */
-  let nearest = Infinity;
-
-  for (let i = 0; i < live.length; i++)
-    for (let j = i + 1; j < live.length; j++)
-      nearest = Math.min(nearest, Math.hypot(
-        live[j].at[0] - live[i].at[0], live[j].at[1] - live[i].at[1],
-      ));
-
-  const look = Math.min(span, Math.max(isFinite(nearest) ? nearest * 1.6 : span, 5));
-  const step = (2 * look) / STEPS;
-
-  GRID = STEPS;
-  GRID_STEP = step;
-  GRID_X = mx - look + step / 2;
-  GRID_Y = my - look + step / 2;
-
-  // Wide enough that the sites blend into a field rather than staying a row
-  // of separate pushes, which is what gives it a gradient to turn anything
-  // with. See `LOCAL`.
-  LOCAL = Math.max(step * 2, 1.5);
-  SPREAD = Math.max(isFinite(nearest) ? nearest / 4 : step, 0.75);
-
-  const val: number[] = [];
-  const dirX: number[] = [];
-  const dirY: number[] = [];
-
-  let strongest = 0;
-
-  // What the picture is doing as a whole: how much of what meets is opposite,
-  // and how much meets at all. Their ratio is the only thing about magnitude
-  // the survey has any business reporting.
-  let cancelling = 0, meeting = 0;
-
-  for (let gy = 0; gy < STEPS; gy++) {
-    const y = my - look + (gy + 0.5) * step;
-
-    for (let gx = 0; gx < STEPS; gx++) {
-      const x = mx - look + (gx + 0.5) * step;
-
-      for (let i = 0; i < live.length; i++) {
-        val[i] = emit(live[i], live[i], x, y, t, reach);
-        dirX[i] = WAY[0]; dirY[i] = WAY[1];
-      }
-
-      // What is annihilating here, and what is meeting here at all — which
-      // is more, because alike charges meeting head-on turn around rather
-      // than cancelling, and either way they stop going forwards.
-      let rate = 0, here = 0, nx = 0, ny = 0;
-
-      for (let i = 0; i < live.length; i++) {
-        for (let j = i + 1; j < live.length; j++) {
-          const both = val[i] * val[j];
-
-          // How much of what is here is one field against the other at all,
-          // whichever way round — the denominator of the share.
-          const closing = Math.max(-(dirX[i] * dirX[j] + dirY[i] * dirY[j]), 0);
-          if (closing <= 0) continue;             // crossing, not meeting
-
-          here += Math.abs(both) * closing;
-          meeting += Math.abs(both) * closing;
-
-          // Opposite in charge as well as opposed in direction: annihilation
-          // rather than a bounce.
-          const against = Math.max(-both, 0) * closing;
-          if (against <= 0) continue;
-
-          rate += against;
-
-          // The line they are meeting along, which is the line that shortens.
-          nx += (dirX[i] - dirX[j]) * against;
-          ny += (dirY[i] - dirY[j]) * against;
-        }
-      }
-
-      if (here <= 0) continue;
-
-      cancelling += rate;
-
-      const len = Math.hypot(nx, ny) || 1;
-
-      SITES.push(x, y, rate, nx / len, ny / len, here);
-      siteCount++;
-
-      if (here > strongest) strongest = here;
-    }
-  }
-
-  // Note there is no global reading of how much bounces and how much
-  // annihilates. That question is settled at each meeting by what the two
-  // charges there are, in `bounced` above — a share taken over the whole
-  // picture is an average of a decision, and an average of a decision is not
-  // a thing anything experiences.
-
-  if (!strongest) { SITES.length = 0; siteCount = 0; return; }
-
-  // Thinned to what is worth summing over, and the total kept with it so that
-  // what is dropped is not quietly handed to what is not.
-  const floor = strongest * 0.05;
-  let kept = 0, total = 0;
-
-  let seen = 0;
-
-  for (let k = 0; k < siteCount; k++) {
-    if (SITES[k * 6 + 5] < floor) continue;
-
-    for (let c = 0; c < 6; c++) SITES[kept * 6 + c] = SITES[k * 6 + c];
-
-    total += SITES[kept * 6 + 2];
-    seen += SITES[kept * 6 + 5];
-    kept++;
-  }
-
-  SITES.length = kept * 6;
-  siteCount = kept;
-
-  // The meeting is kept as it was measured — a density, per unit of space,
-  // per tick. Normalising it to a share of the whole encounter, which is what
-  // it used to do, is what made the shadow useless: a wave crossing the gap
-  // met "a fifth of the total" however thick the thing it was crossing, so
-  // the attenuation stopped depending on how much was actually in the way.
-  // What a wave loses is a density times a path, and both of those have to
-  // survive to the place that multiplies them.
-
-  /**
-   * Rebuilt whatever else is true of this tick, and before anything can
-   * return early.
-   *
-   * A shadow is a fact about where the sources are NOW. Left over from the
-   * tick before while they have moved on — which is what happened whenever a
-   * pair was bouncing without annihilating, since there was nothing to scale
-   * and the function gave up before reaching this — it darkens places nothing
-   * is crossing any more, and the picture fills with patches of black that
-   * belong to a configuration that has gone.
-   */
-
-  if (!kept || total <= 0) return;
-
-  /**
-   * And the whole of it scaled to what a tick's meeting actually costs.
-   *
-   * The share is how much of the encounter annihilates rather than bounces,
-   * which is between nought and one and says nothing about how big the
-   * encounter is. Multiplied by `BITE`, that is the space a tick destroys.
-   * Divided out over the sites in proportion to what each is doing, the
-   * distribution stays exactly what was measured and the total stops being an
-   * accident of how much of the picture the two fields happen to overlap in.
-   */
-  const share = meeting > 1e-12 ? cancelling / meeting : 0;
-
-  /**
-   * And the size of it is fixed by what the pair actually do to each other,
-   * not by what the sites happen to add up to.
-   *
-   * A meeting costs two cells: the charge arriving is on a point, the charge
-   * it meets is on the next one, and annihilating is both of them ceasing to
-   * be anywhere. One meeting a tick, so two cells a tick, times the share of
-   * the encounter that is opposite rather than alike. That is the whole rate
-   * and it is a count — it does not know or care how the annihilation is
-   * spread about.
-   *
-   * Scaling the SITES to sum to it is not the same thing and was the error.
-   * What a source is moved by is not the sum of the sites, it is the flow it
-   * stands in — the sum after each site's reach has fallen away across the
-   * distance and off to the side. Most of it never arrives. So the sites
-   * summed to two cells a tick and the pair closed at a fifth of one, and
-   * every picture of two things attracting was running at a fraction of the
-   * rate the rule gives, with the fraction set by how the survey's kernels
-   * happened to overlap.
-   *
-   * Measured at the sources instead: lay the sites down at whatever relative
-   * strengths they were found with, ask how fast the gap between the pair is
-   * closing under that, and scale the lot until the answer is two cells a
-   * tick. Then the shape is the survey's and the size is the rule's, which is
-   * the right division of labour between the two.
-   */
-  for (let k = 0; k < kept; k++) SITES[k * 6 + 2] /= total;
-
-  let closes = 0;
-
-  for (let i = 0; i < live.length; i++) {
-    for (let j = i + 1; j < live.length; j++) {
-      const a = live[i], b = live[j];
-
-      let ux = b.at[0] - a.at[0], uy = b.at[1] - a.at[1];
-      const apart = Math.hypot(ux, uy);
-      if (apart < 1e-6) continue;
-
-      ux /= apart; uy /= apart;
-
-      flowAt(a.at[0], a.at[1]);
-      const ain = FLOW[0] * ux + FLOW[1] * uy;
-
-      flowAt(b.at[0], b.at[1]);
-      const bin = -(FLOW[0] * ux + FLOW[1] * uy);
-
-      closes += ain + bin;
-    }
-  }
-
-  if (closes <= 1e-9) return;
-
-  const want = BITE * share;
-
-  for (let k = 0; k < kept; k++) SITES[k * 6 + 2] *= want / closes;
-};
-
-// The optical-depth shadow that used to live here is gone. A wave is not
-// thinned by what it passes through — it stops dead at the first thing it
-// meets, which is `meets` above — so there was nothing left for it to say,
-// and it was still being rebuilt over the whole grid every tick.
-
-/**
- * The flow of space, which is where gravity actually is.
- *
- * Each place that is destroying space draws what is around it inwards along
- * the line the collision there is happening on: everything on one side comes
- * one way, everything on the other side comes the other, and a point off to
- * the side barely moves at all. Summed over everywhere that is doing it, that
- * is the whole field, and nothing in the sum knows about sources or pairs —
- * only about places and what is happening at them.
- *
- * And there is the deflection, for free and without a force anywhere. The
- * flow has a gradient, so it does not merely carry a body — it turns it. A
- * velocity is a displacement per tick, and a displacement in a space that is
- * being sheared comes out pointing somewhere else. Nothing accelerates: the
- * body's own motion is untouched and its speed never changes. It is carried,
- * and what carries it is not uniform.
- */
-/**
- * The space itself, kept between ticks, and how fast it is going.
- *
- * Everything before this treated gravity as a speed: work out where
- * annihilation is happening, work out how fast that drags each source, move
- * it that far, throw the answer away and do it again next tick. Which cannot
- * be right, and the discrete rule says why. `annihilate` does not push
- * anything. It rewires — the point behind one dying charge is spliced
- * directly onto the point behind the other — and it STAYS rewired. The state
- * is in the space, not in the bodies, and a speed recomputed from scratch
- * every tick is precisely a model with no state in the space at all.
- *
- * So the space gets a displacement of its own, `h`, which is how far each
- * place has been carried from where it started, and it is kept. Annihilation
- * adds to it and nothing takes it away: once the ground between two things
- * has gone, it has gone, and they are nearer whether or not anything is still
- * eating.
- *
- * And `h` is given a wave equation rather than being applied where it is
- * made. A contraction here has to reach a place over there, and it has to
- * take the time light takes — so the field obeys
- *
- *     d²h/dt² = c² ∇²h + S
- *
- * with S the annihilation. Ripples in `h` then travel outward at exactly c,
- * which is what a gravitational wave is: not a thing added to the model, but
- * what persistence and a finite speed give you together the moment you stop
- * applying the answer instantly and everywhere. Neither alone produces one.
- *
- * A grid fixed for the whole run, unlike the survey's, which re-frames on the
- * pair every tick. A field that is carried from one tick to the next cannot
- * be resampled onto a moving grid without smearing everything it remembers.
- */
-type Warp = {
-  hx: Float32Array; hy: Float32Array;             // where each place has got to
-  vx: Float32Array; vy: Float32Array;             // and how fast it is going
-  sx: Float32Array; sy: Float32Array;             // what is driving it this tick
-  n: number; x0: number; y0: number; step: number;
-};
-
-const warp = (span: number): Warp => {
-  // Forty across is enough to carry a wave and cheap enough to ask the
-  // calibrated flow at every one of its places, once a tick.
-  const n = 40;
-  const step = (2 * span) / n;
-
-  return {
-    hx: new Float32Array(n * n), hy: new Float32Array(n * n),
-    vx: new Float32Array(n * n), vy: new Float32Array(n * n),
-    sx: new Float32Array(n * n), sy: new Float32Array(n * n),
-    n, x0: -span, y0: -span, step,
-  };
-};
-
-// Read between the grid's places, since it is asked at arbitrary points.
-const WARP: [number, number] = [0, 0];
-
-const warpAt = (w: Warp, a: Float32Array, b: Float32Array, x: number, y: number) => {
-  const fx = Math.min(Math.max((x - w.x0) / w.step, 0), w.n - 1.001);
-  const fy = Math.min(Math.max((y - w.y0) / w.step, 0), w.n - 1.001);
-
-  const i = Math.floor(fx), j = Math.floor(fy);
-  const u = fx - i, v = fy - j;
-
-  const k = j * w.n + i;
-
-  WARP[0] = (a[k] * (1 - u) + a[k + 1] * u) * (1 - v)
-    + (a[k + w.n] * (1 - u) + a[k + w.n + 1] * u) * v;
-  WARP[1] = (b[k] * (1 - u) + b[k + 1] * u) * (1 - v)
-    + (b[k + w.n] * (1 - u) + b[k + w.n + 1] * u) * v;
-};
-
-/**
- * One step of it.
- *
- * The annihilation found this tick is laid down as the source term — the same
- * shape `flowAt` used to hand straight to the sources, put into the field
- * instead — and then the field is left to carry it. The Laplacian is the
- * plain five-point one, which is all a wave equation on a grid needs, and the
- * time step is a fraction of a cell against a speed of one, so it is nowhere
- * near the limit where that would misbehave.
- *
- * A little damping, because nothing here should ring for ever: an annihilation
- * that has finished leaves its displacement behind, which is the point, but
- * the SPEED it left the space with has to die away or the picture keeps
- * sloshing long after anything is happening.
- */
-const warpStep = (w: Warp, dt: number) => {
-  const { hx, hy, vx, vy, sx, sy, n, step } = w;
-
-  /**
-   * What the space would be doing here if the annihilation acted at once,
-   * which is what the survey has already been calibrated to give.
-   *
-   * Used as the speed the field is DRAWN TOWARDS rather than as a force added
-   * to it — which keeps the one number that ties this to the discrete rule.
-   * `survey` scales the sites so that a pair whose every meeting cancels
-   * would close at two cells a tick, and if that were integrated as an
-   * acceleration the speed would simply grow past it and the calibration
-   * would mean nothing. Relaxed towards, the near field settles at exactly
-   * the rate the rule gives, and everything the wave equation adds is what
-   * happens on the way there and further out.
-   */
-  for (let j = 0; j < n; j++) {
-    for (let i = 0; i < n; i++) {
-      const k = j * n + i;
-
-      flowAt(w.x0 + i * step, w.y0 + j * step);
-
-      sx[k] = FLOW[0]; sy[k] = FLOW[1];
-    }
-  }
-
-  // A step of the wave equation: the Laplacian carries it, at exactly the
-  // speed of light in the units everything else here is in.
-  const c2 = LIGHT * LIGHT / (step * step);
-  const pull = 2.5;
-
-  for (let j = 1; j < n - 1; j++) {
-    for (let i = 1; i < n - 1; i++) {
-      const k = j * n + i;
-
-      const lx = hx[k - 1] + hx[k + 1] + hx[k - n] + hx[k + n] - 4 * hx[k];
-      const ly = hy[k - 1] + hy[k + 1] + hy[k - n] + hy[k + n] - 4 * hy[k];
-
-      vx[k] += (c2 * lx + (sx[k] - vx[k]) * pull) * dt;
-      vy[k] += (c2 * ly + (sy[k] - vy[k]) * pull) * dt;
-    }
-  }
-
-  // And the displacement keeps what the speed has given it. Nothing takes it
-  // back: once the ground has gone it has gone.
-  for (let k = 0; k < hx.length; k++) { hx[k] += vx[k] * dt; hy[k] += vy[k] * dt; }
-};
-
-/**
- * How steeply the ground falls away here.
- *
- * The flow has exactly one scalar in it — how fast the space is going — and
- * the slope of half its square is where everything else comes from. That is
- * not a choice: a flow which is the gradient of something obeys
- * `(u . grad) u = grad(|u|^2 / 2)`, and `(u . grad) u` is what a thing sitting
- * still in the coordinates is carried by as the flow it is standing in
- * accelerates. So the slope of `|u|^2 / 2` IS the free-fall acceleration, and
- * it is the same quantity Newton called the gradient of a potential — a river
- * running in at `sqrt(2M/r)` has half its square equal to `M/r` exactly.
- *
- * Which means nothing here is imported. The rule is still that annihilation
- * takes two cells out of the space between whatever is annihilating. The flow
- * is what that does to the space. And a falloff nobody put in — the whole
- * inverse-square of it — is sitting in that flow already, waiting to be
- * differentiated.
- *
- * Read over three quarters of a cell either side, which is wide enough to see
- * past the survey's own grid and narrow enough to still be local.
- */
-const NUDGE = 0.75;
-
-const river = (w: Warp, x: number, y: number) => {
-  warpAt(w, w.vx, w.vy, x, y);
-
-  return (WARP[0] * WARP[0] + WARP[1] * WARP[1]) / 2;
-};
-
-const FALL: [number, number] = [0, 0];
-
-const fallAt = (w: Warp, x: number, y: number) => {
-  FALL[0] = -(river(w, x + NUDGE, y) - river(w, x - NUDGE, y)) / (2 * NUDGE);
-  FALL[1] = -(river(w, x, y + NUDGE) - river(w, x, y - NUDGE)) / (2 * NUDGE);
-};
-
-/**
- * What movement itself does to the space it is moving through.
- *
- * `consumeAhead` is a SWAP: the ray takes the point in front of it and that
- * point ends up behind. So anything going anywhere is laying space down
- * behind itself at exactly the rate it takes it up in front, one cell for
- * every cell it goes — and the space it crosses is not merely crossed, it is
- * carried from one end of the thing to the other.
- *
- * Which is the other half of what happens between two sources. The
- * annihilation between them takes space OUT and draws them together. The
- * motion of each puts space BACK, behind it, and pushes them apart. Where
- * those balance is where a pair neither closes nor escapes.
- *
- * Two things about how this is written, and both were got wrong first.
- *
- * It is never its own. A thing does not feel its own wake: the taking in
- * front and the laying behind are not two forces on it that happen to cancel
- * — they are what its moving IS, and `vel` already counts them. Put on the
- * grid with everything else, where there is no way to ask whose wake a place
- * is in, each source read its own and got a shove forward of about two thirds
- * of its own pace on top of its own pace, every tick, compounding through the
- * field. That is a rocket, and it showed as sources tearing away in the
- * direction they were already going.
- *
- * And it is retarded, off the same trail `emit` uses. A wake is news, and
- * news travels at one cell a tick like everything else here.
- */
-const WAKE: [number, number] = [0, 0];
-
-// How far in front the taking happens and how far behind the laying: one
-// point either side, in a lattice whose points are one apart.
-const SWAP = 0.5;
-
-const wakeAt = (s: Live, x: number, y: number, t: number) => {
-  WAKE[0] = 0; WAKE[1] = 0;
-
-  const when = retard(s, x, y, t);
-  if (!isFinite(when)) return;
-
-  wasGoing(s, when);
-
-  const px = RETARD[0], py = RETARD[1];
-  const pace = Math.hypot(CARRY[0], CARRY[1]);
-  if (pace < 1e-9) return;
-
-  const ax = CARRY[0] / pace, ay = CARRY[1] / pace;
-
-  // A point of space being made pushes what is around it away; a point being
-  // taken up draws it in. Movement is one of each, half a cell apart, and far
-  // off the two very nearly cancel — which is exactly right, and is why a
-  // swap is not a source of anything. Near to, they do not.
-  for (let k = 0; k < 2; k++) {
-    const side = k ? -SWAP : SWAP;
-    const sign = k ? 1 : -1;
-
-    const ex = x - (px + ax * side), ey = y - (py + ay * side);
-
-    const r = Math.hypot(ex, ey);
-    if (r < SWAP) continue;
-
-    WAKE[0] += sign * pace * ex / (r * 2 * Math.PI * r);
-    WAKE[1] += sign * pace * ey / (r * 2 * Math.PI * r);
-  }
-};
-
-const FLOW: [number, number] = [0, 0];
-
-const flowAt = (x: number, y: number) => {
-  FLOW[0] = 0; FLOW[1] = 0;
-
-  for (let k = 0; k < siteCount; k++) {
-    const sx = SITES[k * 6], sy = SITES[k * 6 + 1];
-    const q = SITES[k * 6 + 2];
-    const nx = SITES[k * 6 + 3], ny = SITES[k * 6 + 4];
-
-    const ex = x - sx, ey = y - sy;
-
-    const on = ex * nx + ey * ny;
-    const off = ex * -ny + ey * nx;
-
-    /**
-     * Everything on one side comes one way and everything on the other comes
-     * the other, so the line through it is shorter by `q` and the place
-     * itself does not move.
-     *
-     * Saturating over the distance the pair are apart, not over the size of
-     * the picture. Tied to the picture, the pull quietly gave out exactly
-     * when it should have been strongest: a pair a few cells apart has every
-     * site a few cells from each of them, and `tanh` of a few cells over a
-     * width set by the whole view is almost nothing — so they drifted
-     * together, slowed, and stopped short of touching for no reason in the
-     * model at all.
-     */
-    const side = Math.tanh(on / SPREAD);
-    const fade = Math.exp(-((off / LOCAL) ** 2));
-
-    FLOW[0] -= (q / 2) * side * fade * nx;
-    FLOW[1] -= (q / 2) * side * fade * ny;
-  }
-
-  /**
-   * And no place of space goes faster than light, whatever the sites add up
-   * to.
-   *
-   * Not a safety rail — it is the same rule everything else here obeys, and
-   * without it the calibration in `survey` has a hole in it. That divides by
-   * how fast the sites it found happen to close the pair, and when the two
-   * are nearly touching, or arranged so that what is being eaten is mostly
-   * off to the side of the line between them, the measured closing goes to
-   * almost nothing while the rate the rule asks for does not. The quotient
-   * runs away. Measured on the fly-by that pulses every fifth tick, the flow
-   * carrying a source reached three hundred and fifty thousand cells a tick
-   * and the pair were flung four hundred cells apart in forty.
-   *
-   * Held to light, the same arrangement simply closes as fast as anything can
-   * close and no faster. The pair still meet, the gap still goes at two cells
-   * a tick between them, and the number that used to be unbounded is now the
-   * one bound this whole model has.
-   */
-  const going = Math.hypot(FLOW[0], FLOW[1]);
-
-  if (going > LIGHT) { FLOW[0] *= LIGHT / going; FLOW[1] *= LIGHT / going; }
-};
-
-// A 4x4 ordered pattern, centred on nought and worth about one level of an
-// eight-bit channel. See the use below.
-const DITHER = [
-  0, 8, 2, 10,
-  12, 4, 14, 6,
-  3, 11, 1, 9,
-  15, 7, 13, 5,
-].map(v => (v / 16) - 0.5);
-
-/**
- * One canvas of it, evaluated rather than simulated.
- *
- * Every sample is independent of every other, so there is no state to carry
- * between frames and nothing to ease: the drawn field IS the field, at
- * whatever real-valued t the clock has reached. Which is the visible payoff
- * of having a function rather than a run — the animation above has to walk
- * towards each tick because the world only exists at whole ones, and this
- * one is simply continuous, so it moves the way a wave moves.
- *
- * Drawn small and stretched. The field has no detail below the scale of its
- * own bands, so sampling it at every pixel is spending several times over
- * for a picture that is smooth by construction; a quarter-scale buffer drawn
- * up with the canvas's own interpolation is the same image for a sixteenth
- * of the arithmetic.
- */
-const ContinuousField = ({
-  sources,
-  height = 320,
-  span = 14,
-  rate = 10,
-  cycle = 200,
-}: {
-  sources: Emitter[];
-
-  // How much of the world is on screen, as a radius in cells.
-  span?: number;
-
-  // Ticks a second, and it need not be a whole number of anything.
-  rate?: number;
-
-  // Ticks before it starts again from the beginning. A pair that closes on
-  // each other ends up adjacent and then has nothing left to do — neither is
-  // space, so neither can be moved through, and adjacent is as close as
-  // adjacent gets. Watching that happen is the point; watching it having
-  // happened is not.
-  cycle?: number;
-
-  height?: number;
-}) => {
-  const canvasRef = useRef<HTMLCanvasElement | null>(null);
-  const latest = useRef({ sources, span, rate, cycle });
-  latest.current = { sources, span, rate, cycle };
-
-  useEffect(() => {
-    const canvas = canvasRef.current!;
-    const ctx = canvas.getContext("2d")!;
-
-    // The small buffer the field is evaluated into, before being drawn up to
-    // the size of the canvas.
-    const buf = document.createElement("canvas");
-    const bufCtx = buf.getContext("2d")!;
-
-    let img: ImageData | null = null;
-
-    let raf = 0;
-    let seen = false;
-    let t = 0;
-    let last = performance.now();
-
-    // Where the sources have got to. The ones handed in say where they start,
-    // and nothing about where they stay.
-    let live: Live[] = [];
-
-    let field = warp(latest.current.span);
-
-    const reset = () => {
-      t = 0;
-      field = warp(latest.current.span);
-      live = latest.current.sources.map(s => ({
-        ...s,
-        at: [...s.at] as [number, number],
-        path: [s.at[0], s.at[1]],
-        vel: [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number],
-      }));
-    };
-
-    // Everywhere each of them has been, kept up to the moment. Filled to the
-    // current time rather than appended to once per frame, so the record is
-    // evenly spaced whatever the frame rate happens to be doing.
-    const remember = () => {
-      for (const s of live) {
-        for (let k = s.path.length / 2; k <= t / TRAIL; k++) {
-          s.path.push(s.at[0], s.at[1]);
-        }
-      }
-    };
-
-    reset();
-
-
-
-    function resize() {
-      const parent = canvas.parentElement!;
-      const w = parent.clientWidth, h = parent.clientHeight;
-      const ratio = window.devicePixelRatio || 1;
-
-      canvas.width = w * ratio;
-      canvas.height = h * ratio;
-      canvas.style.width = w + "px";
-      canvas.style.height = h + "px";
-
-      // Everything below draws in css pixels; the field's own buffer is
-      // coarser than either and gets stretched over the top.
-      ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
-    }
-
-    function draw() {
-      const { span } = latest.current;
-      const sources = live;
-      const w = canvas.clientWidth, h = canvas.clientHeight;
-      if (!w || !h) return;
-
-      /**
-       * Css pixels to a sample, and it cannot be one number.
-       *
-       * What has to be resolved is a band, and a band is `CYCLE/2` cells of
-       * world however the view is set — so how many pixels it covers depends
-       * entirely on how far out the camera is. A single source framed at
-       * fourteen cells gives a band forty-odd pixels and four pixels a sample
-       * is plenty. The same four pixels against a pair framed at sixty gives a
-       * band ten pixels wide and two and a half samples across it, which is
-       * under what it takes to see a wave at all: what gets drawn there is not
-       * a coarse version of the field, it is the moiré of a grid beating
-       * against one, and no amount of smoothing afterwards recovers it.
-       *
-       * So the sampling follows the bands rather than the screen. Five or so to
-       * a band everywhere, which is what the wide views were missing and what
-       * the close ones were spending several times over.
-       */
-      const bandPx = (CYCLE / 2) * (Math.min(w, h) / (2 * Math.max(span, 1)));
-
-      const SAMPLE = Math.max(Math.min(bandPx / 5, 4), 1.4);
-
-      const cols = Math.max(Math.round(w / SAMPLE), 1);
-      const rows = Math.max(Math.round(h / SAMPLE), 1);
-
-      if (buf.width !== cols || buf.height !== rows) {
-        buf.width = cols; buf.height = rows;
-        img = null;
-      }
-
-      // Asked for once and written over ever after. At this sampling it is a
-      // hundred thousand pixels a frame, and handing that back to be
-      // collected sixty times a second is most of what the drawing would
-      // otherwise cost.
-      if (!img) img = bufCtx.createImageData(cols, rows);
-
-      const px = img.data;
-
-      // Cells to the shorter side of the picture, so the same world is framed
-      // whatever shape the canvas is.
-      const scale = Math.min(w, h) / (2 * span);
-      const reach = span * 0.6;
-
-      for (let y = 0; y < rows; y++) {
-        const wy = ((y + 0.5) * (h / rows) - h / 2) / scale;
-
-        for (let x = 0; x < cols; x++) {
-          const wx = ((x + 0.5) * (w / cols) - w / 2) / scale;
-
-          const v = Math.max(Math.min(fieldAt(wx, wy, t, sources, reach), 1), -1);
-
-          /**
-           * Amber one way, cyan the other, and the background where the two
-           * meet — so a seam is a dark channel and needs no line drawn on it.
-           *
-           * Shown at the strength it actually has, which it was not. A gamma
-           * of about a half lifts the faint parts of a picture towards the
-           * bright ones, and here that is a lie with consequences: a wave
-           * thinned to a hundredth of itself by distance and by everything it
-           * has crossed was being drawn at a fifth, so the outer half of
-           * every picture looked like a place where something was happening.
-           * It is not. Gravity here goes as the product of two waves meeting,
-           * so it falls away faster than either of them does — and if the
-           * waves are drawn brighter than they are, the eye is being told the
-           * opposite of the truth about where anything can still act.
-           *
-           * Straight through, then. What is visible is what is there, and
-           * where the picture goes dark is where the two have nothing left to
-           * do to each other.
-           */
-          const k = Math.abs(v);
-          const i = (y * cols + x) * 4;
-
-          /**
-           * And a little noise added before it is rounded to a byte.
-           *
-           * The field is smooth and the colours it maps to are eight bits, so
-           * a gradient that takes two hundred pixels to go from one shade to
-           * the next has a hard edge every two hundred pixels — a set of
-           * contour lines nothing asked for, which read as the picture being
-           * coarse when what is coarse is only the counting. Half a level of
-           * dither, from a fixed pattern rather than from a random number so
-           * that a still frame is stable, turns each of those edges into a
-           * scatter that averages to the right value and has no edge in it.
-           */
-          const d = DITHER[(y & 3) * 4 + (x & 3)];
-
-          px[i] = 6 + (v > 0 ? 249 : 55) * k + d;
-          px[i + 1] = 7 + (v > 0 ? 115 : 213) * k + d;
-          px[i + 2] = 12 + (v > 0 ? 57 : 243) * k + d;
-          px[i + 3] = 255;
-        }
-      }
-
-      bufCtx.putImageData(img, 0, 0);
-
-      ctx.fillStyle = "#06070c";
-      ctx.fillRect(0, 0, w, h);
-
-      ctx.imageSmoothingEnabled = true;
-      ctx.drawImage(buf, 0, 0, w, h);
-
-      // The sources, in the same yellow they are given above.
-      for (const s of sources) {
-        const sx = w / 2 + s.at[0] * scale, sy = h / 2 + s.at[1] * scale;
-
-        const halo = ctx.createRadialGradient(sx, sy, 0, sx, sy, 14);
-        halo.addColorStop(0, "rgba(255,214,66,0.85)");
-        halo.addColorStop(0.35, "rgba(255,186,40,0.3)");
-        halo.addColorStop(1, "rgba(255,186,40,0)");
-
-        ctx.fillStyle = halo;
-        ctx.beginPath();
-        ctx.arc(sx, sy, 14, 0, Math.PI * 2);
-        ctx.fill();
-
-        ctx.fillStyle = "#FFE066";
-        ctx.beginPath();
-        ctx.arc(sx, sy, 2.2, 0, Math.PI * 2);
-        ctx.fill();
-      }
-    }
-
-    /**
-     * And everything is carried by the flow of the space it is in.
-     *
-     * Three things, in this order, and the order says what the model claims.
-     * A source goes on going the way it was going, because nothing here
-     * accelerates anything. The space it is in is carried by `flowAt`,
-     * wherever annihilation is shortening it. And the source's own direction
-     * is turned by how steeply that flow falls away — not by being pushed,
-     * but because a straight line through ground that is running downhill
-     * across it does not stay straight.
-     *
-     * The turning is `fallAt`, taken across the direction of travel only, so
-     * that a change of direction is all it can ever be. Nothing here changes
-     * speed.
-     *
-     * They stop when they are adjacent, which is not a fudge to keep them
-     * apart: a source is not space, so there is nothing left between them to
-     * annihilate and nothing either could move through if there were.
-     */
-    const TOUCH = 1;                              // as close as adjacent gets
-
-    function pull(dt: number) {
-      const span = latest.current.span;
-      const reach = span * 0.6;
-
-      // Where space is going, worked out once for the whole picture. After
-      // this nothing asks about sources again — only about places.
-      survey(live, t, reach, span);
-
-      // What the annihilation does to the space, carried forward and let
-      // travel. See `warpStep` — this is where gravity now lives.
-      warpStep(field, dt);
-
-      /**
-       * And what each source is carried by is the SPEED of the space it is
-       * standing in, not the annihilation happening elsewhere at this moment.
-       *
-       * Which is the whole difference. A contraction over there reaches here
-       * when the wave carrying it does, and having arrived it leaves this
-       * place displaced for good — so a source goes on being where the space
-       * put it after the eating has stopped, and feels nothing at all from an
-       * annihilation whose news has not yet arrived.
-       */
-      const carry = live.map(s => {
-        warpAt(field, field.vx, field.vy, s.at[0], s.at[1]);
-
-        let cx = WARP[0], cy = WARP[1];
-
-        // And what the others have laid down behind them. Never its own —
-        // see `wakeAt`.
-        for (const o of live) {
-          if (o === s) continue;
-
-          wakeAt(o, s.at[0], s.at[1], t);
-
-          cx += WAKE[0]; cy += WAKE[1];
-        }
-
-        return [cx, cy] as [number, number];
-      });
-
-      const turned = live.map(s => {
-        /**
-         * Turned by the slope of the ground, and only across the way it is
-         * going.
-         *
-         * The part of that slope pointing along the direction of travel is
-         * dropped before anything is added, which is what keeps this a
-         * turning and not a pull. Renormalising afterwards would have hidden
-         * the difference and did: what used to be here took the flow's change
-         * along the line of travel, which for a river running straight in is
-         * a change of length and no change of angle at all, and then handed
-         * that length to the renormalisation to be thrown away. Measured, it
-         * delivered a hundredth of what an orbit needs and most of that
-         * parallel — so a pair sent past each other flew past each other, the
-         * line between them swung forty degrees the way any two things
-         * passing would, and stopped. Which is exactly the complaint: no
-         * orbit, just a flyby with the arithmetic of one.
-         *
-         * Across the direction of travel there is nothing to throw away.
-         * `fallAt` is the free-fall acceleration and a component of it
-         * perpendicular to a velocity can only rotate that velocity — so the
-         * speed is left exactly alone by construction, and the
-         * renormalisation below is now just tidying the second-order error of
-         * a finite step rather than doing the work.
-         */
-        const speed = Math.hypot(s.vel[0], s.vel[1]);
-        if (speed < 1e-9) return s.vel;
-
-        fallAt(field, s.at[0], s.at[1]);
-
-        const hx = s.vel[0] / speed, hy = s.vel[1] / speed;
-        const along = FALL[0] * hx + FALL[1] * hy;
-
-        const vx = s.vel[0] + (FALL[0] - along * hx) * dt;
-        const vy = s.vel[1] + (FALL[1] - along * hy) * dt;
-
-        const now = Math.hypot(vx, vy);
-        if (now < 1e-9) return s.vel;
-
-        return [vx * speed / now, vy * speed / now] as [number, number];
-      });
-
-      for (let i = 0; i < live.length; i++) {
-        const s = live[i];
-
-        s.vel = turned[i];
-
-        s.at[0] += (s.vel[0] + carry[i][0]) * dt;
-        s.at[1] += (s.vel[1] + carry[i][1]) * dt;
-      }
-
-      // Not through one another: a source is not space.
-      for (let i = 0; i < live.length; i++) {
-        for (let j = i + 1; j < live.length; j++) {
-          const a = live[i], b = live[j];
-
-          const dx = b.at[0] - a.at[0], dy = b.at[1] - a.at[1];
-          const gap = Math.hypot(dx, dy);
-          if (gap >= TOUCH || gap < 1e-9) continue;
-
-          const back = (TOUCH - gap) / 2;
-          const ux = dx / gap, uy = dy / gap;
-
-          a.at[0] -= ux * back; a.at[1] -= uy * back;
-          b.at[0] += ux * back; b.at[1] += uy * back;
-        }
-      }
-
-      /**
-       * And the trail is NOT carried with it, which is the whole of what
-       * makes any of this local.
-       *
-       * It was, and the argument for it sounded right: a ring is centred
-       * where its source was when it left, that place is in the space too,
-       * and if the space is going then so is everywhere in it. What that
-       * argument misses is that the trail is not a set of places. It is a
-       * RECORD of where something was at a moment, and a record that gets
-       * amended is not a record of anything.
-       *
-       * Amended every frame, every position in it drifts a little further
-       * from what was actually the case — so `was` gives a different answer
-       * today than it gave yesterday for the same instant, and every wave in
-       * the air, however old, quietly re-centres itself on the answer. Rings
-       * laid down a hundred ticks ago get up and move because their source
-       * has since been pulled somewhere. Nothing that has already happened
-       * may depend on anything that happened after it, and this was the last
-       * place in the model where it did.
-       */
-    }
-
-    function frame(now: number) {
-      const dt = Math.min((now - last) / 1000, 0.05) * latest.current.rate;
-      last = now;
-
-      t += dt;
-
-      if (t >= latest.current.cycle) reset();
-      else pull(dt);
-
-      remember();
-
-      draw();
-
-      raf = requestAnimationFrame(frame);
-    }
-
-    const stop = () => {
-      if (!raf) return;
-
-      cancelAnimationFrame(raf);
-      raf = 0;
-    };
-
-    const show = (visible: boolean) => {
-      if (visible === seen) return;
-      seen = visible;
-
-      if (visible) {
-        resize();
-        reset();
-        last = performance.now();
-        raf = requestAnimationFrame(frame);
-        return;
-      }
-
-      stop();
-
-      // Both buffers handed back, which between them are the whole of what
-      // this holds on to. There is no state in it besides a clock.
-      canvas.width = 0; canvas.height = 0;
-      buf.width = 0; buf.height = 0;
-      img = null;
-    };
-
-    const onResize = () => { if (seen) resize(); };
-    window.addEventListener("resize", onResize);
-
-    const unwatch = whileOnScreen(canvas, show);
-
-    return () => {
-      unwatch();
-      stop();
-      window.removeEventListener("resize", onResize);
-    };
-  }, []);
-
-  return <div style={{ height }}>
-    <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%" }} />
-  </div>;
-};
-
-// A turn per CYCLE ticks, which is the rate the lattice above comes round at:
-// eight directions to a plane and one step of them a tick.
-const SPIN = (Math.PI * 2) / CYCLE;
-
-/**
- * How far apart a pair starts, and how much of the world is watched.
- *
- * Far, now that the closing is at its real rate. A cell a tick is quick
- * enough that a pair set eight apart — which is what the lattice examples
- * above can afford — is over in eight ticks, and what there is to see is not
- * the arrangement but the end of it. Set forty apart there is time for the
- * two to reach each other, for the fringes between them to establish
- * themselves, and for the closing to be watched as a thing with a rate rather
- * than as a fact about the next frame.
- *
- * Note also what the first stretch of every one of these is: nothing at all
- * happening. Neither source knows the other is there until light has crossed
- * the gap, and until then nothing between them cancels and neither moves.
- * That is not dead time in the animation. It is the model's whole position on
- * action at a distance, which is that there is none.
- */
-const APART = 34;
-const WIDE = 40;
-
-/**
- * And how many ticks each is given before it starts again.
- *
- * Not the same number for both kinds, because they do not have the same
- * amount to do. A lone source never finishes: it is laying down a pattern
- * that goes on getting bigger, and every extra turn of it out towards the rim
- * is another turn there is to see, so it is given a long run. A pair does
- * finish — they reach each other, and adjacent is as close as adjacent gets —
- * so what a long run buys there is a great deal of two sources sitting still.
- * Enough after they arrive to see that they have arrived, and then round
- * again.
- */
-/**
- * And the fly-by's own scale, which is larger than everything else here.
- *
- * `FAR` is far enough that light takes a good while to cross — nothing at all
- * happens for the first fifty-odd ticks of that case, which is the model
- * being honest about there being no action at a distance — and `MISS` is the
- * impact parameter, the distance they would pass at if nothing were eaten.
- * Both are the dials for that one picture: closer or more head-on and it is a
- * collision, further or wider and they are gone before the gap notices them.
- */
-// How far out the three sit from their common centre. Their sides are RING
-// times root three, so light takes about that long to cross between any two
-// of them and nothing at all happens before it has.
-/**
- * How fast a pair has to be going to go round rather than into each other.
- *
- * Measured, and the measurement is the only reason this number is what it is.
- * Sent past each other from twenty-four cells out and run for three hundred
- * and twenty ticks, the line between the pair turns:
- *
- *     0.45c    644 degrees, and then it is gone — the gap reaches 123
- *     0.40c    971 degrees, gap 22 to 53, drifting slowly outwards
- *     0.35c   1088 degrees, gap 16 to 52, three full turns and still going
- *
- * So there is an interval, it is narrow, and this is inside it. Faster and
- * the two are never caught; slower and they are caught at once. Nothing was
- * solved for to find it — the rates that fix it are the source's own pace,
- * the annihilation's two cells a meeting, and what the motion lays back down
- * behind itself, and where those cross is where an orbit is possible.
- */
-const ORBIT = 0.35 * LIGHT;
-
-const RING = 30;
-
-const FAR = 52;
-const MISS = 34;
-const ROOM = 62;
-
-const ALONE_FOR = 260;
-const PAIR_FOR = 200;
-
-const CONTINUOUS_CASES: {
-  name: string, note: string, sources: Emitter[], span?: number, cycle?: number,
-}[] = [
-  {
-    name: 'one magnet, turning',
-    cycle: ALONE_FOR,
-    note: 'lobes = 1, so the field carries an angle and its zero set winds.',
-    sources: [{ at: [0, 0], lobes: 1, omega: SPIN, phase: 0 }],
-  },
-  {
-    name: 'one source, not turning',
-    cycle: ALONE_FOR,
-    note: 'The same expression with the angle taken out: lobes = 0, and rings.',
-    sources: [{ at: [0, 0], lobes: 0, omega: SPIN, phase: 0 }],
-  },
-  {
-    name: 'two magnets, turning the same way',
-    span: WIDE,
-    cycle: PAIR_FOR,
-    note: 'Two congruent spirals, and the first pair here that closes: what '
-      + 'they eat between them is what brings them together.',
-    sources: [
-      { at: [-APART, 0], lobes: 1, omega: SPIN, phase: 0 },
-      { at: [APART, 0], lobes: 1, omega: SPIN, phase: 0 },
-    ],
-  },
-  {
-    name: 'two magnets, turning opposite ways',
-    span: WIDE,
-    cycle: PAIR_FOR,
-    note: 'Mirrored winding, so along the line between them the two arrive in '
-      + 'step and out of step by turns — and close in bursts rather than '
-      + 'steadily, which is the beat showing up as a rate.',
-    sources: [
-      { at: [-APART, 0], lobes: 1, omega: SPIN, phase: 0 },
-      { at: [APART, 0], lobes: 1, omega: -SPIN, phase: 0 },
-    ],
-  },
-  {
-    name: 'two sources, pulsing in step',
-    span: WIDE,
-    cycle: PAIR_FOR,
-    note: 'Rings launched together. They agree on the midline and cancel in '
-      + 'rings either side of it, and it is the cancelling that closes them.',
-    sources: [
-      { at: [-APART, 0], lobes: 0, omega: SPIN, phase: 0 },
-      { at: [APART, 0], lobes: 0, omega: SPIN, phase: 0 },
-    ],
-  },
-  {
-    name: 'two sources, pulsing against each other',
-    span: WIDE,
-    cycle: PAIR_FOR,
-    note: 'Half a cycle apart: the midline is now where they always cancel, '
-      + 'so the same pair closes faster on the same rules.',
-    sources: [
-      { at: [-APART, 0], lobes: 0, omega: SPIN, phase: 0 },
-      { at: [APART, 0], lobes: 0, omega: SPIN, phase: Math.PI },
-    ],
-  },
-
-  /**
-   * One of them, going somewhere.
-   *
-   * Nothing for it to interact with, so nothing about it changes: it travels
-   * at the one speed a source can, and goes on emitting the whole way. What
-   * that shows is the retardation on its own, with no gravity mixed into it.
-   * Every ring it leaves is centred where it was when that ring left, so the
-   * rings ahead of it are crowded together and the ones behind are stretched
-   * apart — the same shape as a Doppler shift, arrived at by nothing more
-   * than a source outrunning some of its own past.
-   */
-  {
-    name: 'one magnet, turning, and moving',
-    cycle: ALONE_FOR,
-    note: 'No second source, so nothing is eaten and nothing bends. The rings '
-      + 'bunch ahead and stretch behind because each was left where it left '
-      + 'from, and the source has gone on.',
-    sources: [{ at: [-12, 0], lobes: 1, omega: SPIN, phase: 0, drift: [PACE, 0] }],
-  },
-
-  /**
-   * Two of them, set going the same way round.
-   *
-   * The one on the left sent up and the one on the right sent down, so the
-   * pair are circulating about the point between them rather than passing
-   * each other. This is the case the lattice version could not really put to
-   * the question — a hundred ticks of a nine-thousand-point ball is a long
-   * wait to find out — and it is the one worth asking, because it is where
-   * gravity that is only ever a shortening of a gap either does or does not
-   * come out looking like an orbit.
-   *
-   * What to watch is whether the closing keeps up with the carrying. Neither
-   * changes speed, ever; the drift is what it was set to and stays there. So
-   * the only question is whether the space between them is eaten as fast as
-   * their courses take them apart, and the three answers — they wind
-   * together, they part, or they hold — are all legible and none of them is
-   * arranged for.
-   */
-  {
-    name: 'two magnets, turning, with angular momentum',
-    span: WIDE,
-    cycle: PAIR_FOR,
-    note: 'Set going the same way round the middle. Nothing accelerates: what '
-      + 'brings them in is the gap being eaten while they carry on.',
-    sources: [
-      { at: [-APART, 0], lobes: 1, omega: SPIN, phase: 0, drift: [0, PACE] },
-      { at: [APART, 0], lobes: 1, omega: SPIN, phase: 0, drift: [0, -PACE] },
-    ],
-  },
-
-  /**
-   * And two set to miss each other, which is the fly-by, and the one case
-   * here that could come round.
-   *
-   * Given far more room than any of the others, and the room is the point. An
-   * orbit is a thing that needs somewhere to happen: the two have to be far
-   * enough apart that the gap between them survives being eaten for long
-   * enough to be carried round, and close enough passing that there is
-   * anything to carry. Set eight apart, as the lattice examples can afford,
-   * there is no such interval — light crosses, the gap goes, and they are
-   * together before either has been carried anywhere at all.
-   *
-   * The courses are straight and stay straight. Neither source is aimed at
-   * the other; each is sent along x on its own side of the line, so that
-   * left alone they would pass with the whole of `MISS` between them and go
-   * on for ever. What can happen instead is that the ground between them
-   * starts going while they are still crossing it, and the question — a real
-   * one, with a determinate answer nobody has arranged — is whether it goes
-   * fast enough to catch them and slowly enough to leave them anywhere to be
-   * carried to.
-   *
-   * Three outcomes, all legible. They close before they are past each other,
-   * and it is a collision with extra steps. They are past before enough is
-   * gone, and they leave. Or the gap shortens at about the rate their passing
-   * lengthens it, which is the whole of what an orbit is here — noting again
-   * that neither of them ever changes speed, so if this comes round it comes
-   * round without anything being accelerated by anything.
-   */
-  {
-    name: 'two sources, pulsing, passing at a distance',
-    span: ROOM,
-    cycle: PAIR_FOR,
-    note: 'Set to miss each other by a long way. Both courses stay straight; '
-      + 'it is the ground between them that goes.',
-    sources: [
-      { at: [-FAR, -MISS / 2], lobes: 0, omega: SPIN, phase: 0, drift: [PACE, 0] },
-      { at: [FAR, MISS / 2], lobes: 0, omega: SPIN, phase: 0, drift: [-PACE, 0] },
-    ],
-  },
-
-  /**
-   * Two of them pulsing slowly, which is the one that shows how they move.
-   *
-   * Every other pair here emits without pause, so the space between them is
-   * being eaten continuously and they slide together smoothly. Smooth is the
-   * worst possible thing to watch if the question is HOW gravity gets from
-   * one of them to the other, because a smooth pull looks exactly like a
-   * force reaching across the gap, which is what this model says there is no
-   * such thing as.
-   *
-   * Set far apart and pulsing slowly, what it shows instead is the delay,
-   * and it shows it as plainly as anything here can. Nothing whatever
-   * happens for the first thirty-odd ticks — measured, the gap does not move
-   * by a hundredth of a cell — and then the two begin to close. That pause is
-   * not the model waiting for anything. It is light crossing half the gap to
-   * the meeting, and the news of what happened there crossing back, and there
-   * being no other way for either to travel. A force would have started at
-   * once.
-   *
-   * And what arrives does not slide back. The displacement is kept rather
-   * than recomputed, so what the space has given up stays given up: they hold
-   * wherever the last wave left them. Two things are visible in that which no
-   * instantaneous pull can show — that gravity here is CARRIED, and that it
-   * is carried at exactly the speed of the light these things emit.
-   *
-   * What it does not show, and it is worth saying so, is a staircase. The
-   * beat is twelve ticks and the field follows the annihilation more quickly
-   * than that, so the closing comes out smooth rather than as a series of
-   * kicks. Whether the space between two things should shorten in steps or
-   * continuously is a real question about the model, and this arrangement
-   * does not answer it — it only shows that whichever it is, it starts late.
-   */
-  {
-    name: 'two sources, pulsing slowly',
-    span: 34,
-    cycle: PAIR_FOR,
-    note: 'Nothing at all for thirty ticks, and then they close. The pause '
-      + 'is light crossing to the middle and back — a force would not wait.',
-    sources: [
-      { at: [-26, 0], lobes: 0, omega: SPIN, phase: 0, beat: 12 },
-      { at: [26, 0], lobes: 0, omega: SPIN, phase: 0, beat: 12 },
-    ],
-  },
-
-  /**
-   * Two of them that actually go round each other.
-   *
-   * Every other pair in this article either falls together or leaves, and the
-   * reason is a ratio. A source at `PACE` travels at ninety-nine hundredths
-   * of the speed of its own light, so two of them sent past one another part
-   * at nearly two cells a tick — and the space between them goes at two cells
-   * a tick at the very most, when every single thing that arrives cancels.
-   * Set that fast, nothing is ever caught. Set slow with nothing else
-   * changed, everything is caught at once.
-   *
-   * Between the two there is an interval, and `ORBIT` is in it. Run for three
-   * hundred and twenty ticks the pair go round 1088 degrees — three full
-   * turns and part of a fourth — with the gap between them running from 16 at
-   * the tightest to 52 at the widest and neither of them ever leaving the
-   * frame.
-   *
-   * Two things hold it up and they pull opposite ways.
-   *
-   * The annihilation between them takes space out, and that is what draws
-   * them in. Measured with a pair held still and the field let settle, what
-   * it comes to at each of them is 0.03 cells a tick at a gap of 8, 0.16 at
-   * 24 and 0.40 at 32 — which is worth stopping on, because it goes the wrong
-   * way round. This is not Newton's pull, getting weaker with distance. It
-   * gets STRONGER with distance, like a spring, and that is a consequence of
-   * the rule rather than a choice: a meeting costs two cells however far
-   * apart the two things meeting are, so what varies with the gap is not the
-   * cost but how much of each field is in the other's way. A pull shaped like
-   * that has bound orbits everywhere and unbound ones nowhere, which is
-   * exactly what these runs do.
-   *
-   * And the motion puts space BACK. `consumeAhead` is a swap — a cell taken
-   * in front is a cell laid down behind — so anything going anywhere is
-   * refilling the space it leaves at the rate it leaves it, and that pushes
-   * outwards against the eating. See `WAKE`. It is the smaller of the two by
-   * a long way, and it is not nothing: with it the tightest the pair get is
-   * 22 cells rather than 20, so the floor of the orbit is set by the swap and
-   * the ceiling by the eating.
-   *
-   * What is worth being clear about is what is NOT holding it up. Neither of
-   * these ever changes speed. There is no force here in the sense of a thing
-   * that could push something faster — each carries on at exactly the pace it
-   * was sent, for ever, and `turned` takes the component of the fall ACROSS
-   * the way it is going and throws the rest away before adding anything. What
-   * comes round is the DIRECTION. An orbit here is not a balance of a pull
-   * against an inertia. It is a straight line through ground that keeps
-   * turning under it.
-   *
-   * And that ground takes time to hear about anything, so this is an orbit
-   * with a delay in it — which is why the first thing the two do is get
-   * FURTHER apart, 48 out to 50. They are already moving when the run starts
-   * and nothing can act on them until light has crossed the gap and come
-   * back. They part first, and are caught afterwards.
-   */
-  {
-    name: 'two sources, in orbit',
-    span: 34,
-    cycle: 320,
-    note: 'Sent past each other at a third of light, and they go round — '
-      + 'nearly three times. Neither ever changes speed; only the direction '
-      + 'comes round, because the ground it is crossing falls away.',
-    sources: [
-      { at: [-24, 0], lobes: 0, omega: SPIN, phase: 0, drift: [0, ORBIT] },
-      { at: [24, 0], lobes: 0, omega: SPIN, phase: 0, drift: [0, -ORBIT] },
-    ],
-  },
-
-  /**
-   * The same thing, but nothing about it set up to work.
-   *
-   * The pair above is a construction: two identical sources, mirrored, sent
-   * exactly across the line between them at exactly the same pace, so that
-   * whatever holds them has a symmetry to hold. That is the honest way to
-   * show a mechanism and a poor way to show that it is real, because a
-   * balance which only exists on the axis of a symmetry is usually the
-   * symmetry and not the balance.
-   *
-   * So: magnets rather than plain sources, which means `lobes = 1` and a
-   * field that carries an angle and winds. Turning opposite ways, so there is
-   * no rotational symmetry either. Different paces — one at `ORBIT` and one
-   * half again as fast — and different distances out, so the centre of the
-   * thing is nowhere in particular. And neither of them aimed across the line
-   * between them: both are sent off at an angle to it.
-   *
-   * Nothing here is solved for. What it has in common with the pair above is
-   * only that both speeds are in the interval `ORBIT` names, and that is the
-   * whole claim being made — that the interval is a property of the rules and
-   * not of the arrangement.
-   */
-  {
-    name: 'two magnets, mixed speeds, in orbit',
-    span: 40,
-    cycle: 320,
-    note: 'Different speeds, different distances out, winding opposite ways '
-      + 'and neither sent square to the line between them. It still goes '
-      + 'round, which is the point.',
-    sources: [
-      {
-        at: [-20, -6], lobes: 1, omega: SPIN, phase: 0,
-        drift: [ORBIT * 0.34, ORBIT * 0.94] as [number, number],
-      },
-      {
-        at: [26, 4], lobes: 1, omega: -SPIN, phase: Math.PI / 3,
-        drift: [-ORBIT * 1.5 * 0.42, -ORBIT * 1.5 * 0.91] as [number, number],
-      },
-    ],
-  },
-
-  /**
-   * Three of them, which is where this stops being arithmetic.
-   *
-   * Nothing in the rules changes. Every pair does exactly what a pair does —
-   * meets head-on, annihilates where opposite and turns round where alike,
-   * and loses the space between them at two cells a tick for as much of the
-   * meeting as cancels. Add a third and not one line of that is different.
-   * What is different is that there are now three gaps going at once, each at
-   * its own rate, and no symmetry left holding any of them.
-   *
-   * Which is the point of putting it here. Two of anything is a special case:
-   * whatever they do, they do it along the one line between them, and the
-   * whole configuration is that line's length. Three have a shape, and the
-   * shape can change — so this is the first arrangement in the article where
-   * the question "what happens" does not have an answer that could have been
-   * worked out from a single number.
-   *
-   * Set going the same way round a common centre, so what they carry is
-   * angular momentum rather than three approaches. Whether that survives the
-   * eating is a real question and it is the same one the pair asked, with the
-   * difference that a pair either closes or does not, and three can shed one
-   * and keep the other two. Nothing here is arranged to produce that. It is
-   * arranged to be legible if it happens.
-   *
-   * Worth watching for two things the pairs cannot show. Each source is
-   * eating with BOTH of the others at once, along two different lines, so
-   * what moves it is a sum of two contractions pointing different ways — and
-   * it will not point at either of them. And a wave leaving one of them meets
-   * whichever of the other two it runs into first, so the surface it stops at
-   * is no longer a plane: it is two planes, and which one applies depends on
-   * the direction it left in.
-   */
-  {
-    name: 'three sources, going round',
-    span: ROOM,
-    cycle: PAIR_FOR,
-    note: 'The same pairwise rule, three times over. Nothing is aimed at '
-      + 'anything; each carries on the way it was sent while the space '
-      + 'between all three of them goes.',
-    sources: [0, 1, 2].map(k => {
-      const turn = Math.PI / 2 + k * (Math.PI * 2) / 3;
-
-      return {
-        at: [RING * Math.cos(turn), RING * Math.sin(turn)] as [number, number],
-        lobes: 0 as const,
-        omega: SPIN,
-        phase: 0,
-        // Tangentially, all the same way round, so the three of them carry a
-        // rotation about the middle rather than three separate approaches.
-        drift: [-PACE * Math.sin(turn), PACE * Math.cos(turn)] as [number, number],
-      };
-    }),
-  },
-
-  /**
-   * And the same three aimed straight at one another.
-   *
-   * The other arrangement of three, and the one that isolates what the
-   * turning was doing. There every source was carrying past the other two
-   * while the ground went, and it was never clear how much of what happened
-   * was the eating and how much was the momentum. Here the momentum is
-   * pointed at the same place the eating is pulling, so the two agree, and
-   * whatever comes out is what these rules do when nothing is working against
-   * them.
-   *
-   * Which makes the arithmetic worth stating in advance, because it is
-   * checkable. Each pair loses two cells a tick for as much of what they send
-   * each other as cancels, so a side of the triangle goes at about a cell a
-   * tick from the eating alone; on top of that the two ends of it are already
-   * closing at nearly two cells a tick under their own steam. And every
-   * source is on two sides at once. The three should arrive together, at the
-   * middle, sooner than any pair in this article manages it.
-   *
-   * The thing to watch for is whether they arrive at a POINT. Three bodies
-   * aimed at one place have every reason to miss it — the least asymmetry in
-   * what each is emitting when puts one of the three gaps ahead of the other
-   * two, that pair closes first, and what was a collapse becomes a pair with
-   * a third thing falling towards it. Nothing here decides which. The phases
-   * are identical and the geometry is exact, so if they do not arrive
-   * together it is because the encounter itself is not stable, and that is a
-   * result rather than a fault.
-   */
-  {
-    name: 'three sources, aimed at each other',
-    span: ROOM,
-    cycle: PAIR_FOR,
-    note: 'The same three, sent inwards instead of round. Momentum and the '
-      + 'loss of space now agree, so nothing is holding them apart.',
-    sources: [0, 1, 2].map(k => {
-      const turn = Math.PI / 2 + k * (Math.PI * 2) / 3;
-
-      return {
-        at: [RING * Math.cos(turn), RING * Math.sin(turn)] as [number, number],
-        lobes: 0 as const,
-        omega: SPIN,
-        phase: 0,
-        // Straight at the middle, which is straight at the other two.
-        drift: [-PACE * Math.cos(turn), -PACE * Math.sin(turn)] as [number, number],
-      };
-    }),
-  },
-
-  /**
-   * Three turning magnets, not sent anywhere.
-   *
-   * The other two threes are about momentum — one carrying round, one aimed
-   * in — and both of them have sides that put out the same charge in every
-   * direction. This one takes the momentum away and gives them poles instead.
-   * Nothing is thrown at anything. The only thing that moves them is the
-   * space between them going, so whatever they end up doing is gravity
-   * unaccompanied, which is the thing the article is actually arguing about.
-   *
-   * And it is the first arrangement here where what each of them presents to
-   * the others is CHANGING. A pulsing source is the same all round, so a pair
-   * of them either cancel or they do not and that stays true. A magnet has a
-   * north and a south, and a turning magnet sweeps them past everything —
-   * so each of the three faces each of the others with something different
-   * every tick, and the three gaps go at three rates that are not only
-   * unequal but keep swapping which is largest.
-   *
-   * All three given the same phase, so they start pointing the same way and
-   * come round together. That is deliberate and it is not the same as facing
-   * each other: a pair with matching axes presents opposite poles across the
-   * gap, permanently, which is why the pair above eats so steadily. Three at
-   * the corners of a triangle cannot all do that with all of the others —
-   * there is no way to orient three things so that every pair is opposed —
-   * and what happens instead is the question. Some of the pairs are eating
-   * and some are bouncing, and which is which comes round with the axes.
-   */
-  {
-    name: 'three magnets, turning',
-    span: ROOM,
-    cycle: PAIR_FOR,
-    note: 'Three of them with poles, coming round together, sent nowhere. '
-      + 'Nothing moves them but the space between them going.',
-    sources: [0, 1, 2].map(k => {
-      const turn = Math.PI / 2 + k * (Math.PI * 2) / 3;
-
-      return {
-        at: [RING * Math.cos(turn), RING * Math.sin(turn)] as [number, number],
-        lobes: 1 as const,
-        omega: SPIN,
-        phase: 0,
-      };
-    }),
-  },
-
-  /**
-   * And the same fly-by again, moving as fast and emitting a fifth as often.
-   *
-   * One pulse every fifth tick, and everything else exactly as above: the
-   * same distance, the same miss, the same speed, the same rules. What
-   * changes is only how often the two have anything to say to each other.
-   *
-   * Which is not a small change, because it is the one term that was making
-   * capture inevitable. A source travels at a third of a cell a tick, and a
-   * pair pulsing every tick has a meeting every tick, each meeting taking two
-   * cells out of the gap. Two cells a tick against a third of one: the eating
-   * was six times quicker than the moving, no amount of distance was going to
-   * outrun it, and every pair above ends up together with the only question
-   * being how long it took.
-   *
-   * A pulse every fifth tick is a meeting every fifth tick, so the gap goes
-   * at two fifths of a cell a tick — and nothing has been slowed down to
-   * achieve it. The two are carried exactly as far as they were. For the
-   * first time in any of these the two rates are within reach of each other,
-   * and the outcome stops being obvious.
-   *
-   * It is worth being clear that nothing here is tuned to produce an orbit.
-   * The beat is a property of the source — how often it lets go of a shell —
-   * and the speed is a property of its mass. Two independent facts about a
-   * thing, whose ratio decides whether it falls in, escapes, or comes round.
-   * Which is the shape of the question every orbiting system asks, arrived at
-   * here with no force anywhere in it.
-   *
-   * There is a second thing this makes visible, which the filled field could
-   * not. With four cells of nothing between one ring and the next, most of
-   * the space between the two sources is space where neither of them has
-   * anything, and the eating happens in bursts as the rings pass through each
-   * other rather than continuously. The gap does not shorten smoothly. It
-   * shortens whenever two shells arrive at the same place, and holds still in
-   * between, which is what a discrete rule looks like when it is still
-   * discrete.
-   */
-  {
-    name: 'the same, pulsing every fifth tick',
-    span: ROOM,
-    cycle: PAIR_FOR,
-    note: 'Moving every tick, emitting every fifth one. A fifth as many '
-      + 'meetings, so the gap goes a fifth as fast — and the two are carried '
-      + 'just as far while it does.',
-    sources: [
-      { at: [-FAR, -MISS / 2], lobes: 0, omega: SPIN, phase: 0, drift: [PACE, 0], beat: 5 },
-      { at: [FAR, MISS / 2], lobes: 0, omega: SPIN, phase: 0, drift: [-PACE, 0], beat: 5 },
-    ],
-  },
-];
-
-// The four states one end of a two-point universe can be in: its polarity,
-// and whether its ray moves into the connection or away from it.
-const SIDE_STATES: PairSide[] = [
-  { polarity: Polarity.Positive, moving: 'towards' },
-  { polarity: Polarity.Positive, moving: 'away' },
-  { polarity: Polarity.Negative, moving: 'towards' },
-  { polarity: Polarity.Negative, moving: 'away' },
-];
-
-// Every combination of those two ends. `j >= i` drops mirror images — a
-// universe and its left-right reflection run identically, so listing both
-// would only duplicate the same experiment. Drop the slice for all 16.
-const PAIRS: { a: PairSide, b: PairSide }[] = SIDE_STATES.flatMap((a, i) =>
-  SIDE_STATES.slice(i).map(b => ({ a, b }))
-);
-
-type Pair = { a: PairSide, b: PairSide };
-
-// Identity of a pair up to mirroring: whichever ordering of its two ends
-// sorts first, since a universe and its reflection are the same experiment.
-const pairKey = ({ a, b }: Pair) => {
-  const end = (s: PairSide) => `${s.polarity}${s.moving}`;
-  const [x, y] = [`${end(a)}|${end(b)}`, `${end(b)}|${end(a)}`];
-  return x < y ? x : y;
-};
-
-// The anti-universe: every polarity flipped, every movement direction kept.
-const anti = ({ a, b }: Pair): Pair => {
-  const flip = (s: PairSide): PairSide => ({
-    polarity: s.polarity === Polarity.Positive ? Polarity.Negative : Polarity.Positive,
-    moving: s.moving,
-  });
-
-  return { a: flip(a), b: flip(b) };
-};
-
-// Pairs grouped with their own anti-pair, so the two sit one above the other.
-// Head-on opposite polarities (and away-from-each-other opposite polarities)
-// are their own anti up to mirroring, so those groups hold a single pair.
-const ANTI_GROUPS: Pair[][] = (() => {
-  const byKey = new Map(PAIRS.map(p => [pairKey(p), p]));
-  const taken = new Set<string>();
-  const groups: Pair[][] = [];
-
-  for (const pair of PAIRS) {
-    const key = pairKey(pair);
-    if (taken.has(key)) continue;
-    taken.add(key);
-
-    const group = [pair];
-
-    const opposite = pairKey(anti(pair));
-    if (!taken.has(opposite) && byKey.has(opposite)) {
-      taken.add(opposite);
-      group.push(byKey.get(opposite)!);
-    }
-
-    groups.push(group);
-  }
-
-  return groups;
-})();
-
-// The same four states a side of a pair can be in, named against the line
-// rather than against a partner.
-const LINE_STATES: LineSide[] = [
-  { polarity: Polarity.Positive, moving: 'right' },
-  { polarity: Polarity.Positive, moving: 'left' },
-  { polarity: Polarity.Negative, moving: 'right' },
-  { polarity: Polarity.Negative, moving: 'left' },
-];
-
-// Every arrangement of n charges in a row: each of them either polarity, each
-// of them going either way. 4ⁿ of them before the symmetries are taken out.
-const linesOf = (n: number): LineSide[][] =>
-  n === 0
-    ? [[]]
-    : linesOf(n - 1).flatMap(rest => LINE_STATES.map(side => [side, ...rest]));
-
-// Read back to front with every direction reversed, a line is the same
-// experiment watched from the other end.
-const mirrored = (line: LineSide[]): LineSide[] =>
-  [...line].reverse().map(s => ({
-    polarity: s.polarity,
-    moving: s.moving === 'left' ? 'right' : 'left',
-  }));
-
-const opposite = (p: Polarity): Polarity =>
-  p === Polarity.Positive ? Polarity.Negative : Polarity.Positive;
-
-// Every polarity flipped, every direction kept: the anti-line.
-const antiLine = (line: LineSide[]): LineSide[] =>
-  line.map(s => ({ polarity: opposite(s.polarity), moving: s.moving }));
-
-// Identity up to mirroring: whichever way round the line reads first.
-const lineKey = (line: LineSide[]): string => {
-  const read = (l: LineSide[]) => l.map(s => `${s.polarity}${s.moving}`).join(",");
-  const [x, y] = [read(line), read(mirrored(line))];
-
-  return x < y ? x : y;
-};
-
-/**
- * The distinct lines among the given ones, each grouped with its anti-line so
- * the two sit one above the other — the same experiment run on matter and on
- * antimatter. A line that is its own anti up to mirroring is a group of one.
- */
-const antiGroups = (lines: LineSide[][]): LineSide[][][] => {
-  const byKey = new Map<string, LineSide[]>();
-  for (const line of lines) {
-    const key = lineKey(line);
-    if (!byKey.has(key)) byKey.set(key, line);
-  }
-
-  const taken = new Set<string>();
-  const groups: LineSide[][][] = [];
-
-  for (const [key, line] of byKey) {
-    if (taken.has(key)) continue;
-    taken.add(key);
-
-    const group = [line];
-
-    const opposite = lineKey(antiLine(line));
-    if (!taken.has(opposite) && byKey.has(opposite)) {
-      taken.add(opposite);
-      group.push(byKey.get(opposite)!);
-    }
-
-    groups.push(group);
-  }
-
-  return groups;
-};
-
-// Every arrangement of n charges, grouped with its anti.
-const lineGroups = (n: number): LineSide[][][] => antiGroups(linesOf(n));
-
-/**
- * One side of a head-on collision: `size` charges all going the same way,
- * their polarity flipping from one to the next. `inner` is the polarity of
- * the one at the interface, and the block alternates outward from there —
- * so what a block is doing at the meeting point is what names it, and the
- * rest of it follows.
- */
-const alternatingBlock = (size: number, inner: Polarity, moving: 'left' | 'right'): LineSide[] => {
-  const outward = Array.from({ length: size }, (_, i) => ({
-    polarity: i % 2 === 0 ? inner : opposite(inner),
-    moving,
-  }));
-
-  // Written from the interface outward. A block moving right sits to the left
-  // of the interface, so it reads the other way round along the line.
-  return moving === 'right' ? outward.reverse() : outward;
-};
-
-/**
- * Two alternating blocks run at each other. Once the alternation is fixed the
- * only freedom left is the phase of each block — which polarity it presents
- * at the interface — so these four are all of them:
- *
- *   ..0101 → ← 1010..  the alternation carries straight through the meeting
- *                      point; the line is one alternating line, cut in two and
- *                      told to move at itself.
- *   ..1010 → ← 1010..  both blocks in the same phase; the alternation breaks
- *                      exactly where they meet, and the two innermost charges
- *                      are alike rather than opposite.
- *
- * and the anti of each. Head-on opposites annihilate and head-on likes turn
- * around, so the phase decides whether the interface eats the line or reflects
- * it — and after the first tick the block behind is one step further in, with
- * its own phase to present.
- */
-const COLLISION_PHASES: [Polarity, Polarity][] = [
-  [Polarity.Positive, Polarity.Negative],
-  [Polarity.Negative, Polarity.Positive],
-  [Polarity.Positive, Polarity.Positive],
-  [Polarity.Negative, Polarity.Negative],
-];
-
-const collision = (size: number, [left, right]: [Polarity, Polarity]): LineSide[] => [
-  ...alternatingBlock(size, left, 'right'),
-  ...alternatingBlock(size, right, 'left'),
-];
-
-// The distinct collisions of two alternating blocks of `size`, grouped with
-// their antis. Mirroring identifies the two through-alternating phases, so
-// what is left is: alternation-through, and alternation-broken with its anti.
-const collisionGroups = (size: number): LineSide[][][] =>
-  antiGroups(COLLISION_PHASES.map(phases => collision(size, phases)));
-
-/**
- * A block with no phase to it: `size` charges all going the same way, each
- * polarity drawn on its own. There is nothing to name such a block by — every
- * draw is a different block — so what it says about an interface is only what
- * survives being watched a few times over.
- */
-const randomBlock = (size: number, moving: 'left' | 'right'): LineSide[] =>
-  Array.from({ length: size }, () => ({ polarity: Universe.randomPolarity(), moving }));
-
-/**
- * An alternating block driven into an unstructured one. The left side arrives
- * at the interface with a polarity that was decided the moment the block was
- * written; the right side arrives with one that wasn't decided by anything.
- *
- * So the two phases above stop being two experiments: which of them is
- * happening is redrawn at every step, as whatever the other side happens to
- * have put in front. What is left to watch is whether the alternation
- * survives being met by something that isn't one.
- */
-const alternatingIntoRandom = (size: number, inner: Polarity): LineSide[] => [
-  ...alternatingBlock(size, inner, 'right'),
-  ...randomBlock(size, 'left'),
-];
-
-/**
- * Two spinning magnets in a 3D space that has every direction in it, and the
- * ways they can be set going.
- *
- * They are laid out along x with the origin between them, so:
- *
- *  - `towards` / `apart` are along the line joining them — the only thing the
- *    flat two-block version could express at all;
- *  - `across` is both of them going the same way perpendicular to it, which
- *    is the two of them travelling together and asks whether whatever holds
- *    them holds them while they move;
- *  - `shear` is each going the opposite way across that line, which is the
- *    setup an orbit is made of: angular momentum about the midpoint, with an
- *    attraction to bend it into something closed;
- *  - `corner` sends each along a body diagonal, which no lattice wired only
- *    to its faces has at all, and which is the case that says whether "every
- *    direction" is a real claim here or just six of them dressed up;
- *  - `still` is the control — neither of them going anywhere, so anything
- *    that moves, moved because of the field.
- *
- * Each is run twice: with the two magnets turning together (both emitting the
- * same thing at the same time) and turning against each other (one always
- * putting out the opposite of what the other is).
- *
- * It is tempting to read that as the difference between annihilating and not
- * — like shells bouncing, opposite shells cancelling — and it isn't. A magnet
- * that turns over every tick lays down alternating shells, so directly behind
- * every shell is one of the opposite charge. Two like shells meeting in the
- * middle do turn each other round, and what each of them then runs into is
- * the opposite-charged shell coming along behind it, and THAT cancels. Both
- * ways round eat the space between the two sources; turning together just
- * takes one more step about it.
- */
-const MAGNET_CASES: {
-  name: string, a?: number[], b?: number[],
-  axis?: number[], spin?: boolean, alone?: boolean, turning?: 1 | -1,
-  crossed?: boolean,
-  // Drawn as the field rather than pulse by pulse, which a turning source
-  // gets anyway. Said outright for anything else that wants the comparison.
-  asField?: boolean,
-}[] = [
-  /**
-   * One magnet, on its own, held still — and the answer to whether anything
-   * here loops from one pole round to the other is no, by construction.
-   *
-   * What comes out is two opposed caps: the one charge straight out of the
-   * half facing along the axis, the other straight out of the half facing
-   * back, and nothing at all off the equator. They go out radially and they
-   * keep going. Nothing bends.
-   *
-   * Nothing CAN bend. A ray in this calculus does exactly two things — it
-   * moves the way it is going, or it meets something head-on and turns
-   * completely around. There is no rule anywhere that alters a direction by a
-   * little, so no path here is ever a curve; every path is a straight run
-   * with the occasional reversal in it. A field line that leaves the north
-   * pole, arcs over, and comes back into the south would need a charge to be
-   * continuously deflected by the space it is passing through, and space here
-   * does not act on anything: it is what gets traded places with.
-   *
-   * There is also a reason it shouldn't be expected. Magnetic field lines
-   * close because the field has no sources to start or stop on. This field is
-   * nothing BUT sources — every charge on screen was written onto space by a
-   * magnet and is on its way out of it. So the thing being drawn is much
-   * closer to two opposite charges radiating than to a dipole, and radiating
-   * is what it looks like.
-   *
-   * What DOES happen, and is worth watching for, is at the equator: the two
-   * caps fan sideways as they travel (see the Huygens step), so their edges
-   * eventually reach around into each other's half. Where a positive edge
-   * meets a negative one they cancel. That is not a line curving from pole to
-   * pole. It is the nearest thing these rules have to one: the two halves of
-   * the field closing on each other, around the middle, some way out.
-   */
-  // { name: 'one magnet, on its own', axis: [1, 0, 0], spin: false, alone: true },
-
-  // Neither going anywhere: the baseline, in which anything that moves, moved
-  // because of the field.
-  { name: 'still' },
-
-  /**
-   * Angular momentum, both the same way round.
-   *
-   * The sources sit at −sep and +sep along x. Take the one on the left up
-   * (+y) and the one on the right down (−y) and the pair is circulating about
-   * the point between them — clockwise, looking down the z axis at the plane
-   * they are in. Checking the sign rather than trusting it: a rotation about
-   * +z carries a point at −x towards −y, so a point at −x heading towards +y
-   * is going round the other way, which is the clockwise one.
-   *
-   * Both of them the same way round is what makes this angular momentum
-   * rather than two things passing. Opposite ways round would cancel about
-   * the midpoint and be a shear — the two sliding past each other with
-   * nothing going round anything.
-   *
-   * Whether it closes into an orbit is the question, and it is a real one
-   * rather than a foregone conclusion: an orbit needs the pull to bend the
-   * motion by just as much as the motion carries it past, and nothing here
-   * has been arranged to make those two match. The likely outcomes are all
-   * legible — they spiral together, they curve and escape, or the radiation
-   * knocks them off course before either.
-   */
-  // { name: 'both clockwise', a: [0, 1, 0], b: [0, -1, 0] },
-
-  /**
-   * Closing, but not on each other.
-   *
-   * The left one goes up and to the right, the right one down and to the
-   * left. Along x they are approaching; along y they are pulling apart. So
-   * they converge without ever being aimed at one another, and pass at an
-   * offset rather than meeting — which is the one arrangement where a pull
-   * has something to work with.
-   *
-   * Head-on, attraction can only make them arrive sooner; there is nothing
-   * for it to bend. Set going sideways (`both clockwise`), they were already
-   * leaving and it has to catch them. Between the two is this: a fly-by with
-   * an impact parameter, coming in fast enough to pass and close enough to be
-   * turned, which is the case where a pull either bends the path into
-   * something that comes back round or doesn't — and either answer is worth
-   * having.
-   *
-   * The angular momentum is the same sense for both, as above, so what they
-   * carry past each other is a rotation about the midpoint rather than two
-   * things sliding by.
-   *
-   * Both directions are edge steps rather than axis ones, √2 long, which the
-   * clock in `tick` charges accordingly — so these two cover the same ground
-   * per tick as everything else and arrive when they would have arrived.
-   */
-  // { name: 'closing at an angle', a: [1, 1, 0], b: [-1, -1, 0] },
-
-  /**
-   * Two actual magnets, poles along the line between them, not turning.
-   *
-   * Everything above is a source with no sides that flips over every tick:
-   * the same charge in every direction, reversed, again and again. That is
-   * where the waves come from — the alternation IS the wave, and a train of
-   * shells is a record of a thing being turned over.
-   *
-   * A magnet doesn't do that. It has a north and a south and it holds them:
-   * `emits` out of the half facing +x, its opposite out of the half facing
-   * −x, nothing across the equator, tick after tick without reversing. So
-   * there are no shells here at all — no alternation to make a front out of.
-   * What comes off each pole is a steady stream of the one charge, and the
-   * field between the two is not a sequence of arrivals but a standing thing
-   * that is simply there.
-   *
-   * Both get the same axis, which is what faces them at each other properly:
-   * the left one's right-hand side is its north and the right one's left-hand
-   * side is its south. So everything crossing the gap is the opposite of what
-   * it meets, permanently. Between two turning sources the two streams were
-   * alike as often as not, and alike charges bounce; here every meeting in
-   * the gap cancels, and cancelling is the one event that takes space out of
-   * the world.
-   *
-   * Which makes this the arrangement to ask the question of. If a steady
-   * one-sided cancellation right along the line between them does not draw
-   * them together, nothing built out of these rules will, and the answer is
-   * about the rules rather than about the setup.
-   */
-  // { name: 'two magnets, poles facing', axis: [1, 0, 0], spin: false },
-
-  /**
-   * One magnet, actually turning.
-   *
-   * Its axis comes round an eighth of a turn at a time, so north sweeps
-   * through every direction in the plane and comes back. It emits the whole
-   * while and nothing about it flips: standing anywhere off the axis you are
-   * passed by north, then the equator, then south, then the equator again,
-   * which is an alternation that happens TO you because the thing is going
-   * round rather than one stipulated of it.
-   *
-   * What that should make is the difference between this and every source
-   * above. A source flipping in place puts out shells — the same in every
-   * direction, one polarity after another, and drawn as a surface a shell is
-   * a sphere. A source turning puts out two lobes that are pointing somewhere
-   * different each time, so what leaves it is a fan sweeping the plane it
-   * turns in, and what is left behind is a spiral of alternating charge
-   * rather than a stack of shells. Flat, because the turn is flat.
-   */
-  { name: 'one magnet, turning', axis: [1, 0, 0], spin: false, alone: true, turning: 1 },
-
-  /**
-   * The same source, and the same drawing, with the turning taken out.
-   *
-   * A control, and the only honest way to read the one above it. Everything
-   * that picture is claiming rests on the field being reconstructed from a
-   * few thousand points, and a reconstruction can be talked into almost any
-   * shape by what it was told to prefer — so a spiral coming out of it is
-   * worth exactly as much as the same machinery drawing something that is
-   * NOT a spiral when it is not given one.
-   *
-   * This is that. No axis, so the source has no sides and puts the same
-   * charge out in every direction at once; flipping in place rather than
-   * coming round, so every shell is the opposite of the one before it. What
-   * is there is rings: concentric, alternating, evenly spaced, and closed.
-   * The winding is the whole of the difference between the two, and it is a
-   * difference in what the sources are doing rather than in how either was
-   * drawn.
-   *
-   * The preference the drawing carries is a preference about NEIGHBOURS and
-   * not about shape — a charge belongs with the ones that left when it did,
-   * which lie across the way it is going, and not with the one in front of
-   * it, which is a different shell and as likely as not the other charge. Set
-   * that loose on a source that turns and the arcs it closes are rotated one
-   * from the next, which is a spiral. Set it loose on one that only flips and
-   * they are rings. Nothing in it knows which it is drawing.
-   */
-  { name: 'one source, not turning', alone: true, asField: true },
-
-  /**
-   * Two of them, turning opposite ways.
-   *
-   * Same as above with a second magnet across the gap, and it comes round the
-   * other way — so the two are counter-rotating, like a pair of gears rather
-   * than a pair of clocks. Which is the arrangement where what crosses the
-   * gap is not the same twice: the face each presents to the other is
-   * changing, and changing in opposite senses, so the charge arriving from
-   * one is sometimes alike to what it meets and sometimes opposite, on a
-   * cycle set by how fast they turn rather than by anything about the space.
-   *
-   * Both turning the same way is the other half of the experiment and is what
-   * the pairing below draws alongside it — there the two present matching
-   * faces to each other throughout, which is a different thing entirely from
-   * two counter-rotating ones and should not eat the space between them the
-   * same way.
-   */
-  { name: 'two magnets, turning', axis: [1, 0, 0], spin: false, turning: 1 },
-
-  /**
-   * The two of them turning in planes at right angles to each other.
-   *
-   * Everything above turns in the plane the pair are laid out in, which is
-   * the flat case dressed up in three dimensions: both arms wind in the same
-   * plane, and a picture of it says nothing a drawing on paper could not.
-   * Here the left one comes round from x towards y and the right one from x
-   * towards z, so the two spirals lie in surfaces at right angles and cross
-   * rather than overlap.
-   *
-   * It is the one arrangement in this article that could not exist in fewer
-   * than three dimensions — two planes meeting in a line — and the thing to
-   * watch is that line, which is where the only directions belonging to both
-   * of them are, and so the only places their fields can meet at all.
-   */
-  // {
-  //   name: 'two magnets, turning in crossed planes',
-  //   axis: [1, 0, 0], spin: false, turning: 1, crossed: true,
-  // },
-];
-
-const MAGNET_SPINS: { name: string, phase: number }[] = [
-  { name: 'turning together', phase: 0 },
-  { name: 'turning against', phase: 1 },
-];
-
-
-const Caption = ({ children }: { children: any }) => (
-  <div style={{ color: '#8a8d99', fontSize: '0.8em', paddingTop: '0.6em' }}>{children}</div>
-);
-
-const RayCalculiAndPhysics = () => {
-  const navigate = useNavigate();
-
-  const referenceCounter = useCounter();
-
-  const paper: Omit<PaperProps, 'children'> = {
-    ...RAY_CALCULI_AND_PHYSICS.reference,
-    pdf: {
-      fonts: [JetBrainsMono, BlueprintIcons20, BlueprintIcons16],
-    },
-    Reference: (props: {}) => (<></>),
-    references: referenceCounter
-  }
-
-  return <Post {...paper}>
-    <Arc head="">
-      <Section head="">
-        <CalculusVisualization
-          graph={() => Graph.expandingGrid(3)}
-          // repeated
-        />
-
-        {/* Two blocks meeting head-on: opposite polarities, then both
-            positive, then both negative. */}
-        {([
-          [Polarity.Positive, Polarity.Negative],
-          [Polarity.Positive, Polarity.Positive],
-          [Polarity.Negative, Polarity.Negative],
-        ] as [Polarity, Polarity][]).map(([left, right], i) => (
-          <CalculusVisualization
-            key={`blocks-${i}`}
-            graph={() => Graph.blocks(left, right)}
-            repeated={15}
-            height={140}
-            density={false}
-          />
-        ))}
-
-        {/* The same two blocks heading into each other with nothing uniform
-            about either of them: every point drawn positive or negative on
-            its own. The interface is then a different thing at every row of
-            it, so the two come apart along a line neither of them had — three
-            draws, since a draw is not a case. */}
-        {[0, 1, 2].map(i => (
-          <CalculusVisualization
-            key={`mixed-blocks-${i}`}
-            graph={() => Graph.mixedBlocks()}
-            repeated={5}
-            filmstrip
-            height={90}
-            density={false}
-          />
-        ))}
-
-        {/* The same two blocks held apart by a wide field of neutral space,
-            neither of them moving, each writing a charge onto the space at
-            its face every other tick. Opposite charges annihilate in the
-            middle and the field between them is eaten two columns at a time
-            until there is none of it left; like charges only bounce off each
-            other and come home. */}
-        {([
-          [Polarity.Positive, Polarity.Negative],
-          [Polarity.Positive, Polarity.Positive],
-        ] as [Polarity, Polarity][]).map(([left, right], i) => (
-          <CalculusVisualization
-            key={`emitters-${i}`}
-            graph={() => Graph.emitters(left, right)}
-            repeated={18}
-            height={140}
-          />
-        ))}
-
-        {/* The same two blocks with the magnets turned on: each side flips
-            what it is emitting every tick, and emits on every one of them, so
-            the field fills with alternating charge rather than with one thing
-            over and over. Spinning is what makes it unconditional — held
-            still, two blocks emitting alike only push each other away; turned
-            over fast enough, both ways round end up eating the field between
-            them, the second one in bursts rather than steadily. */}
-        {([
-          [Polarity.Positive, Polarity.Negative],
-          [Polarity.Positive, Polarity.Positive],
-        ] as [Polarity, Polarity][]).map(([left, right], i) => (
-          <CalculusVisualization
-            key={`spinning-${i}`}
-            graph={() => Graph.emitters(left, right, { gap: 20, every: 1, spin: true })}
-            repeated={22}
-            height={140}
-          />
-        ))}
-
-        {/* The same two magnets, in three dimensions, each radiating into all
-            twenty-six directions of the lattice instead of down one corridor,
-            and each set going a different way to begin with. The sources are
-            the yellow points; every charge on screen came out of one of them.
-            What is drawn is the structure rather than the coordinates, so
-            space that has been annihilated out of the world is not a hole in
-            the picture — it is two things that are now nearer each other. */}
-        {MAGNET_CASES.map(({ name, a, b, axis, spin: flipping = true, alone, turning, crossed, asField }) => (
-          <Fragment key={`magnets-${name}`}>
-            {/* What the pair of runs is contrasting depends on what the
-                sources are doing. Flipping in place, it is whether they flip
-                in step; turning, it is whether they turn the same way or
-                against each other, which is the only sense in which a thing
-                going round has a hand. Doing neither, there is nothing to
-                contrast and it is one run. */}
-            {((turning
-              ? [{ name: 'turning the same way', phase: 0, sense: 1 },
-                 { name: 'turning opposite ways', phase: 0, sense: -1 }]
-              : flipping
-                // Phase is one source's flip against the other's, so on its
-                // own there is nothing for it to be against and the two runs
-                // would be the same run twice.
-                ? alone
-                  ? [{ name: 'pulsing', phase: 0, sense: 1 }]
-                  : MAGNET_SPINS.map(s => ({ ...s, sense: 1 }))
-                : [{ name: 'held', phase: 0, sense: 1 }]
-            ) as { name: string, phase: number, sense: 1 | -1 }[]).map(spin => (
-              <div key={spin.name} style={{ marginBottom: '1.5rem' }}>
-                {/* Flat and round, one under the other.
-
-                    The turn is flat: the axis comes round in a plane and
-                    never leaves it, so everything these arrangements do
-                    happens in that plane and the third dimension only offers
-                    the rest of a sphere for the same arms to be looked at
-                    through. Which makes the 3D picture a projection of the 2D
-                    one with a great deal of unrelated ball laid over it —
-                    every part of the space that is neither in front of an arm
-                    nor behind it, drawn at the same time as the arm.
-
-                    So the flat one is the picture of the thing, and the round
-                    one is the picture of the thing plus the depth it was seen
-                    through. Read together they say which of the two the
-                    features belong to: what is in both is the arrangement,
-                    and what is only in the round one is the embedding. */}
-                {[2, 3].map(dims => (
-                <Fragment key={dims}>
-                  <CalculusVisualization
-                    graph={() => Graph.magnets(
-                      { emits: Polarity.Positive, moving: a, axis, turning },
-                      {
-                        emits: Polarity.Positive, moving: b, phase: spin.phase, axis,
-                        // The second one turning in a plane at right angles to
-                        // the first: x towards z rather than x towards y.
-                        plane: crossed
-                          ? [[1, 0, 0], [0, 0, 1]] as [number[], number[]]
-                          : undefined,
-                        // The second one comes round the other way when they
-                        // are set against each other.
-                        turning: turning ? (turning * spin.sense) as 1 | -1 : undefined,
-                      },
-                      {
-                        spin: flipping, alone,
-                        // A spiral is where each pulse went. Wandering is each
-                        // pulse going somewhere slightly else on the way, which
-                        // is exactly the information an arm is made of, rubbed
-                        // out — measurably: the distance out stops tracking how
-                        // long ago it left.
-                        wander: turning || asField ? 0 : undefined,
-
-                        /**
-                         * One pulse per cell the wave advances, which for a
-                         * turning source means one every third tick.
-                         *
-                         * The two have to agree. Charges from a turning magnet
-                         * are held to a cell every third tick, so that the
-                         * magnet gets three eighths of a turn round between one
-                         * ring of the wave and the next and the winding is
-                         * tight. Emit every tick against that and the ring of
-                         * cells around the source has not cleared when the next
-                         * pulse is due: it goes out as one or two charges
-                         * instead of two dozen, and most of the shells are too
-                         * thin to be anything. Measured, that leaves gaps at
-                         * two thirds of the radii and under a full turn of
-                         * winding across the whole ball.
-                         *
-                         * Matched, every pulse leaves into empty space and
-                         * lands one cell further out than the one before, so
-                         * the ball is layered the whole way from the source to
-                         * the edge with a hundred and thirty-five degrees
-                         * between each layer and the next.
-                         */
-                        /**
-                         * Long enough that every direction has cleared, which
-                         * is set by the slowest of them.
-                         *
-                         * A step costs its own length, so a charge leaving
-                         * through a corner of its cell takes √3 times as long
-                         * to be gone as one leaving through a face. Emit again
-                         * before that and the corner directions are still
-                         * occupied by the last pulse: what goes out is the six
-                         * faces and a few edges — fourteen of the twenty-six —
-                         * and the shell has holes in it in exactly the
-                         * directions that were slowest, every time, in the same
-                         * places. Which is a spiral with pieces missing out of
-                         * it wherever the lattice is coarsest.
-                         *
-                         * Waiting the √3·3 ≈ 6 ticks a corner needs, every
-                         * pulse leaves whole. The wave advances two cells in
-                         * that time and the magnet turns three quarters of the
-                         * way round, so the pitch is what it was — an eighth of
-                         * a turn per third of a cell — with half as many shells
-                         * in the air, each of them entire.
-                         */
-                        // Every tick, like everything else here. A cell
-                        // emptied this tick is free the next, so the source is
-                        // never waiting on its own last pulse: a shell leaves
-                        // whole every tick, lands one cell further out than the
-                        // one before, and the magnet has turned an eighth of a
-                        // turn in between. The ball is layered the whole way
-                        // from the source to the edge, each layer rotated from
-                        // the one inside it, which is what a spiral is.
-                        every: undefined,
-
-                        /**
-                         * And fanning as early as it can, which is what closes
-                         * the gaps.
-                         *
-                         * A shell is the two dozen directions the source has,
-                         * and two dozen points spread over a sphere of radius
-                         * ten are nowhere near each other — the band they are
-                         * supposed to make is dots with holes between them, and
-                         * no amount of care in the drawing joins up something
-                         * that is not joined. Every charge fanning sideways
-                         * into the room around it as soon as it has any
-                         * multiplies each shell several times over, and it does
-                         * it where the gaps are: out at the far end, where a
-                         * shell has grown and its charges have drifted apart.
-                         */
-                        // Out where there is room for it, rather than at the
-                        // first opportunity. Fanning close in crowds the few
-                        // cells near the source and thickens the shells there
-                        // (measured: half again as thick, and half of
-                        // everything waiting to move); fanning out where a
-                        // shell has already grown puts the extra charges
-                        // exactly where the gaps between them have opened.
-                        fanAt: turning || asField ? 5 : undefined,
-
-                        dims,
-                      },
-                    )}
-                    repeated={60}
-                    // Said outright rather than left to follow from `repeated`,
-                    // which is what it defaults to: turn the repeat off to
-                    // watch one run go on indefinitely and the whole thing
-                    // silently stops autoplaying too, which looks exactly like
-                    // a universe in which nothing happens.
-                    autoplay
-                    height={320}
-                    interval={0.2}
-                    // A turning source lays down a spiral, and a spiral
-                    // belongs to a whole train of shells rather than to any one
-                    // of them — drawn pulse by pulse it is a stack of lobes and
-                    // the winding is nowhere. Everything else is a source that
-                    // emits the same thing in every direction, where the pulse
-                    // IS the object and the shells say it best.
-                    mode={turning || asField ? "field" : "shells"}
-                    // The glow is a sum over every charge, and with a pulse
-                    // going out every tick that is most of the ball — one even
-                    // wash, hiding the shells it is drawn from.
-                    density={false}
-                  />
-                  <Caption>
-                    {name} — {spin.name}, {dims === 2 ? 'flat' : 'in three dimensions'}
-                  </Caption>
-                </Fragment>
-                ))}
-              </div>
-            ))}
-          </Fragment>
-        ))}
-
-        {/* And the same dynamics again, written down instead of run.
-
-            Everything above this is the model: points, a local rule, and a
-            field reconstructed afterwards from where the points ended up.
-            What follows is the closed form of what that model makes — one
-            cosine per source, evaluated at every pixel, with no simulation
-            behind it and nothing to reconstruct. It is not a cheaper way of
-            getting the pictures above; it is a different claim, and the value
-            of it is in where the two disagree.
-
-            Cheap, though, and that shows: there is no state carried between
-            frames and no tick, so t is a real number and the waves travel
-            smoothly rather than a cell at a time. */}
-        {CONTINUOUS_CASES.map(({ name, note, sources, span, cycle }) => (
-          <div key={`continuous-${name}`} style={{ marginBottom: '1.5rem' }}>
-            <ContinuousField sources={sources} span={span} cycle={cycle} height={320} />
-            <Caption>{name} — {note}</Caption>
-          </div>
-        ))}
-
-        {ANTI_GROUPS.map((group, i) => (
-          <div key={i} style={{ marginBottom: '1.5rem' }}>
-            {group.map((pair, j) => (
-              <CalculusVisualization
-                key={j}
-                graph={() => Graph.pair(pair.a, pair.b)}
-                repeated={1}
-                filmstrip
-                height={60}
-                density={false}
-              />
-            ))}
-          </div>
-        ))}
-
-        {/* The same thing with an inside to it: every arrangement of three,
-            then of four, charges in a line. Each runs for as many steps as
-            there are charges, since that is roughly how long it takes for
-            what happens at one end to be felt at the other. */}
-        {[3, 4].map(n => (
-          <Fragment key={`line-${n}`}>
-            {lineGroups(n).map((group, i) => (
-              <div key={i} style={{ marginBottom: '1.5rem' }}>
-                {group.map((line, j) => (
-                  <CalculusVisualization
-                    key={j}
-                    graph={() => Graph.line(line)}
-                    repeated={n}
-                    filmstrip
-                    height={60}
-                    density={false}
-                  />
-                ))}
-              </div>
-            ))}
-          </Fragment>
-        ))}
-
-        {/* Not every arrangement now, but the one arrangement with a pattern
-            to it: alternating polarities driven head-on into alternating
-            polarities. Blocks of two, three and four a side, each run for as
-            many steps as the whole line is long. */}
-        {[2, 3, 4].map(size => (
-          <Fragment key={`collision-${size}`}>
-            {collisionGroups(size).map((group, i) => (
-              <div key={i} style={{ marginBottom: '1.5rem' }}>
-                {group.map((line, j) => (
-                  <CalculusVisualization
-                    key={j}
-                    graph={() => Graph.line(line)}
-                    repeated={size * 2}
-                    height={60}
-                    density={false}
-                  />
-                ))}
-              </div>
-            ))}
-          </Fragment>
-        ))}
-
-        {/* And the same collision with the structure taken out of one side:
-            alternating into randomly assigned. There is no permutation to
-            enumerate here — a draw is not a case — so it is a handful of runs,
-            the alternating side starting from either polarity in turn. */}
-        {[3, 4].map(size => (
-          <Fragment key={`mixed-${size}`}>
-            {Array.from({ length: 4 }, (_, i) => (
-              <div key={i} style={{ marginBottom: '1.5rem' }}>
-                <CalculusVisualization
-                  graph={() => Graph.line(
-                    alternatingIntoRandom(size, i % 2 === 0 ? Polarity.Positive : Polarity.Negative)
-                  )}
-                  repeated={size * 2}
-                  height={60}
-                  density={false}
-                />
-              </div>
-            ))}
-          </Fragment>
-        ))}
-
-      </Section>
-    </Arc>
-  </Post>;
-}
-
-export default RayCalculiAndPhysics;
\ No newline at end of file
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx
new file mode 100644
index 0000000..12111ea
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx
@@ -0,0 +1,2390 @@
+import { useRef } from "react";
+
+import { CanvasView, Surface } from "./canvas";
+import { Boundary, Graph, node } from "./discrete";
+import { BOUNDARY_STUB, CYCLE, LATTICE_STEP, Polarity, Vec } from "./lattice";
+import {
+  AMBER, channels, CYAN, ground, HALO, rgba, SOURCE, source, tintOf,
+} from "./paint";
+
+/**
+ * How much of the universe is worth drawing.
+ *
+ * `lattice` draws all of it: every boundary of every point, one stroke each.
+ * That is the right thing for a universe of a dozen points, where each one is
+ * the subject.
+ *
+ * `shells` and `field` are for the ones with thousands. A point wired in all
+ * twenty-six directions has twenty-six boundaries, and a ball of a thousand
+ * such points has some thirteen thousand connections — drawn one stroke at a
+ * time it is both unaffordable and a solid grey fog. So the space is drawn as
+ * its axis-aligned connections only, batched into a single path, and
+ * everything on top of it is only what is HAPPENING: the sources, and the
+ * charges in flight. The lattice bending is then something you can see,
+ * because there is a lattice to see rather than a fill.
+ *
+ * The two differ in what they make of the charges. `shells` draws each pulse
+ * as the surface it is, which is the honest picture of a thing that emits and
+ * the whole story for a source that only flips over. `field` draws what the
+ * pulses add up to — the region where the field is one charge and the region
+ * where it is the other — which is the only way to see a source that TURNS,
+ * since a spiral is a property of a whole train of shells and of none of them
+ * separately.
+ */
+export type RenderMode = 'lattice' | 'shells' | 'field';
+
+/**
+ * One canvas showing one universe.
+ *
+ * `animate` is what separates a player from a still: with it the view runs a
+ * requestAnimationFrame loop, easing the camera and handing each frame's dt
+ * back to the caller (which is where ticking lives — this component only ever
+ * renders, it never advances the dynamics). Without it the universe is drawn
+ * exactly once, with the camera snapped straight to its target orientation
+ * rather than eased into it, since there are no later frames to ease over.
+ */
+export const GraphCanvas = ({
+  graph: current,
+  animate = false,
+  density = true,
+  mode = 'lattice',
+  onFrame,
+  onVisible,
+}: {
+  // Read afresh every frame, so a reset that swaps the whole graph out is
+  // picked up without tearing the render loop down. Nothing at all is a
+  // universe that has been let go of because nobody is looking at it — the
+  // view draws nothing rather than pretending there is something to draw.
+  graph: () => Graph | null;
+  animate?: boolean;
+  density?: boolean;
+  mode?: RenderMode;
+  onFrame?: (dt: number) => void;
+
+  // Called as the view comes on and off screen, so that whoever owns the
+  // universe can let go of it and make a new one. See `CalculusPlayer`.
+  onVisible?: (visible: boolean) => void;
+}) => {
+  // The frame loop is made once and outlives every re-render, so it must not
+  // capture these — a callback closed over at mount time would still be
+  // looking at the state of the world as it was then (which is what made
+  // pausing do nothing: the loop kept calling the first render's onFrame,
+  // where `running` was frozen at its initial value). Kept in a ref and read
+  // per frame, so the loop always calls the current ones.
+  const latest = useRef({ current, onFrame, onVisible });
+  latest.current = { current, onFrame, onVisible };
+
+  return <CanvasView animate={animate} deps={[animate, density, mode]} paint={() => {
+    const cam = {
+      scale: 44, rot: Math.PI / 4, tilt: 0.6155,
+      dist: null as number | null, distMult: 1.5, scaleMult: 1,
+    };
+
+    // The field as drawn, which lags the field as computed and catches up a
+    // fraction every frame. Kept across frames because that lag is the whole
+    // of what makes the animation flow rather than step.
+    let eased: Float32Array | null = null;
+
+    function project(pos: Vec, rot: number, tilt: number, camDist: number) {
+      const x = pos[0] || 0, y = pos[1] || 0, z = pos[2] || 0;
+      const cosR = Math.cos(rot), sinR = Math.sin(rot);
+      const x1 = x * cosR - z * sinR;
+      const z1 = x * sinR + z * cosR;
+      const cosT = Math.cos(tilt), sinT = Math.sin(tilt);
+      const y1 = y * cosT - z1 * sinT;
+      const z2 = y * sinT + z1 * cosT;
+      // True perspective: camera sits at distance camDist from the origin
+      // along the view axis. Points nearer the camera than that (denom small
+      // or negative) are behind/at the lens and get clipped. Convergence
+      // toward a vanishing point is now the CORRECT result of an actual
+      // camera, not a bug — it's what "moving the camera closer" means.
+      const denom = z2 + camDist;
+      if (denom < camDist * 0.02) return { x: 0, y: 0, depth: 0, clipped: true };
+      const persp = camDist / denom;
+      return { x: x1 * persp, y: y1 * persp, depth: Math.min(Math.max(persp, 0.15), 6), clipped: false };
+    }
+
+    function draw({ ctx, width: w, height: h }: Surface) {
+      const graph = latest.current.current();
+      if (!graph) return;
+      // The outline enclosing a set of points. Andrew's monotone chain:
+      // sort, then walk once along the bottom and once back along the top,
+      // dropping any point the walk turns the wrong way at.
+      const outline = (at: { x: number, y: number }[]) => {
+        const p = at.slice().sort((a, b) => a.x - b.x || a.y - b.y);
+        const turn = (o: typeof p[0], a: typeof p[0], b: typeof p[0]) =>
+          (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+
+        const half = (source: typeof p) => {
+          const out: typeof p = [];
+
+          for (const q of source) {
+            while (out.length >= 2 && turn(out[out.length - 2], out[out.length - 1], q) <= 0) out.pop();
+            out.push(q);
+          }
+
+          out.pop();
+
+          return out;
+        };
+
+        return half(p).concat(half(p.slice().reverse()));
+      };
+
+      // Both of the two field renderings want the lattice, the sources and
+      // the marks; they differ in what they make of the charges.
+      const field = mode !== 'lattice';
+      const contours = mode === 'field';
+
+      ground(ctx, w, h, { vignette: true });
+
+      if (graph.nodes.length === 0) return;
+
+      const layout = graph.layout;
+
+      // What the camera measures itself against. Everything, unless the
+      // universe has said which part of itself is the subject — see `focus`.
+      const framed = graph.focus === undefined
+        ? [...layout]
+        : [...layout].filter(([nd]) => graph.inFocus(nd));
+
+      // Raw world extent (unprojected) — this is what the base pixel scale
+      // tracks, deliberately independent of camera distance/perspective, so
+      // there's no feedback loop between "how far the camera has dollied" and
+      // "how much of the grid fits on screen". A real camera doesn't refit
+      // its FOV to guarantee everything stays visible as it moves closer.
+      let worldExtent = 1e-6;
+      for (const [, pos] of framed) {
+        const r = Math.hypot(...pos);
+        if (r > worldExtent) worldExtent = r;
+      }
+
+      // Auto-orient the camera to the effective dimensionality of what's
+      // actually on screen: measure the spread along each world axis and
+      // count how many are meaningfully populated. A 1D structure (one
+      // axis) lies flat as a horizontal line, a 2D structure (two axes) is
+      // viewed straight-on/top-down, and a 3D structure gets a ¾
+      // perspective. The camera eases toward the target so a change in
+      // dimensionality (e.g. a line thickening into a plane) animates
+      // rather than snapping.
+      const lo = [Infinity, Infinity, Infinity];
+      const hi = [-Infinity, -Infinity, -Infinity];
+      for (const [, pos] of framed) {
+        for (let k = 0; k < 3; k++) {
+          const v = pos[k] || 0;
+          if (v < lo[k]) lo[k] = v;
+          if (v > hi[k]) hi[k] = v;
+        }
+      }
+      const extent = [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]];
+      const maxExtent = Math.max(extent[0], extent[1], extent[2], 1e-6);
+      const effDims = extent.filter(e => e > maxExtent * 0.15).length;
+
+      const targetRot = effDims >= 3 ? Math.PI / 4 : 0;
+      const targetTilt = effDims >= 3 ? 0.6155 : 0;
+      // A still has no later frames to ease over, so it snaps.
+      const orientEase = animate ? 0.12 : 1;
+      cam.rot += (targetRot - cam.rot) * orientEase;
+      cam.tilt += (targetTilt - cam.tilt) * orientEase;
+
+      // Scale/distance are always exactly proportional to the grid's current
+      // size — recomputed directly every frame, not smoothed toward a target.
+      // That matters for two reasons: (1) no lerp means nothing ever "chases"
+      // a moving target, which is what read as unwanted drift; (2) being
+      // exactly proportional means the camera can never fall behind the
+      // grid's exponential physical growth, which a genuinely fixed distance
+      // eventually does — that falling-behind is what looked like runaway
+      // automatic zoom-in with no way to scroll back out. The user's zoom
+      // level (scaleMult / distMult) is a stable multiplier riding on top,
+      // changed only by scroll — never reset or overridden automatically.
+      cam.dist = worldExtent * (cam.distMult || 1.5);
+      // cam.scale is fit to the projected bounding box below (once every
+      // node has been projected), so the zoom matches the actual on-screen
+      // shape and the available width/height — see the fit step.
+
+      const cx = w / 2, cy = h / 2;
+
+      const projected = new Map();
+      for (const [n, pos] of layout)
+        projected.set(n, project(pos, cam.rot, cam.tilt, cam.dist || 1));
+
+      // Where a boundary's stub points, in projected (pre-scale) space: at
+      // its neighbour, or one lattice step along its bare outward direction.
+      // The same two cases the renderer draws, so the box below is measured
+      // against exactly what ends up on the canvas.
+      const aims = (n: node, bd: Boundary) => {
+        if (bd.target) return projected.get(bd.target.at.node);
+
+        const wp = layout.get(n);
+        if (!bd.outward || !wp) return undefined;
+
+        return project(
+          wp.map((v, i) => v + (bd.outward![i] || 0) * LATTICE_STEP),
+          cam.rot, cam.tilt, cam.dist || 1,
+        );
+      };
+
+      // Fit-to-viewport zoom: size the structure from its actual PROJECTED
+      // extent against the available width and height. A horizontal line
+      // fills the width, a flat plane fills the frame, and a sphere sits
+      // inside the smaller dimension — each zoomed appropriately for its
+      // shape rather than assumed spherical. Boundary stubs are measured
+      // along with the nodes: the outward ones reach past the outermost node
+      // by a quarter of a lattice step, which on a two-point universe is a
+      // large fraction of the whole picture, and would otherwise hang off
+      // the edge of the canvas.
+      let loX = Infinity, hiX = -Infinity, loY = Infinity, hiY = -Infinity;
+      const consider = (x: number, y: number) => {
+        if (x < loX) loX = x;
+        if (x > hiX) hiX = x;
+        if (y < loY) loY = y;
+        if (y > hiY) hiY = y;
+      };
+      for (const [n, p] of projected) {
+        if (p.clipped || !graph.inFocus(n)) continue;
+        consider(p.x, p.y);
+
+        for (const ray of n) {
+          for (const bd of ray.boundaries) {
+            const t = aims(n, bd);
+            if (!t || t.clipped) continue;
+            consider(p.x + (t.x - p.x) * BOUNDARY_STUB, p.y + (t.y - p.y) * BOUNDARY_STUB);
+          }
+        }
+      }
+      if (loX > hiX) { loX = hiX = loY = hiY = 0; } // nothing survived clipping
+
+      // The camera frames what is actually there, rather than the world
+      // origin: the middle of that bounding box is what lands in the middle
+      // of the canvas. A universe that has drifted off the origin — every
+      // node merged onto one side, say — is still centred on screen instead
+      // of clinging to an edge.
+      const midX = (loX + hiX) / 2, midY = (loY + hiY) / 2;
+      const halfX = Math.max((hiX - loX) / 2, 1e-6);
+      const halfY = Math.max((hiY - loY) / 2, 1e-6);
+
+      const FIT_MARGIN = 0.9; // small gap at the edges
+      cam.scale = Math.min(
+        (w * 0.5 * FIT_MARGIN) / halfX,
+        (h * 0.5 * FIT_MARGIN) / halfY,
+        // A single point has no extent to fit, and would otherwise ask for
+        // an infinite zoom.
+        Math.min(w, h) / LATTICE_STEP,
+      ) * (cam.scaleMult || 1);
+
+      // Projected space to canvas pixels. Everything drawn goes through this,
+      // so the framing above holds for nodes, boundaries and the density
+      // cloud alike.
+      const place = (pr: { x: number, y: number, depth: number, clipped: boolean }) => ({
+        x: cx + (pr.x - midX) * cam.scale,
+        y: cy + (pr.y - midY) * cam.scale,
+        depth: pr.depth,
+        clipped: pr.clipped,
+      });
+
+      const pts = new Map();
+      for (const [n, p] of projected) pts.set(n, place(p));
+
+      // Screen position of an arbitrary world point, through the same camera
+      // as the nodes — used for boundaries that point somewhere no node is.
+      const screenOf = (world: Vec) =>
+        place(project(world, cam.rot, cam.tilt, cam.dist || 1));
+
+      // The seed of an expanding universe — the one cell at the origin.
+      const isCenterNode = (nd: node) => {
+        const g = graph.gridPos.get(nd);
+        return !!g && g.every(v => v === 0);
+      };
+
+      // Viewport culling: skip the detailed rendering work (ray projection,
+      // shadowBlur, stroke/fill calls) for anything clearly off-screen. Once
+      // zoomed into part of a large structure, most of the population isn't
+      // actually visible — this is what stops paying for it anyway. Margin
+      // is generous (a couple of scale-units of screen space) so a node just
+      // outside the canvas edge doesn't have its still-visible ray tip
+      // prematurely clipped.
+      const cullMargin = cam.scale * 2;
+      const onScreen = (p: { x: number, y: number }) => p.x > -cullMargin && p.x < w + cullMargin && p.y > -cullMargin && p.y < h + cullMargin;
+
+      // Connections — one faint line per boundary link (deduped), following
+      // the actual graph structure, so merged and newly-created nodes read
+      // correctly wherever they sit.
+      //
+      // In `field` mode this is the whole of how space is drawn, and it is
+      // one path stroked once rather than a stroke per connection — a lattice
+      // wired in every direction has too many of them for anything else. Only
+      // the axis-aligned ones are taken: the diagonals are just as real, but
+      // drawing all twenty-six through every point is a grey fill you can
+      // read nothing off, where three lines through every point is a grid
+      // whose bending is the thing worth seeing.
+      // Faint enough to be the paper rather than the drawing: what the
+      // lattice is here for is to be bent, and reading a bend needs only
+      // enough of a grid to see it against.
+      ctx.strokeStyle = field ? "rgba(124,136,176,0.05)" : "rgba(140,150,180,0.3)";
+      ctx.lineWidth = field ? 1 : 2.2;
+      const idxOf = new Map<node, number>();
+      graph.nodes.forEach((nd, i) => idxOf.set(nd, i));
+
+      if (field) ctx.beginPath();
+      for (const nd of graph.nodes) {
+        const a = pts.get(nd);
+        if (!a || a.clipped) continue;
+
+        // Outside the frame there is lattice nothing can reach — the edge
+        // absorbs before anything gets there — so it is a few thousand
+        // segments a frame drawn beyond the edge of the picture.
+        if (field && !graph.inFocus(nd)) continue;
+
+        for (const ray of nd) {
+          for (const bd of ray.boundaries) {
+            const other = bd.target?.at.node;
+            if (!other || other === nd) continue;
+
+            // Each connection drawn once, from its lower-numbered end. This
+            // was a set of "ia-ib" strings, which on a lattice wired in
+            // twenty-six directions is a couple of hundred thousand strings
+            // built and hashed every frame to answer a question two integers
+            // already answer.
+            if (idxOf.get(nd)! > idxOf.get(other)!) continue;
+
+            const b = pts.get(other);
+            if (!b || b.clipped) continue;
+            if (!onScreen(a) && !onScreen(b)) continue;
+
+            if (field) {
+              const from = graph.gridPos.get(nd), to = graph.gridPos.get(other);
+              if (!from || !to) continue;
+
+              // One step, along an axis. Anything longer is a connection that
+              // has closed up over space that was annihilated out from
+              // between its two ends — real, and the reason the two ends are
+              // now near each other, but it is not an event and must not look
+              // like one. They accumulate: every cancellation there has ever
+              // been leaves one behind, permanently, so marking them out puts
+              // a growing web of bright lines over the picture that reads as
+              // things happening everywhere at once and never stopping.
+              //
+              // What they do is already visible without drawing them, because
+              // the layout is solved against them (`relaxedLayout`): they pull
+              // their ends together, and that pulling IS the attraction. So
+              // they are left to act rather than shown acting.
+              const off = from.map((v, i) => to[i] - v);
+              if (off.filter(v => v !== 0).length !== 1) continue;
+              if (Math.max(...off.map(Math.abs)) > 1) continue;
+
+              ctx.moveTo(a.x, a.y);
+              ctx.lineTo(b.x, b.y);
+              continue;
+            }
+
+            ctx.beginPath();
+            ctx.moveTo(a.x, a.y);
+            ctx.lineTo(b.x, b.y);
+            ctx.stroke();
+          }
+        }
+      }
+
+      if (field) ctx.stroke();
+
+      // Gravity-flow density cloud — the warm glow that fills the dense
+      // core. A continuous scalar potential sampled on a real 3D grid,
+      // colored on a dark→purple→orange→white ramp and blended additively
+      // so overlapping samples read as one smooth glow. Fully world-space:
+      // every sample is a real coordinate run through the same camera as
+      // the nodes, so it navigates identically.
+      const sources: { pos: Vec; sign: number; w: number }[] = [];
+      for (const nd of density ? graph.nodes : []) {
+        const mv = nd[0] && nd[0].moving;
+        if (!mv) continue;
+        const wpos = layout.get(nd);
+        if (!wpos) continue;
+        // Positive polarity glows one way, Negative the other; neutral space
+        // contributes nothing to pull against.
+        if (mv.polarity === Polarity.Neutral) continue;
+        sources.push({ pos: wpos, sign: mv.polarity === Polarity.Positive ? 1 : -1, w: 1 });
+      }
+      const MAX_SOURCES = 220;
+      if (sources.length > MAX_SOURCES) {
+        sources.sort((x, y) => y.w - x.w);
+        sources.length = MAX_SOURCES;
+      }
+
+      if (sources.length > 0) {
+        const SOFTEN_SQ = (0.6 * worldExtent) ** 2 * 0.02 + 0.04;
+        const gridExtent = worldExtent * 1.05;
+        const RES = 7;
+        const stepG = (gridExtent * 2) / RES;
+        const depthStackCompensation = 1 / (RES * 0.45);
+
+        const densityColor = (t: number, alpha: number) => {
+          t = Math.min(Math.max(t, 0), 1);
+          let r: number, g: number, b: number;
+          if (t < 0.4) { const u = t / 0.4; r = u * 60; g = u * 20; b = u * 70; }
+          else if (t < 0.75) { const u = (t - 0.4) / 0.35; r = 60 + u * 195; g = 20 + u * 95; b = 70 - u * 30; }
+          else { const u = (t - 0.75) / 0.25; r = 255; g = 115 + u * 140; b = 40 + u * 215; }
+          return `rgba(${r | 0},${g | 0},${b | 0},${alpha})`;
+        };
+
+        const samples: { pos: Vec; mag: number }[] = [];
+        let maxMag = 0;
+        const sp: number[] = new Array(3);
+        const build = (axis: number) => {
+          if (axis === 3) {
+            let potential = 0;
+            for (const src of sources) {
+              let distSq = SOFTEN_SQ;
+              for (let k = 0; k < 3; k++) distSq += (src.pos[k] - sp[k]) ** 2;
+              potential += (src.w * src.sign) / distSq;
+            }
+            const mag = Math.max(potential, 0);
+            if (mag > maxMag) maxMag = mag;
+            samples.push({ pos: sp.slice(), mag });
+            return;
+          }
+          for (let i = 0; i < RES; i++) { sp[axis] = -gridExtent + i * stepG + stepG / 2; build(axis + 1); }
+        };
+        build(0);
+
+        const withDepth = samples
+          .map(s => ({ s, proj: project(s.pos, cam.rot, cam.tilt, cam.dist || 1) }))
+          .filter(x => !x.proj.clipped);
+        withDepth.sort((x, y) => y.proj.depth - x.proj.depth);
+
+        const prevComposite = ctx.globalCompositeOperation;
+        ctx.globalCompositeOperation = "lighter";
+        for (const { s, proj } of withDepth) {
+          const { x, y } = place(proj);
+          if (!onScreen({ x, y })) continue;
+          const depthFactor = Math.min(Math.max(proj.depth, 0.3), 1.8);
+          const norm = maxMag > 0 ? Math.min(s.mag / maxMag, 1) : 0;
+          if (norm < 0.015) continue;
+          const radius = (stepG * cam.scale * 0.9 + norm * cam.scale * 0.5) * depthFactor;
+          if (radius < 1.5) continue;
+          const alpha = Math.min(0.05 + norm * 0.35, 0.4) * Math.min(depthFactor, 1) * depthStackCompensation;
+          const grad = ctx.createRadialGradient(x, y, 0, x, y, radius);
+          grad.addColorStop(0, densityColor(norm, alpha));
+          grad.addColorStop(1, densityColor(norm, 0));
+          ctx.fillStyle = grad;
+          ctx.beginPath();
+          ctx.arc(x, y, radius, 0, Math.PI * 2);
+          ctx.fill();
+        }
+        ctx.globalCompositeOperation = prevComposite;
+      }
+
+      /**
+       * The way from one source to the other, as it currently runs.
+       *
+       * Two sources that have eaten the space between them end up one step
+       * apart along ONE route, and as far apart as they ever were along every
+       * other — because what a pulse meeting a pulse destroys is a line, not
+       * a region. That structure has no faithful drawing in three dimensions:
+       * asked to put two points both next to each other and far apart, a
+       * layout can only compromise, and that compromise is the dimple you see
+       * instead of two things arriving.
+       *
+       * So the closeness is drawn as what it actually is — the chain of
+       * points you would have to pass through to get from one source to the
+       * other. Long and wandering to begin with, a short bright link between
+       * two neighbours by the end. That shortening IS the attraction, and it
+       * is visible here whether or not the two are ever drawn near each
+       * other.
+       */
+      if (field && graph.route.length > 1) {
+        const chain = graph.route
+          .map(nd => pts.get(nd))
+          .filter(p => p && !p.clipped) as { x: number, y: number }[];
+
+        if (chain.length > 1) {
+          ctx.strokeStyle = rgba(HALO, 0.45);
+          ctx.lineWidth = 2.4;
+          ctx.lineCap = "round";
+          ctx.beginPath();
+          ctx.moveTo(chain[0].x, chain[0].y);
+          for (let i = 1; i < chain.length; i++) ctx.lineTo(chain[i].x, chain[i].y);
+          ctx.stroke();
+
+          ctx.fillStyle = rgba(SOURCE, 0.8);
+          for (const p of chain) {
+            ctx.beginPath();
+            ctx.arc(p.x, p.y, 2, 0, Math.PI * 2);
+            ctx.fill();
+          }
+
+          ctx.lineCap = "butt";
+        }
+      }
+
+      /**
+       * One surface per pulse: the shells as they were drawn before.
+       *
+       * Each emission is taken on its own and given the outline that encloses
+       * it — split by charge as well as by pulse, because a source with poles
+       * throws opposite charges out of its two halves in the same breath and
+       * collecting them together loses the fact that it has sides at all.
+       *
+       * Not drawn as circles: the outline is taken from where the charges
+       * actually are, so a shell crossing space that has been eaten comes out
+       * dented, which is the thing worth seeing in the examples where the two
+       * magnets are pulling on each other.
+       */
+      if (field && !contours) {
+        const waves = new Map<string, {
+          at: { x: number, y: number }[], depth: number, out: number, polarity: Polarity,
+        }>();
+
+        for (const nd of graph.nodes) {
+          if (!graph.inFocus(nd)) continue;
+
+          for (const ray of nd) {
+            if (ray.magnet || !ray.moving || ray.wave === undefined) continue;
+            if (ray.moving.polarity === Polarity.Neutral) continue;
+
+            const p = pts.get(nd);
+            if (!p || p.clipped) continue;
+
+            const key = `${ray.wave}|${ray.moving.polarity}`;
+
+            let wave = waves.get(key);
+            if (!wave) waves.set(key, wave = {
+              at: [], depth: 0, out: 0, polarity: ray.moving.polarity,
+            });
+
+            wave.at.push({ x: p.x, y: p.y });
+            wave.depth += p.depth;
+
+            const wp = layout.get(nd);
+            if (wp) wave.out += Math.hypot(...wp) / ((graph.focus ?? 12) * LATTICE_STEP);
+
+            break;
+          }
+        }
+
+        const shells = [...waves.values()]
+          .filter(wave => wave.at.length >= 3)
+          .map(wave => ({
+            hull: outline(wave.at),
+            depth: wave.depth / wave.at.length,
+            out: Math.min(wave.out / wave.at.length, 1),
+            polarity: wave.polarity,
+          }))
+          .filter(shell => shell.hull.length >= 3)
+          // Far ones first, so a near shell reads as in front of one behind
+          // it rather than the two adding up.
+          .sort((a, b) => b.depth - a.depth);
+
+        const prev = ctx.globalCompositeOperation;
+        ctx.globalCompositeOperation = "lighter";
+
+        for (const shell of shells) {
+          const tint = channels(tintOf(shell.polarity));
+          const h = shell.hull;
+          const at = (i: number) => h[(i % h.length + h.length) % h.length];
+
+          // A smooth closed curve rather than the corners it was computed
+          // from: the straight lines between them are an artefact of there
+          // being finitely many charges, and drawing those claims the shell
+          // has facets and edges, which nothing supports.
+          ctx.beginPath();
+          ctx.moveTo(h[0].x, h[0].y);
+
+          for (let i = 0; i < h.length; i++) {
+            const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
+
+            ctx.bezierCurveTo(
+              p1.x + (p2.x - p0.x) / 6, p1.y + (p2.y - p0.y) / 6,
+              p2.x - (p3.x - p1.x) / 6, p2.y - (p3.y - p1.y) / 6,
+              p2.x, p2.y,
+            );
+          }
+
+          ctx.closePath();
+
+          // Bright where it was emitted, faint by the time it is far out — a
+          // wave spreading the same charge over a larger and larger surface.
+          const lift = Math.max(1 - shell.out, 0);
+          const fade = 0.1 + lift * lift * 0.9;
+
+          ctx.fillStyle = `rgba(${tint},${0.06 * fade})`;
+          ctx.fill();
+
+          ctx.strokeStyle = `rgba(${tint},${0.55 * fade})`;
+          ctx.lineWidth = 1.2;
+          ctx.stroke();
+        }
+
+        ctx.globalCompositeOperation = prev;
+      }
+
+      /**
+       * ONE of two ways of drawing the same charges, and they answer
+       * different questions.
+       *
+       * `shells` draws each pulse: one surface per emission, so what you see
+       * is the source letting go of shell after shell and each of them
+       * travelling. It is the honest picture of a thing that emits, and for a
+       * source that only flips over it is the whole story, since every shell
+       * is the same in every direction and there is nothing else to say about
+       * one.
+       *
+       * `field` draws what the pulses add up to: the region where the field
+       * is one charge and the region where it is the other, with the boundary
+       * between them. For a source that TURNS, that is the only way to see
+       * what it is doing — a turning source lays down a spiral, and a spiral
+       * is a property of a whole train of shells and of none of them
+       * separately. Drawn shell by shell it is a stack of lobes, and the
+       * winding they make is nowhere in the picture.
+       *
+       * Two surfaces. Not two hundred.
+       *
+       * A charge at distance r in direction θ left r cells ago, when the
+       * magnet's north pole pointed at α − ωr rather than at α. So its sign
+       * depends on θ − ωr: the positive charges are one Archimedean spiral
+       * winding out from the source, and the negative ones fill exactly the
+       * gaps between its turns. One body each, connected from the middle to
+       * the edge, and neither is ever where the other is.
+       *
+       * Drawing per pulse guarantees the one thing that must not happen. A
+       * pulse is a ring, so a picture made of pulses is a stack of rings
+       * lying across one another — when what is actually there is two
+       * interleaved spirals that never cross at all.
+       *
+       * So the outline is still an outline, drawn exactly as the shells were:
+       * a smooth closed curve, barely filled, its own colour at the edge,
+       * fading with distance. What changed is what it goes round. Instead of
+       * enclosing the charges of one pulse, it follows the edge of the region
+       * where the field has that sign — which is found by reconstructing the
+       * field from the charges and walking the line along which it crosses.
+       * The result is one curve per body rather than one per pulse, it is
+       * shaped like the body (so it winds, because the body winds), and two
+       * of them can no more overlap than a place can be both positive and
+       * negative.
+       */
+      if (contours) {
+        const CELL = 4;                                 // pixels per sample
+        const cols = Math.max(Math.ceil(w / CELL), 1);
+        const rows = Math.max(Math.ceil(h / CELL), 1);
+
+        const sum = new Float32Array(cols * rows);
+        const weight = new Float32Array(cols * rows);
+        const near = new Float32Array(cols * rows);
+        const cut = new Float32Array(cols * rows);
+
+        /**
+         * The average over a square neighbourhood, however wide, for the
+         * price of one.
+         *
+         * A running total gives every sample the mean over its whole
+         * neighbourhood in one pass per axis, where a diffusion of the same
+         * width costs passes going as the square of it. It is a cruder shape
+         * of average than the smoothing the picture is drawn from, and it is
+         * used only where nothing is drawn from it — spreading the directions
+         * the charges are travelling in, and deciding how hard to press. Both
+         * are decisions about the field rather than the field, and there is
+         * no such thing as a square edge on a decision.
+         */
+        const scratch = new Float32Array(cols * rows);
+
+        const box = (a: Float32Array, r: number) => {
+          const clampX = (x: number) => Math.min(Math.max(x, 0), cols - 1);
+          const clampY = (y: number) => Math.min(Math.max(y, 0), rows - 1);
+          const n = 2 * r + 1;
+
+          for (let y = 0; y < rows; y++) {
+            const row = y * cols;
+            let acc = 0;
+
+            for (let x = -r; x <= r; x++) acc += a[row + clampX(x)];
+
+            for (let x = 0; x < cols; x++) {
+              scratch[row + x] = acc / n;
+              acc += a[row + clampX(x + r + 1)] - a[row + clampX(x - r)];
+            }
+          }
+
+          for (let x = 0; x < cols; x++) {
+            let acc = 0;
+
+            for (let y = -r; y <= r; y++) acc += scratch[clampY(y) * cols + x];
+
+            for (let y = 0; y < rows; y++) {
+              a[y * cols + x] = acc / n;
+              acc += scratch[clampY(y + r + 1) * cols + x] - scratch[clampY(y - r) * cols + x];
+            }
+          }
+        };
+
+        /**
+         * How far one charge speaks for, and it is bounded on both sides.
+         *
+         * Too small and the charges never meet: the region comes apart into
+         * one little ring per charge, which is the picture of points that
+         * keeps coming back. Too large and a band bleeds into the next band
+         * round, the alternation averages itself away, and there is one grey
+         * body instead of two winding ones.
+         *
+         * The right size is set by the winding itself, and the winding here
+         * is the one `every: undefined` above settles on: a shell leaves
+         * every tick, the wave advances a cell a tick, and the source comes
+         * round an eighth of a turn in between. So a whole turn is CYCLE
+         * cells out from the source and a band of one sign is half of that —
+         * four cells thick, with four cells of the other sign beyond it.
+         */
+        const step = cam.scale * LATTICE_STEP;          // pixels per cell
+        const band = (CYCLE / 2) * step / CELL;         // samples across one band
+
+        /**
+         * And it reaches much further across a charge's path than along it.
+         *
+         * A round reach has to be a compromise between two things that want
+         * opposite sizes. The holes to be closed are the gaps between charges
+         * of one shell, which open up as the shell grows and are the reason
+         * the arcs come out as strings of islands; closing them wants a
+         * generous reach. What must not be closed is the gap between one
+         * shell and the next, which is where the alternation lives, since a
+         * shell four along is the opposite charge; keeping that wants a mean
+         * one. Round, there is no size that does both, and the picture is
+         * either beads or porridge.
+         *
+         * But the two gaps are not in the same direction, and the direction
+         * that tells them apart is the one the charges are travelling in. A
+         * shell is spread out ACROSS its own motion — every part of it left
+         * together and is the same age and the same charge — and the next
+         * shell is one cell AHEAD. So the reach is an ellipse laid across the
+         * path: long the way the shell runs, short the way it is going.
+         * Nothing is invented by this. It is a statement about which charges
+         * are neighbours, and a charge's neighbours are the ones off its
+         * shoulders rather than the one in front.
+         *
+         * The short axis is the delicate one, and it is why merging with any
+         * generosity in the direction of travel was wrong. Four shells make
+         * one band, so a reach of much over a cell forward joins a charge to
+         * shells that are still its own sign, which is wanted; a reach of
+         * four joins it to the opposite one, which averages the alternation
+         * away and is how a set of arcs turns into a disc.
+         *
+         * A cell, then, and not a cell and a half. Every fraction past the
+         * spacing between two shells is spent averaging a band against the
+         * one beyond it, and that cost is paid over the whole width of the
+         * seam rather than at the seam: a reach of a cell and a half puts
+         * three cells of a four-cell band within sight of the other charge
+         * and there is very little of it left reading as wholly one thing. At
+         * exactly the spacing the shells of a band still touch — which is all
+         * that is needed for it to be one body, the closing along each shell
+         * being what actually mends it — and a charge's reach stops dead
+         * before anything of the other sign.
+         */
+        const across = Math.max(band / 4.5, 1.2);           // the way it is going
+        const along = Math.max(band * 1.15, across * 3);    // the way it is spread
+
+        // Where each source is on the screen, which is what "out from it"
+        // means. Anything with no source of its own is measured from the
+        // middle of the picture.
+        const origin = new Map<number, { x: number, y: number }>();
+
+        for (const nd of graph.nodes) {
+          for (const ray of nd) {
+            if (!ray.magnet || ray.source === undefined) continue;
+
+            const p = pts.get(nd);
+            if (p && !p.clipped) origin.set(ray.source, { x: p.x, y: p.y });
+          }
+        }
+
+        // How far out each part of the picture is from the nearest source,
+        // and which way that is — the fallback frame, for the places no
+        // charge has an opinion about.
+        const outX = new Float32Array(cols * rows);
+        const outY = new Float32Array(cols * rows);
+        const rad = new Float32Array(cols * rows);
+
+        {
+          const from = origin.size
+            ? [...origin.values()].map(p => ({ x: p.x / CELL, y: p.y / CELL }))
+            : [{ x: cols / 2, y: rows / 2 }];
+
+          for (let y = 0; y < rows; y++) {
+            for (let x = 0; x < cols; x++) {
+              let dx = 1, dy = 0, len = Infinity;
+
+              for (const s of from) {
+                const ex = x - s.x, ey = y - s.y;
+                const d = Math.hypot(ex, ey);
+
+                if (d < len) { len = d; dx = ex; dy = ey; }
+              }
+
+              const i = y * cols + x;
+
+              rad[i] = len;
+
+              if (len > 1e-6) { outX[i] = dx / len; outY[i] = dy / len; }
+              else { outX[i] = 1; outY[i] = 0; }
+            }
+          }
+        }
+
+        /**
+         * Which way the field runs, taken from the charges rather than
+         * supposed of them.
+         *
+         * Everything here that closes a gap or opens one needs to know which
+         * way the thing it is working on lies — the kernel, so it can be an
+         * ellipse; the smoothing and the bridging, so they run along a body
+         * and not across one; the sharpening, so it cuts between two and not
+         * through the middle of either.
+         *
+         * And the answer is not a shape to be assumed. Supposing the bodies
+         * are rings and merging round the source draws rings; supposing they
+         * are spirals of a particular pitch and merging along that draws
+         * those. Both are the picture telling you what it was told. Worse,
+         * merging the way the charges are GOING joins each one to the one in
+         * front of it, which is the one that left a tick earlier — so a band
+         * gets knitted together from the inside out, across the very
+         * direction its polarity alternates in, and the alternation is what
+         * gets averaged away.
+         *
+         * What a charge is actually beside is what left with it. A shell is
+         * one emission, every part of it the same age and the same charge,
+         * and it is spread out ACROSS the way it travels — so the neighbours
+         * of a charge are the ones off its shoulders, and the thing in front
+         * of it is a different shell of possibly the other sign. Merge
+         * orthogonal to the motion and each shell closes into the arc it is;
+         * a source that only flips gives rings, a source that turns gives
+         * arcs each rotated from the last, which is a spiral. Neither is
+         * imposed. Both come out of the same rule, which is a statement about
+         * which charges are neighbours and says nothing about shape.
+         *
+         * Kept as a doubled angle so it can be averaged at all. These are
+         * lines rather than arrows — a charge going one way and a charge
+         * coming back lie along the same line and belong together — and
+         * averaging arrows would have the two cancel to nothing exactly where
+         * two shells meet. Doubling the angle makes opposites identical,
+         * which is what they are here, and halving it back afterwards
+         * recovers the line.
+         */
+        const spinA = new Float32Array(cols * rows);   // cos of the doubled angle
+        const spinB = new Float32Array(cols * rows);   // sin of it
+        const spinW = new Float32Array(cols * rows);
+
+        const runX = new Float32Array(cols * rows);
+        const runY = new Float32Array(cols * rows);
+
+        for (const nd of graph.nodes) {
+          if (!graph.inFocus(nd)) continue;
+
+          for (const ray of nd) {
+            if (ray.magnet || !ray.moving) continue;
+            if (ray.moving.polarity === Polarity.Neutral) continue;
+
+            const p = pts.get(nd);
+            if (!p || p.clipped) continue;
+
+            const cx = p.x / CELL, cy = p.y / CELL;
+            const sign = ray.moving.polarity === Polarity.Positive ? 1 : -1;
+
+            const wp = layout.get(nd);
+            const out = wp
+              ? Math.min(Math.hypot(...wp) / ((graph.focus ?? 12) * LATTICE_STEP), 1)
+              : 0;
+
+            // How far out it is, which is only used to keep the reach inside
+            // the arc there is to reach along.
+            const from = origin.get(ray.source ?? 0);
+            let ox = from ? cx - from.x / CELL : 0;
+            let oy = from ? cy - from.y / CELL : 0;
+            const len = Math.hypot(ox, oy);
+
+            if (len > 1e-6) { ox /= len; oy /= len; } else { ox = 1; oy = 0; }
+
+            /**
+             * And which way it is going, on the screen, which is the one
+             * thing the ellipse is oriented by.
+             *
+             * `heading` first: that is the direction in the large, and a step
+             * is only this tick's piece of it. Where there is no heading —
+             * nothing wanders in these examples, so most of the time — the
+             * step and the direction are the same thing and the point ahead
+             * says it exactly.
+             *
+             * Projected rather than taken from the lattice, because what is
+             * being drawn is the screen. A charge travelling straight at the
+             * camera has no direction in the picture at all, and its shell is
+             * a face-on ring around it there; the projection says so by
+             * coming out at nothing, and the fallback is the frame from the
+             * source, which is that ring.
+             */
+            let mx = 0, my = 0;
+
+            if (wp && ray.heading) {
+              const t = screenOf(wp.map((v, i) => v + (ray.heading![i] || 0) * LATTICE_STEP));
+
+              mx = t.x - p.x; my = t.y - p.y;
+            }
+
+            if (mx === 0 && my === 0 && ray.moving.target) {
+              const q = pts.get(ray.moving.target.at.node);
+
+              if (q && !q.clipped) { mx = q.x - p.x; my = q.y - p.y; }
+            }
+
+            const ml = Math.hypot(mx, my);
+
+            // Across the way it is going: the shoulders of its own shell.
+            let rx: number, ry: number;
+
+            if (ml > 1e-3) { rx = -my / ml; ry = mx / ml; }
+            else { rx = -oy; ry = ox; }
+
+            // Which is then remembered, so that the places between the
+            // charges can be given the same answer as the charges around
+            // them. See the doubled angle above.
+            {
+              const i0 = Math.min(Math.max(Math.round(cy), 0), rows - 1) * cols
+                + Math.min(Math.max(Math.round(cx), 0), cols - 1);
+
+              spinA[i0] += rx * rx - ry * ry;
+              spinB[i0] += 2 * rx * ry;
+              spinW[i0] += 1;
+            }
+
+            /**
+             * And it reaches no further along than there is arc to reach
+             * along.
+             *
+             * A band covers half a turn, so at radius r it is about πr long,
+             * and at one or two cells out that is shorter than the reach
+             * itself. Sweeping the full ellipse there does not join a shell
+             * to itself, it joins it right round to the next one — which is
+             * the opposite charge, and the two average away into the grey
+             * disc that the middle of these pictures kept coming out as.
+             *
+             * So the long axis is held to the arc it is supposed to be lying
+             * on. Far out that is the reach as given; close in it shrinks
+             * with the radius until the ellipse is barely longer than it is
+             * wide, which is right — near the source there are no gaps to
+             * close, the charges are on top of each other.
+             */
+            const reach = Math.max(Math.min(along, len * 0.8), across);
+            const span = Math.ceil(reach);
+
+            for (let y = Math.max(Math.floor(cy - span), 0); y <= Math.min(Math.ceil(cy + span), rows - 1); y++) {
+              for (let x = Math.max(Math.floor(cx - span), 0); x <= Math.min(Math.ceil(cx + span), cols - 1); x++) {
+                const dx = x - cx, dy = y - cy;
+
+                // Split into how far along the arm and how far off it, and
+                // measure each against its own reach.
+                const round2 = dx * rx + dy * ry;
+                const out2 = dx * -ry + dy * rx;
+
+                const d = Math.hypot(out2 / across, round2 / reach);
+                if (d >= 1) continue;
+
+                // Smooth to nothing at the edge of its reach, so no charge
+                // leaves a rim of its own in the field.
+                const k = (1 - d * d) ** 2;
+                const i = y * cols + x;
+
+                sum[i] += sign * k;
+                weight[i] += k;
+                if (1 - out > near[i]) near[i] = 1 - out;
+              }
+            }
+
+            /**
+             * Two charges moving into each other are never one thing.
+             *
+             * They are about to meet — next tick they cancel, or they turn
+             * each other round — and the whole meaning of that is that they
+             * came from different places and are arriving at each other. A
+             * body cannot be approaching itself. Yet nothing said so: the
+             * field is built from where charges are and not from where they
+             * are going, so two shells closing on one another read as one
+             * thick region of the same charge, with the interface that is
+             * about to be an event drawn straight through its middle as if it
+             * were the inside of something.
+             *
+             * So the place between them is cut. Where a charge is moving into
+             * a point that holds a charge coming back at it, the field is
+             * held to nothing along the line between the two — and a boundary
+             * is what gets drawn there, which is what puts them in different
+             * islands and keeps them there right up until the tick where they
+             * resolve.
+             */
+            const ahead = ray.moving.target?.at.node;
+
+            if (ahead && ahead !== nd
+              && ahead.some(x => x.moving?.target?.at.node === nd)) {
+              const q = pts.get(ahead);
+
+              if (q && !q.clipped) {
+                const mx = (p.x + q.x) / 2 / CELL, my = (p.y + q.y) / 2 / CELL;
+
+                /**
+                 * And what is put there is a seam, not a bite.
+                 *
+                 * The thing between two charges arriving at each other is an
+                 * interface — it has the two of them on either side of it and
+                 * it extends sideways, the way the two fronts do. Marked with
+                 * a disc instead, it takes a round hole out of whichever band
+                 * the pair happen to be sitting in, and a band with a dozen
+                 * such pairs along it is a band with a dozen holes punched
+                 * through it: the arm falls apart into the pieces between
+                 * them, and the pieces read as islands.
+                 *
+                 * Thin the way they are approaching and wide the way they are
+                 * not, it does the one thing it was for — the two of them end
+                 * up on opposite sides of a line — and it does not cost the
+                 * arm its continuity to do it.
+                 */
+                let jx = q.x - p.x, jy = q.y - p.y;
+                const jl = Math.hypot(jx, jy) || 1;
+
+                jx /= jl; jy /= jl;
+
+                const thin = Math.max(across / 4, 0.8);
+                const broad = Math.max(across, 2);
+                const bite = Math.ceil(broad);
+
+                for (let y = Math.max(Math.floor(my - bite), 0); y <= Math.min(Math.ceil(my + bite), rows - 1); y++) {
+                  for (let x = Math.max(Math.floor(mx - bite), 0); x <= Math.min(Math.ceil(mx + bite), cols - 1); x++) {
+                    const ex = x - mx, ey = y - my;
+
+                    const d = Math.hypot(
+                      (ex * jx + ey * jy) / thin,
+                      (ex * -jy + ey * jx) / broad,
+                    );
+                    if (d >= 1) continue;
+
+                    const k = (1 - d * d) ** 2;
+                    const i = y * cols + x;
+
+                    if (k > cut[i]) cut[i] = k;
+                  }
+                }
+              }
+            }
+
+            break; // one sample per point, however many rays are on it
+          }
+        }
+
+        /**
+         * And spread out over the places between them, so that the frame is
+         * something the whole picture has rather than something only the
+         * charges have.
+         *
+         * Averaged over about the width one charge speaks for, which is the
+         * distance at which two charges are meant to be part of the same
+         * thing anyway. Where a shell runs, its own members all say the same
+         * and the average is that; where two shells cross, they disagree and
+         * it comes out short, which is exactly a place with no one direction
+         * to it and is treated as one.
+         */
+        {
+          // Wide enough to have an answer in the gaps, which is where it is
+          // wanted: a place with no charge in it is the very place that needs
+          // to be told which way the thing running through it lies.
+          const smear = Math.max(Math.round(along * 0.6), 2);
+
+          box(spinA, smear);
+          box(spinB, smear);
+          box(spinW, smear);
+
+          for (let i = 0; i < runX.length; i++) {
+            const mag = Math.hypot(spinA[i], spinB[i]);
+
+            // Nothing said anything here, or what was said cancelled out.
+            // Both are the same answer: fall back to the shape of a shell
+            // around the nearest source, which is what a place with no
+            // direction of its own is nearest to being part of.
+            if (spinW[i] < 1e-4 || mag < spinW[i] * 0.15) {
+              runX[i] = -outY[i]; runY[i] = outX[i];
+              continue;
+            }
+
+            const a = 0.5 * Math.atan2(spinB[i], spinA[i]);
+
+            runX[i] = Math.cos(a); runY[i] = Math.sin(a);
+          }
+        }
+
+        /**
+         * How positive or negative each part of the picture is: +1 well
+         * inside an amber band, −1 well inside a cyan one, and nothing where
+         * no charge reaches or where the two meet.
+         *
+         * Divided by a little more than the weight actually there, which is
+         * the difference between how positive a place is and how sure of it
+         * the picture can be. Dividing by the weight exactly says a place
+         * with one charge in it is as wholly positive as a place with twenty
+         * — so a charge that has come adrift from everything, out ahead of
+         * its shell or left behind by it, reads at full strength and is
+         * traced as a little closed body of its own. Every one of those is an
+         * island, and they are the ones with nothing in them.
+         *
+         * The extra in the divisor is worth about a charge's own weight. One
+         * charge on its own then reads at a third of what a band reads, which
+         * is under the level anything is traced at, and it goes back to being
+         * what it is: a faint mark in the field rather than a body. Nothing
+         * is thrown away — twenty of them together still read as twenty, and
+         * a thin arm far out is still an arm. It is a preference for what is
+         * supported over what is isolated, applied to the reading rather than
+         * to the drawing.
+         */
+        const trust = 0.9;
+
+        const target = new Float32Array(cols * rows);
+        const known = new Uint8Array(cols * rows);
+
+        for (let i = 0; i < target.length; i++) {
+          if (weight[i] <= 0) continue;
+
+          target[i] = Math.max(Math.min(sum[i] / (weight[i] + trust), 1), -1);
+          known[i] = 1;
+        }
+
+        /**
+         * Places no charge reached take the value their surroundings imply.
+         *
+         * A charge is a sample of the field, not the extent of it. Where two
+         * of them happen to fall a little far apart the reading in between is
+         * not "no field" — it is a place nothing was measured, and treating
+         * unmeasured as zero puts a boundary through the middle of a band
+         * wherever the sampling thinned. That is what the holes in the arms
+         * are: not gaps in the field, gaps in the record of it.
+         *
+         * So a value is grown into them from their edges, a ring at a time,
+         * and each takes the average of whatever is already known beside it.
+         * Somewhere with amber on all sides fills in amber, and the band
+         * closes; somewhere between amber and cyan fills in with what is
+         * between them, which is nothing, and the boundary stays exactly
+         * where it was. Only a few rings of it, so a genuinely empty part of
+         * the world stays empty rather than being papered over.
+         */
+        /**
+         * And pressed a good deal further than a few rings, at the price of
+         * getting stricter about what counts as a gap.
+         *
+         * The two things it must not do are grow a band outwards into the
+         * empty space past the wavefront, and grow one band into the next.
+         * The second is already handled — disagreeing neighbours are refused
+         * below — and the first is what the small number of passes was really
+         * buying: an edge grows one ring per pass just as a hole fills one
+         * ring per pass, so the only thing keeping the outside of the picture
+         * from creeping outwards was stopping early, which also stopped every
+         * hole halfway through being mended.
+         *
+         * Told apart instead of traded off. A place inside a hole has known
+         * neighbours nearly all round it; a place just outside the edge of
+         * something has them on one side only. So the first few passes take
+         * anything with two — that is a crack one sample wide, and closing
+         * those is most of what closing is — and every pass after that wants
+         * three of four, which a hole has and an edge never does. Then the
+         * filling can run until it has nothing left to fill.
+         */
+        for (let pass = 0; pass < 16; pass++) {
+          const grown: [number, number][] = [];
+          const need = pass < 3 ? 2 : 3;
+
+          for (let y = 1; y + 1 < rows; y++) {
+            for (let x = 1; x + 1 < cols; x++) {
+              const i = y * cols + x;
+              if (known[i]) continue;
+
+              let total = 0, n = 0, warm = 0, cold = 0;
+
+              for (const j of [i - 1, i + 1, i - cols, i + cols]) {
+                if (!known[j]) continue;
+
+                total += target[j];
+                n++;
+
+                if (target[j] > 0.05) warm++;
+                else if (target[j] < -0.05) cold++;
+              }
+
+              /**
+               * Filled only where its surroundings agree.
+               *
+               * Averaging whatever is beside it is right in the middle of a
+               * band and wrong on the edge of one. A place with amber on one
+               * side and cyan on the other is not a hole in either — it is
+               * the seam between them, and filling it with the average is
+               * filling it with something halfway, which is a step towards
+               * one band and the next one out becoming a single band. Enough
+               * of those and the layers close up into each other and the
+               * winding goes.
+               *
+               * So a gap is only closed from the inside. Where the known
+               * neighbours are all of one charge it fills with that charge
+               * and the band mends; where they disagree it is left as it is,
+               * because what is there is a boundary and a boundary is
+               * supposed to be empty.
+               */
+              if (warm && cold) continue;
+
+              if (n >= need) grown.push([i, total / n]);
+            }
+          }
+
+          if (!grown.length) break;
+
+          // All of them at once, so a ring fills from the ring outside it
+          // rather than from itself half-filled.
+          for (const [i, v] of grown) { target[i] = v; known[i] = 1; }
+        }
+
+        /**
+         * Eased from the last frame rather than replaced.
+         *
+         * The world only changes on a tick, and a tick is a whole cell — a
+         * charge is here, and then it is a cell further out, with nothing in
+         * between because there is nothing in between to be in. Drawn
+         * directly, the picture stands still for a fifth of a second and then
+         * jumps, which is honest about the model and awful to watch: the eye
+         * reads the jump instead of the movement.
+         *
+         * The FIELD, though, is a continuous quantity — how positive a place
+         * is — and there is nothing wrong with a place becoming more positive
+         * gradually. So the drawn field walks towards the true one a fraction
+         * each frame instead of arriving at it at once. A band that moves one
+         * cell out fades out of where it was and into where it has got to,
+         * and what you see is the wave travelling rather than a slideshow of
+         * where it has been.
+         *
+         * It is a property of the drawing and not of the model. Nothing here
+         * is fed back into the dynamics, and a still of any frame is the same
+         * picture the unsmoothed version would have reached a moment later.
+         */
+        if (!eased || eased.length !== target.length) eased = target.slice();
+        else for (let i = 0; i < eased.length; i++)
+          eased[i] += (target[i] - eased[i]) * 0.2;
+
+        /**
+         * And smoothed along itself before anything is traced from it.
+         *
+         * The field is built by dropping a kernel at every charge, so it
+         * carries the charges in it: little bumps where one landed, little
+         * dips between two, all at the scale of a single lattice cell. A line
+         * traced through that follows every one of them, and the arm comes
+         * out scalloped — which is not the shape of the arm, it is the shape
+         * of the fact that it was measured at points.
+         *
+         * A few passes of each sample settling towards the ones on either
+         * side of it takes that out. Which two are "on either side" is the
+         * whole question, and it is the same answer as everywhere else here:
+         * the ones further along the band, not the ones further out from the
+         * source. Settling towards the neighbours in every direction equally
+         * pulls each band towards the two of the other sign it lies between,
+         * so the alternation is worn down at exactly the rate the gaps in it
+         * are closed, and there is no number of passes that gets one without
+         * the other. Settling along the band only, the arm knits together
+         * down its own length and nothing at all happens across it.
+         *
+         * That is the preference, in one line: a place takes after what
+         * continues through it. A neck between two lumps of one arm has arm
+         * on both sides along the way it runs and fills in; a speck with
+         * nothing either side of it has nothing to take after and fades.
+         * Neither is decided in advance — it is read off which way the thing
+         * is going where it is.
+         */
+        // On a copy, never on the eased field itself: that one is carried
+        // from frame to frame, and smoothing something that is then smoothed
+        // again next frame is not a smoothing, it is a slow erasure — after a
+        // few seconds there would be nothing left of the field at all.
+        const f = eased.slice();
+
+        // The field between its samples, so a step of a fraction of one is a
+        // step rather than a rounding — the directions below are not the
+        // grid's and almost never land on it.
+        const sample = (a: Float32Array, x: number, y: number) => {
+          const px = Math.min(Math.max(x, 0), cols - 1);
+          const py = Math.min(Math.max(y, 0), rows - 1);
+
+          const x0 = Math.floor(px), y0 = Math.floor(py);
+          const x1 = Math.min(x0 + 1, cols - 1), y1 = Math.min(y0 + 1, rows - 1);
+          const fx = px - x0, fy = py - y0;
+
+          return (a[y0 * cols + x0] * (1 - fx) + a[y0 * cols + x1] * fx) * (1 - fy)
+            + (a[y1 * cols + x0] * (1 - fx) + a[y1 * cols + x1] * fx) * fy;
+        };
+
+        // One pass of it, in whichever of the two directions is asked for.
+        const drift = (a: Float32Array, passes: number, reach: number, round: boolean) => {
+          const next = new Float32Array(a.length);
+
+          for (let pass = 0; pass < passes; pass++) {
+            for (let y = 0; y < rows; y++) {
+              for (let x = 0; x < cols; x++) {
+                const i = y * cols + x;
+
+                // Held to the arm there is, close in, for the same reason the
+                // kernel's long axis is.
+                const r = round ? Math.min(reach, rad[i] * 0.5) : reach;
+
+                const dx = (round ? runX[i] : -runY[i]) * r;
+                const dy = (round ? runY[i] : runX[i]) * r;
+
+                next[i] = (
+                  a[i] * 2
+                  + sample(a, x + dx, y + dy)
+                  + sample(a, x - dx, y - dy)
+                ) / 4;
+              }
+            }
+
+            a.set(next);
+          }
+
+          return a;
+        };
+
+        drift(f, 10, 1.8, true);
+
+        /**
+         * Where the alternation actually is, before anything is done that
+         * could cost some of it.
+         *
+         * Everything from here on is one of two opposite pressures. Closing a
+         * gap wants a place to take after what is around it; keeping the
+         * winding wants a place to stay unlike what is around it. Applied at
+         * one strength everywhere, they are the beads-or-porridge choice
+         * again in a different guise, and whichever is turned up wrecks the
+         * half of the picture the other was for.
+         *
+         * But which of the two a place needs is a thing that can be looked
+         * at. Somewhere in the body of a band has one charge all round it out
+         * to the distance the bands repeat over; somewhere between two has
+         * both, in comparable amounts. So: how much of each is nearby, and
+         * how near they come to being equal.
+         *
+         * Measured on the field rather than assumed from the geometry, which
+         * matters where the geometry is not the whole story — near a source,
+         * where the arms have not separated yet, or out where two magnets'
+         * fields have run into each other and the alternation is nothing so
+         * tidy as one spiral's. Where there IS alternation it is protected,
+         * wherever it came from and whichever way round it lies. Where there
+         * is none, there is nothing to protect and the gaps can be closed as
+         * hard as it takes.
+         */
+        const alt = new Float32Array(f.length);
+
+        {
+          const warm = new Float32Array(f.length);
+          const cold = new Float32Array(f.length);
+
+          for (let i = 0; i < f.length; i++) {
+            warm[i] = Math.max(f[i], 0);
+            cold[i] = Math.max(-f[i], 0);
+          }
+
+          // Out to most of the way to the next band, which is the scale the
+          // question is being asked at. A cell either side finds alternation
+          // only where the two are already touching; two thirds of a band
+          // finds it while there is still something between them, which is
+          // while there is still something to keep.
+          const look = Math.max(Math.round(band / 2.2), 2);
+
+          box(warm, look);
+          box(cold, look);
+
+          for (let i = 0; i < f.length; i++) {
+            const lo = Math.min(warm[i], cold[i]);
+            const hi = Math.max(warm[i], cold[i]);
+
+            // Nothing at all nearby is not alternation; it is emptiness, and
+            // emptiness gets closed like anything else.
+            alt[i] = hi > 1e-3 ? Math.min((2 * lo) / (lo + hi) * 2.8, 1) : 0;
+          }
+        }
+
+        /**
+         * And then the gaps are bridged outright, rather than diffused shut.
+         *
+         * Smoothing along an arm closes a gap by moving what is on either
+         * side of it into the middle, which means the middle ends up weaker
+         * than either side — and a gap wide enough to be worth closing ends
+         * up filled with something under the level anything is traced at. The
+         * hole is smaller and blurrier and still a hole. Pushing the
+         * smoothing harder to get through it takes the arm's own strength
+         * down with it, because a diffusion cannot tell which of its
+         * neighbours it is supposed to be taking after.
+         *
+         * A gap is not an average, though. It is a place where something
+         * runs THROUGH — the arm arrives at one side of it and leaves from
+         * the other — and that is a thing to test for rather than to hope
+         * comes out of an average. So each place looks out along the band,
+         * both ways at once, for a distance the same charge is found in both
+         * directions, and takes the weaker of the two.
+         *
+         * Both ways at once is the whole of what makes it safe. A speck with
+         * nothing either side of it finds nothing that agrees and is left as
+         * it is; the far end of an arm finds arm behind it and empty space
+         * ahead and is not extended past where it ends; a seam between two
+         * bands has opposite signs across it and never had them along it, so
+         * it is not something this can reach through. Only a place with the
+         * same thing on both sides of it is filled, and a place with the same
+         * thing on both sides of it is the inside of an arm.
+         *
+         * Taking the weaker end rather than the stronger keeps it honest: a
+         * bridge is only ever as much as the thinner of the two things it
+         * joins, so a wisp joined to a bright arm does not come out bright.
+         *
+         * And the looking stops at the first thing of the other charge it
+         * meets, rather than running the whole way and asking about the far
+         * end. That is the one way this could do damage — a stripe of the
+         * other charge lying across the arm, with more arm beyond it, is two
+         * things with something between them and not one thing with a gap in
+         * it, and reaching over the stripe would paint it out. Stopped at it,
+         * the two sides come back disagreeing and nothing happens. So the
+         * alternation is not weighed against the closing here; it is simply
+         * in the way of it, which is what alternation ought to be.
+         */
+        /**
+         * And it is a preference for that direction, not a rule about it.
+         *
+         * A shell is not a perfect arc. It is a couple of dozen directions
+         * off a lattice, fanning as they go and passing through space that
+         * other charges have been eating, so the line through its members
+         * wanders by some tens of degrees from the one thing perpendicular to
+         * any one of them. Looking along a single exact direction, half the
+         * gaps in it are at an angle to what is being looked down and are
+         * missed — while looking down a wide fan of directions at once finds
+         * the next shell as readily as its own, which is the merge along the
+         * path that must not happen.
+         *
+         * So each pass looks slightly differently: straight across the path,
+         * then a little to one side of that, then a little to the other. A
+         * gap that lies square on is closed by the first and closed again by
+         * the other two; one on a slant is closed by whichever pass is
+         * pointing at it; nothing anywhere gets a look down the path itself,
+         * which is off the end of the fan in both directions. Preference by
+         * how much of the ink each direction gets, which is what a preference
+         * is, rather than by which directions exist.
+         */
+        const bridge = (a: Float32Array, taps: number, reach: number, tilt: number) => {
+          const next = a.slice();
+
+          // What counts as something rather than as the tail of something.
+          // Under the level anything is traced at, so a gap in an arm — which
+          // is by definition below that level — is still a gap to be crossed
+          // and not an obstacle to stop at.
+          const lip = 0.07;
+
+          // The strongest thing one way along the band, or whatever stopped
+          // us getting to it, and how far off that was. Answered into these
+          // rather than returned: it is called twice per sample of the
+          // picture and a pair of objects a sample is a great many objects.
+          let found = 0, at = 1;
+
+          const seek = (x: number, y: number, dx: number, dy: number) => {
+            found = 0; at = 1;
+
+            for (let t = 1; t <= taps; t++) {
+              const v = sample(a, x + dx * t, y + dy * t);
+
+              if (found !== 0 && v * found < 0 && Math.abs(v) > lip) break;
+              if (Math.abs(v) > Math.abs(found)) { found = v; at = t; }
+            }
+          };
+
+          for (let y = 0; y < rows; y++) {
+            for (let x = 0; x < cols; x++) {
+              const i = y * cols + x;
+
+              /**
+               * Softened, though not stopped, where the alternation is thick.
+               *
+               * The frame is least trustworthy exactly where it matters most
+               * — near a source, where the arms have not come apart yet, and
+               * out where two magnets' fields have run into each other — and
+               * there what lies "along" may well be the next band round. The
+               * test above catches that whenever the other charge is actually
+               * between the two, which is most of the time; this is for the
+               * rest of it. Not a veto, because a thin arm has the other
+               * charge close by on both sides of it by construction, and a
+               * thin arm is exactly the thing with the worst gaps in it.
+               */
+              const room = 1 - alt[i] * 0.9;
+
+              const r = Math.min(reach, Math.max(rad[i] * 0.5, 0.5));
+
+              const c = Math.cos(tilt), sn = Math.sin(tilt);
+              const dx = (runX[i] * c - runY[i] * sn) * r;
+              const dy = (runX[i] * sn + runY[i] * c) * r;
+
+              seek(x, y, dx, dy);
+              const fv = found, fat = at;
+
+              seek(x, y, -dx, -dy);
+              const bv = found, bat = at;
+
+              // Nothing runs through here.
+              if (fv * bv <= 0) continue;
+
+              const v = Math.abs(fv) < Math.abs(bv) ? fv : bv;
+
+              // Already at least this much of it, or of the other charge and
+              // meaning it — either way, not a gap.
+              if (Math.abs(v) <= Math.abs(a[i])) continue;
+              if (a[i] * v < 0 && Math.abs(a[i]) > lip) continue;
+
+              // And reaching costs something, so a gap is closed by what is
+              // just past it rather than by whatever is furthest away.
+              const far = Math.max(fat, bat) / taps;
+
+              next[i] = a[i] + (v * (1 - 0.22 * far) - a[i]) * room;
+            }
+          }
+
+          return next;
+        };
+
+        // Twice, which is not the same as once with twice the reach: what the
+        // first pass closes is arm by the time the second runs, so a run of
+        // gaps with slivers between them mends from both ends inwards rather
+        // than each gap having to be spanned in one go from whatever is left
+        // either side of it.
+        f.set(bridge(f, 9, 2.6, 0));
+        f.set(bridge(f, 9, 2.6, 0.42));
+        f.set(bridge(f, 9, 2.6, -0.42));
+
+        /**
+         * And the valley between two bands is deepened until it separates
+         * them.
+         *
+         * Where an arm of one charge passes close to another arm of the same
+         * charge, what lies between them is a thin band of the other — and
+         * thin means weak, because the two sides of it are pulling the
+         * average back towards themselves. If it is weak enough that the
+         * field never quite crosses the level being traced, the two arms are
+         * drawn as one: an island that is really two islands with a seam in
+         * it that did not print.
+         *
+         * Comparing the field against a blurred copy of itself says exactly
+         * where that is happening. A place in the middle of a wide band looks
+         * like its own surroundings and the two agree; a place in a narrow
+         * gap is much less positive than its surroundings, because its
+         * surroundings are the arms on either side of it. Taking the
+         * difference and pushing it back in leaves the middles of the bands
+         * where they were and drives the gaps between them down through zero
+         * — which is where a boundary is, so a boundary is what gets drawn,
+         * and the two arms come apart into the two islands they are.
+         *
+         * Compared ACROSS itself, though, and not in the round. The gap that
+         * wants deepening is the one between one turn of the spiral and the
+         * next, and that is out from the source by construction. A round
+         * comparison finds a second kind of thin place the arm has — the neck
+         * where it happens to be narrow along its own length — and deepens
+         * that one too, which cuts the arm in half. Every island this used to
+         * make was made honestly, by a rule that could not tell the gap it
+         * was for from the arm it was cutting.
+         *
+         * And turned up where there is alternation to keep and down where
+         * there is not.
+         *
+         * Sharpening is a separator, and a separator applied where there is
+         * nothing to separate has only one thing left to do: find whatever is
+         * weakest in a body of one charge and drive it below the level, which
+         * is a hole opened in the middle of something solid. That is the same
+         * ink the bridge above just spent closing gaps, spent undoing it.
+         *
+         * Where the two charges genuinely lie against each other it is the
+         * whole reason there are two shapes in the picture instead of one, so
+         * there it goes harder than it did before. The two are not in
+         * competition once they are asked separately.
+         *
+         * And hardest of all where the change is ALONG the way the charges
+         * are going, which is the other half of the same preference the
+         * bridging is the first half of.
+         *
+         * A shell alternates with the shells in front of it and behind it,
+         * because those are the ones thrown off a moment earlier and a moment
+         * later, when the source was pointing somewhere else or had turned
+         * over. It does not alternate with itself. So a change of charge
+         * encountered by going along the path is the real thing, worth
+         * driving apart until it separates; one encountered by going across
+         * the path — round the shell — is more likely to be two arcs at
+         * different radii happening to pass, or the edge of a gap, and
+         * sharpening it is how a ring gets cut into beads.
+         *
+         * Which of the two it is, is the direction the field changes in,
+         * against the direction the charges here are travelling in. Squared,
+         * so it falls away smoothly rather than at some angle, and floored,
+         * because none of this is exact: a shell is a couple of dozen lattice
+         * directions and a change square across the path is only ever
+         * approximately square across it.
+         */
+        const wide = drift(f.slice(), 12, 2.0, false);
+        const before = f.slice();
+
+        for (let y = 0; y < rows; y++) {
+          for (let x = 0; x < cols; x++) {
+            const i = y * cols + x;
+
+            // Which way the field changes here.
+            const gx = before[y * cols + Math.min(x + 1, cols - 1)]
+              - before[y * cols + Math.max(x - 1, 0)];
+            const gy = before[Math.min(y + 1, rows - 1) * cols + x]
+              - before[Math.max(y - 1, 0) * cols + x];
+
+            const gl = Math.hypot(gx, gy);
+
+            // And which way the charges here are going, which is across the
+            // way their shell runs.
+            const mx = -runY[i], my = runX[i];
+
+            const par = gl > 1e-5 ? ((gx * mx + gy * my) / gl) ** 2 : 0;
+
+            // Between linear and squared: squared alone ignores everything
+            // but the thickest alternation, and half of what wants keeping
+            // here is the thin seam between two arcs that have nearly closed
+            // on each other — which is faint precisely because it is about to
+            // be lost, and is the last moment it can be saved.
+            const a2 = alt[i] * (0.4 + 0.6 * alt[i]);
+
+            const gain = 0.3 + a2 * 5.2 * (0.35 + 0.65 * par);
+
+            f[i] = Math.max(Math.min(f[i] + (f[i] - wide[i]) * gain, 1), -1);
+          }
+        }
+
+        // And nothing survives where two charges are about to meet: the field
+        // there belongs to neither of them, because in a tick it will belong
+        // to whatever they become.
+        for (let i = 0; i < f.length; i++) f[i] *= 1 - cut[i] * 0.9;
+
+        /**
+         * And where the two charges lie against each other, both give ground.
+         *
+         * Everything above works on the field, and the field is traced at a
+         * level — so two bodies that meet cleanly are drawn with their
+         * outlines touching, one line doing for the pair of them, and what
+         * the eye gets is one shape with a crease in it. The alternation is
+         * there in the reading and gone from the picture.
+         *
+         * The last thing done, then, is the cheapest and the most direct:
+         * where the two are near equal, both are pushed back from zero by the
+         * same amount before the outlines are found. Neither loses anything
+         * to the other — the place they part is exactly where it was, since
+         * both give the same ground — and what opens between them is a
+         * channel of the width of what was given. Away from any seam it does
+         * nothing at all, because there is nothing there for both to be near.
+         *
+         * It is a drawing decision and says so: no charge has moved and no
+         * region has changed hands. Two things that touch are drawn as two
+         * things that touch, which is what they are.
+         */
+        for (let i = 0; i < f.length; i++) {
+          const give = alt[i] * 0.2;
+
+          f[i] = f[i] > 0 ? Math.max(f[i] - give, 0) : Math.min(f[i] + give, 0);
+        }
+
+        // And the pulses they were emitted in, kept separately, so the grain
+        // of the thing can be drawn under its shape.
+        const waves = new Map<string, {
+          at: { x: number, y: number }[], out: number, n: number, polarity: Polarity,
+        }>();
+
+        for (const nd of graph.nodes) {
+          if (!graph.inFocus(nd)) continue;
+
+          for (const ray of nd) {
+            if (ray.magnet || !ray.moving || ray.wave === undefined) continue;
+            if (ray.moving.polarity === Polarity.Neutral) continue;
+
+            const p = pts.get(nd);
+            if (!p || p.clipped) continue;
+
+            const key = `${ray.wave}|${ray.moving.polarity}`;
+
+            let wave = waves.get(key);
+            if (!wave) waves.set(key, wave = {
+              at: [], out: 0, n: 0, polarity: ray.moving.polarity,
+            });
+
+            wave.at.push({ x: p.x, y: p.y });
+
+            const wp = layout.get(nd);
+            if (wp) wave.out += Math.hypot(...wp) / ((graph.focus ?? 12) * LATTICE_STEP);
+            wave.n++;
+
+            break;
+          }
+        }
+
+
+        /**
+         * The line along which the field crosses a value.
+         *
+         * Marching squares: each little square of four neighbouring samples
+         * is wholly above the value, wholly below, or cut by it — and which
+         * of its sides the cut passes through follows from which corners are
+         * on which side. Where on a side is solved for rather than snapped to
+         * the grid, so the curve is placed to a fraction of a sample and does
+         * not come out looking like stairs.
+         *
+         * The segments come out unordered, so they are then strung together
+         * end to end into runs. That is what turns a scatter of little lines
+         * into a curve that can be smoothed and filled — and a run that
+         * arrives back where it began is a closed one, which is what the
+         * boundary of a body is.
+         */
+        const trace = (level: number) => {
+          const segs: [number, number, number, number][] = [];
+
+          for (let y = 0; y + 1 < rows; y++) {
+            for (let x = 0; x + 1 < cols; x++) {
+              const v = [
+                f[y * cols + x], f[y * cols + x + 1],
+                f[(y + 1) * cols + x + 1], f[(y + 1) * cols + x],
+              ];
+
+              let mask = 0;
+              for (let c = 0; c < 4; c++) if (v[c] > level) mask |= 1 << c;
+              if (mask === 0 || mask === 15) continue;
+
+              const corner = [[x, y], [x + 1, y], [x + 1, y + 1], [x, y + 1]];
+
+              const cut = (a: number, b: number): [number, number] => {
+                const t = Math.max(Math.min((level - v[a]) / ((v[b] - v[a]) || 1e-9), 1), 0);
+
+                return [
+                  (corner[a][0] + (corner[b][0] - corner[a][0]) * t) * CELL,
+                  (corner[a][1] + (corner[b][1] - corner[a][1]) * t) * CELL,
+                ];
+              };
+
+              const on: [number, number][] = [];
+              for (let c = 0; c < 4; c++) {
+                const d = (c + 1) % 4;
+                if (((mask >> c) & 1) !== ((mask >> d) & 1)) on.push(cut(c, d));
+              }
+
+              if (on.length === 2) segs.push([on[0][0], on[0][1], on[1][0], on[1][1]]);
+              else if (on.length === 4) {
+                segs.push([on[0][0], on[0][1], on[1][0], on[1][1]]);
+                segs.push([on[2][0], on[2][1], on[3][0], on[3][1]]);
+              }
+            }
+          }
+
+          // Strung end to end. Endpoints are shared exactly between
+          // neighbouring squares, so matching them to the nearest tenth of a
+          // pixel is enough to find which segment continues which.
+          const key = (x: number, y: number) => `${Math.round(x * 10)},${Math.round(y * 10)}`;
+          const ends = new Map<string, number[]>();
+
+          segs.forEach(([ax, ay, bx, by], i) => {
+            for (const k of [key(ax, ay), key(bx, by)]) {
+              const list = ends.get(k);
+              if (list) list.push(i); else ends.set(k, [i]);
+            }
+          });
+
+          const used = new Array(segs.length).fill(false);
+          const runs: { x: number, y: number }[][] = [];
+
+          for (let i = 0; i < segs.length; i++) {
+            if (used[i]) continue;
+            used[i] = true;
+
+            const [ax, ay, bx, by] = segs[i];
+            const run = [{ x: ax, y: ay }, { x: bx, y: by }];
+
+            // Follow it forwards, then turn round and follow the other way.
+            for (let pass = 0; pass < 2; pass++) {
+              for (; ;) {
+                const tip = run[run.length - 1];
+                const next = (ends.get(key(tip.x, tip.y)) ?? []).find(j => !used[j]);
+                if (next === undefined) break;
+
+                used[next] = true;
+
+                const [cx2, cy2, dx2, dy2] = segs[next];
+                const near = Math.hypot(cx2 - tip.x, cy2 - tip.y) < Math.hypot(dx2 - tip.x, dy2 - tip.y);
+
+                run.push(near ? { x: dx2, y: dy2 } : { x: cx2, y: cy2 });
+              }
+
+              run.reverse();
+            }
+
+            if (run.length >= 4) runs.push(run);
+          }
+
+          return runs;
+        };
+
+        /**
+         * A run, eased.
+         *
+         * Marching squares places every point on the edge of a sample square,
+         * so a curve through them carries the grid's own fret in it — a
+         * regular little waver at the scale of one sample, which is nothing
+         * about the field and everything about how it was measured. A few
+         * passes of each point drifting towards the middle of its neighbours
+         * takes that out and leaves the shape, which is at the scale of a
+         * band and untouched by it.
+         */
+        const ease = (run: { x: number, y: number }[], closed: boolean) => {
+          let cur = run;
+
+          for (let pass = 0; pass < 10; pass++) {
+            const next = cur.map((p, i) => {
+              if (!closed && (i === 0 || i === cur.length - 1)) return p;
+
+              const a = cur[(i - 1 + cur.length) % cur.length];
+              const b = cur[(i + 1) % cur.length];
+
+              return { x: (a.x + 2 * p.x + b.x) / 4, y: (a.y + 2 * p.y + b.y) / 4 };
+            });
+
+            cur = next;
+          }
+
+          return cur;
+        };
+
+        const prev = ctx.globalCompositeOperation;
+        ctx.globalCompositeOperation = "lighter";
+
+        /**
+         * The waves themselves, underneath and barely there.
+         *
+         * The spirals are what the field IS, and they are drawn above. But a
+         * spiral is made of something — one shell after another, each thrown
+         * off a moment later than the last and a little further round — and
+         * with only the boundaries drawn there is nothing in the picture that
+         * says so. A faint outline per pulse puts that back: the rings are
+         * the grain of the thing, and the winding is the thing.
+         */
+        for (const wave of waves.values()) {
+          if (wave.at.length < 3) continue;
+
+          const hull = outline(wave.at);
+          if (hull.length < 3) continue;
+
+          const tint = channels(tintOf(wave.polarity));
+          const at = (i: number) => hull[(i % hull.length + hull.length) % hull.length];
+
+          ctx.beginPath();
+          ctx.moveTo(hull[0].x, hull[0].y);
+
+          for (let i = 0; i < hull.length; i++) {
+            const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
+
+            ctx.bezierCurveTo(
+              p1.x + (p2.x - p0.x) / 6, p1.y + (p2.y - p0.y) / 6,
+              p2.x - (p3.x - p1.x) / 6, p2.y - (p3.y - p1.y) / 6,
+              p2.x, p2.y,
+            );
+          }
+
+          ctx.closePath();
+          /**
+           * And the older ones stop being drawn rather than piling up.
+           *
+           * A dozen pulses in the air at once is a dozen rings, and the
+           * further out they are the longer their outlines are and the more
+           * of them cross each other — so the outside of the picture ends up
+           * carrying most of the ink for the part of the field that has least
+           * in it. Cut off once they are past halfway out, what is left is
+           * the handful nearest the source, which are the ones that read as
+           * pulses.
+           */
+          const lift = Math.max(1 - wave.out / wave.n, 0);
+          if (lift < 0.45) continue;
+
+          // Faint enough to be texture. There are several of these to every
+          // band and their outlines run alongside it, so at anything like the
+          // band's own weight they stop being the grain of it and become a
+          // second set of edges arguing with the first.
+          ctx.strokeStyle = `rgba(${tint},${lift * lift * 0.18})`;
+          ctx.lineWidth = 0.9;
+          ctx.stroke();
+        }
+
+        // Traced where the field is only weakly one thing rather than
+        // firmly so. A high level draws a line well inside each band and the
+        // arm comes out thin, broken wherever it happens to be weak; a low
+        // one follows the band right out to where it gives way to its
+        // neighbour, which is where the two actually meet.
+        /**
+         * A fill that dims with distance from the source rather than with
+         * which island it belongs to.
+         *
+         * A fill takes one colour for the whole shape it fills, so a band
+         * cannot be shaded along itself the way its edge can. What it can be
+         * given is a colour that is already a gradient — bright at the middle
+         * of the picture and thin at the rim — and then every band is dim
+         * where it is far out and bright where it is close in, including the
+         * ones that are both.
+         */
+        const centre = origin.size
+          ? [...origin.values()].reduce((a, p) => ({
+            x: a.x + p.x / origin.size, y: a.y + p.y / origin.size,
+          }), { x: 0, y: 0 })
+          : { x: w / 2, y: h / 2 };
+
+        const span2 = (graph.focus ?? 12) * LATTICE_STEP * cam.scale;
+
+        const wash = (tint: string) => {
+          const g = ctx.createRadialGradient(
+            centre.x, centre.y, 0, centre.x, centre.y, Math.max(span2, 1),
+          );
+
+          g.addColorStop(0, `rgba(${tint},0.3)`);
+          g.addColorStop(0.45, `rgba(${tint},0.14)`);
+          g.addColorStop(1, `rgba(${tint},0.03)`);
+
+          return g;
+        };
+
+        const strength = (p: { x: number, y: number }) => {
+          const i = Math.min(Math.max(Math.round(p.y / CELL), 0), rows - 1) * cols
+            + Math.min(Math.max(Math.round(p.x / CELL), 0), cols - 1);
+
+          const lift = near[i];
+
+          return 0.08 + lift * lift * 0.92;
+        };
+
+        for (const [level, tint] of [
+          [0.17, channels(AMBER)], [-0.17, channels(CYAN)],
+        ] as [number, string][]) {
+          const runs = trace(level).map(raw => {
+            const closed = Math.hypot(
+              raw[0].x - raw[raw.length - 1].x, raw[0].y - raw[raw.length - 1].y,
+            ) < CELL * 2;
+
+            return { run: ease(raw, closed), closed };
+          });
+
+          const curve = (into: Path2D, run: { x: number, y: number }[], closed: boolean) => {
+            const at = (i: number) => run[closed
+              ? (i % run.length + run.length) % run.length
+              : Math.max(Math.min(i, run.length - 1), 0)];
+
+            into.moveTo(run[0].x, run[0].y);
+
+            for (let i = 0; i < run.length - (closed ? 0 : 1); i++) {
+              const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
+
+              into.bezierCurveTo(
+                p1.x + (p2.x - p0.x) / 6, p1.y + (p2.y - p0.y) / 6,
+                p2.x - (p3.x - p1.x) / 6, p2.y - (p3.y - p1.y) / 6,
+                p2.x, p2.y,
+              );
+            }
+
+            if (closed) into.closePath();
+          };
+
+          /**
+           * All of one charge's boundaries filled as ONE shape, with the
+           * even-odd rule.
+           *
+           * A body of one charge is not simply a blob with an edge. An arm
+           * that winds round has the other charge inside the loop it makes,
+           * and that shows up here as a second closed curve lying within the
+           * first — the hole, not another island. Filled one curve at a time,
+           * the hole gets filled too, and amber is painted straight over the
+           * cyan that lives there: two regions that cannot overlap in the
+           * field, overlapping in the picture, purely as an artefact of
+           * filling their boundaries separately.
+           *
+           * Taken together under the even-odd rule, a place is inside the
+           * body when the boundary wraps it an odd number of times — so the
+           * inside of the arm is filled, the hole within it is not, and what
+           * is drawn is the region rather than everything its edges happen to
+           * enclose.
+           */
+          const body = new Path2D();
+          for (const { run, closed } of runs) if (closed) curve(body, run, closed);
+
+          ctx.fillStyle = wash(tint);
+          ctx.fill(body, "evenodd");
+
+          // A brighter rim on top of it, stroked span by span so that its
+          // strength is the strength of the field where each piece of it
+          // actually lies rather than the average over the whole run.
+          ctx.lineWidth = 1.4;
+          ctx.lineCap = "round";
+
+          for (const { run, closed } of runs) {
+            const at = (i: number) => run[closed
+              ? (i % run.length + run.length) % run.length
+              : Math.max(Math.min(i, run.length - 1), 0)];
+
+            for (let i = 0; i + 1 < run.length + (closed ? 1 : 0); i++) {
+              const a = at(i), b = at(i + 1);
+
+              ctx.strokeStyle = `rgba(${tint},${0.75 * strength(a)})`;
+              ctx.beginPath();
+              ctx.moveTo(a.x, a.y);
+              ctx.lineTo(b.x, b.y);
+              ctx.stroke();
+            }
+          }
+
+          ctx.lineCap = "butt";
+        }
+
+        ctx.globalCompositeOperation = prev;
+      }
+
+      for (const n of graph.nodes) {
+        const p = pts.get(n);
+        if (!p || p.clipped || !onScreen(p)) continue;
+        const depth = Math.min(Math.max(p.depth, 0.4), 1.6);
+
+        // In field mode everything in flight has already been drawn, as the
+        // surface it belongs to. What is left to draw one point at a time is
+        // what isn't a surface: the sources, and (below) the places where
+        // something is about to happen.
+        const magnet = n.some(r => r.magnet);
+        if (field && !magnet) continue;
+
+        // The origin of the waves. Everything charged in this universe came
+        // out of one of these, so it is the one thing that isn't an event but
+        // a cause of them — drawn as its own colour rather than as a polarity,
+        // since it has none.
+        if (magnet) {
+          // Sized against the zoom, since this is a point of a structure that
+          // is being looked at from somewhere — which is the one thing the
+          // closed form, having no points and no camera, cannot do.
+          const r = Math.min(Math.max(cam.scale * 0.2 * depth, 2), 30);
+
+          source(ctx, p.x, p.y, { halo: r * 3.2, dot: Math.max(r * 0.4, 1.6) });
+        }
+
+        // Center seed: a soft glow marking where the universe started. In
+        // field mode the origin is only the point halfway between the two
+        // sources, and glowing there would read as a third one.
+        if (!field && isCenterNode(n)) {
+          const r = Math.min(Math.max(cam.scale * 0.16 * depth, 0.8), 26);
+          const g = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3);
+          g.addColorStop(0, "rgba(255,217,168,0.9)");
+          g.addColorStop(1, "rgba(255,217,168,0)");
+          ctx.fillStyle = g;
+          ctx.beginPath();
+          ctx.arc(p.x, p.y, r * 3, 0, Math.PI * 2);
+          ctx.fill();
+        }
+
+        // Boundaries: EVERY boundary of every ray is drawn as a segment
+        // towards the node on the far side of its connection, coloured by
+        // its own polarity (Positive amber, Negative cyan), reaching 25% of
+        // the way along it. So each lattice connection shows two of them —
+        // one from each end, with a gap in between. The single boundary the
+        // ray is currently `moving` along is drawn at full opacity (and
+        // thicker) on top; the rest are faded down.
+        ctx.lineCap = "round";
+        const stub = (bd: Boundary, moving: boolean) => {
+          // Connected boundaries aim at their neighbour; unconnected ones at
+          // a point one lattice step along their bare `outward` direction, so
+          // "moving away from every connection" is visible rather than blank.
+          const wp = layout.get(n);
+          const wt = bd.target
+            ? layout.get(bd.target.at.node)
+            : (wp && bd.outward ? wp.map((v, i) => v + (bd.outward![i] || 0) * LATTICE_STEP) : undefined);
+          if (!wp || !wt) return;
+
+          const tp = bd.target ? pts.get(bd.target.at.node) : screenOf(wt);
+          if (!tp || tp.clipped) return;
+
+          const dx = tp.x - p.x, dy = tp.y - p.y;
+          const len = Math.hypot(dx, dy);
+          if (len < 1) return;
+          const ux = dx / len, uy = dy / len;
+          const L = len * BOUNDARY_STUB;
+
+          // Positive amber, Negative cyan, and space that hasn't been charged
+          // by anything a plain grey.
+          // Positive amber, negative cyan, and space that hasn't been charged
+          // by anything a plain grey — the same three the closed form leans
+          // its pixels towards. The one it is moving along at full strength,
+          // the rest faded down.
+          const tint = tintOf(bd.polarity);
+
+          ctx.strokeStyle = moving
+            ? rgba(tint, 1)
+            : rgba(tint, bd.polarity === Polarity.Neutral ? 0.25 : 0.3);
+          ctx.lineWidth = 2 * depth;
+          ctx.beginPath();
+          ctx.moveTo(p.x, p.y);
+          ctx.lineTo(p.x + ux * L, p.y + uy * L);
+          ctx.stroke();
+
+          if (!moving) return;
+
+          // An arrow head sitting ON the node, naming which of its lattice
+          // directions the ray is actually moving in. Its base is centred on
+          // the node's own position and it points off along the connection,
+          // so the direction is read at the point it belongs to rather than
+          // out at the far end of the stub.
+          //
+          // It is the silhouette of a cone, so it foreshortens like one: the
+          // width of the base is fixed, but the length shrinks as the
+          // direction turns towards or away from the camera. That ratio is
+          // measured, not guessed — the drawn length of the connection over
+          // the length it would have had square to the camera. Without it
+          // every head is drawn at full length whatever it points at, which
+          // is what makes them read wrong in 3D.
+          const worldLen = Math.hypot(...wt.map((v, i) => v - wp[i]));
+          const square = worldLen * cam.scale * depth;
+          const foreshortening = square > 0 ? Math.min(len / square, 1) : 1;
+
+          const size = Math.min(Math.max(10, ctx.lineWidth * 5), L * 0.7);
+          const head = size * Math.max(foreshortening, 0.3);
+          const nx = -uy * size * 0.46, ny = ux * size * 0.46;
+
+          ctx.fillStyle = ctx.strokeStyle;
+          ctx.beginPath();
+          ctx.moveTo(p.x + ux * head, p.y + uy * head);
+          ctx.lineTo(p.x + nx, p.y + ny);
+          ctx.lineTo(p.x - nx, p.y - ny);
+          ctx.closePath();
+          ctx.fill();
+        };
+
+        // One stub per direction — per neighbouring node, or per outward
+        // direction. After a merge a node holds many rays whose boundaries
+        // all face the same neighbour; stroking that one segment once per
+        // boundary stacks the 0.3-alpha passes into an opaque line, and mixed
+        // polarities towards the same neighbour blend amber over cyan into a
+        // washed-out white. A `moving` boundary always wins the slot, so the
+        // highlight is never lost to a resting one sharing its direction.
+        const slots = new Map<string, { bd: Boundary; moving: boolean }>();
+        for (const ray of n) {
+          for (const bd of ray.boundaries) {
+            const other = bd.target?.at.node;
+
+            let key: string;
+            if (other && other !== n) key = "n" + idxOf.get(other);
+            else if (!other && bd.outward) key = "o" + bd.outward.join(",");
+            else continue;
+
+            const moving = ray.moving === bd;
+            const cur = slots.get(key);
+            if (!cur || (moving && !cur.moving)) slots.set(key, { bd, moving });
+          }
+        }
+
+        // Dim pass first, so the highlighted one is never overdrawn by it —
+        // and skipped entirely in field mode, where the twenty-five
+        // directions a charge ISN'T going are twenty-five stubs saying
+        // nothing, per charge, per frame.
+        for (const { bd, moving } of slots.values())
+          if (!moving && !field) stub(bd, false);
+
+        for (const { bd, moving } of slots.values())
+          if (moving) stub(bd, true);
+
+        ctx.lineCap = "butt";
+      }
+
+      // What is about to happen — and only ever one thing.
+      //
+      // Everything in this universe is charges moving, and almost all of the
+      // time a charge moving is nothing happening: it swaps places with the
+      // space in front of it and the world is as it was. Two alike meeting
+      // head-on and turning each other round is barely more than that —
+      // nothing is lost by it, the pair carry on the other way, and there are
+      // thousands of them a tick all over the field.
+      //
+      // Cancelling is the only event that leaves the world a different size.
+      // It is the whole of what gravity is here, and marking anything else
+      // alongside it buries it in the general bustle.
+      if (field) {
+        // Drawn plainly, NOT added together like the shells above.
+        //
+        // Additive blending is right for a few translucent surfaces and wrong
+        // for a thousand marks: where the fields properly meet there are
+        // hundreds of these on top of one another, and adding a hundred faint
+        // whites gives solid white. The middle of the picture — which is the
+        // part being watched — turns into a lamp. Ordinary alpha means a
+        // hundred stacked marks are no brighter than a few, so a dense region
+        // reads as dense rather than as blown out.
+        const prev = ctx.globalCompositeOperation;
+
+        for (const nd of graph.nodes) {
+          for (const ray of nd) {
+            const a = ray.moving;
+            const b = a?.target;
+            if (!a || !b) continue;
+
+            const other = b.at.node;
+            if (other === nd) continue;
+
+            // Each moving into where the other is — the same test the tick
+            // itself uses, so what is marked is what will actually happen.
+            const met = other.find(x => x.moving?.target?.at.node === nd);
+            if (!met) continue;
+
+            // Found from both ends; drawn from one.
+            if (idxOf.get(nd)! > idxOf.get(other)!) continue;
+
+            // Against what the other one is actually carrying towards us,
+            // which is its own moving boundary — the same pair of polarities
+            // the tick will compare. Only one of each cancels; everything
+            // else meeting head-on turns around, and turning around leaves
+            // the world exactly as big as it was.
+            const facing = met.moving!.polarity;
+
+            const opposed =
+              (a.polarity === Polarity.Positive && facing === Polarity.Negative) ||
+              (a.polarity === Polarity.Negative && facing === Polarity.Positive);
+
+            if (!opposed) continue;
+
+            const p = pts.get(nd), q = pts.get(other);
+            if (!p || !q || p.clipped || q.clipped) continue;
+
+            const x = (p.x + q.x) / 2, y = (p.y + q.y) / 2;
+            if (!onScreen({ x, y })) continue;
+
+            // Sized in pixels with only a little from the zoom. These are
+            // marks ON the picture rather than things in it — scaled to the
+            // lattice they are two or three pixels across on a ball this big,
+            // which is to say invisible, which is to say the one thing the
+            // picture is for isn't in it.
+            // Sized in pixels rather than scaled to the lattice, but only
+            // just: there are a great many of these once the fields properly
+            // meet, and at full brightness they stop being marks on the
+            // picture and become the picture.
+            const r = 3 + cam.scale * 0.012 * p.depth;
+
+            const flash = ctx.createRadialGradient(x, y, 0, x, y, r);
+            flash.addColorStop(0, "rgba(255,240,214,0.28)");
+            flash.addColorStop(0.4, "rgba(255,240,214,0.1)");
+            flash.addColorStop(1, "rgba(255,240,214,0)");
+            ctx.fillStyle = flash;
+            ctx.beginPath();
+            ctx.arc(x, y, r, 0, Math.PI * 2);
+            ctx.fill();
+
+            // A small hard centre, so it still reads as a point where
+            // something is happening rather than as one more soft glow.
+            ctx.fillStyle = "rgba(255,244,224,0.4)";
+            ctx.beginPath();
+            ctx.arc(x, y, 1, 0, Math.PI * 2);
+            ctx.fill();
+          }
+        }
+
+        // And what DID happen — the same events a tick later, at the place
+        // they happened, fading. An annihilation is over inside the tick it
+        // occurs in and takes both of the points it occurred between with it,
+        // so without this the one thing in this universe that changes how
+        // much space there is is the one thing never shown happening.
+        for (const event of graph.events) {
+          if (event.kind !== 'annihilate') continue;
+
+          const age = graph._tickId - event.tick;
+          if (age > 1) continue;
+
+          const pr = place(project(event.at, cam.rot, cam.tilt, cam.dist || 1));
+          if (pr.clipped || !onScreen(pr)) continue;
+
+          const fade = age === 0 ? 0.3 : 0.12;
+          const r = 5 + cam.scale * 0.018 * pr.depth;
+
+          const burst = ctx.createRadialGradient(pr.x, pr.y, 0, pr.x, pr.y, r);
+          burst.addColorStop(0, `rgba(255,236,196,${fade})`);
+          burst.addColorStop(0.35, `rgba(255,236,196,${0.35 * fade})`);
+          burst.addColorStop(1, "rgba(255,236,196,0)");
+          ctx.fillStyle = burst;
+          ctx.beginPath();
+          ctx.arc(pr.x, pr.y, r, 0, Math.PI * 2);
+          ctx.fill();
+        }
+
+        ctx.globalCompositeOperation = prev;
+
+        // What the last tick actually consisted of. "Nothing is happening"
+        // has several quite different causes that look identical on screen,
+        // and these are what tell them apart: emitted 0 means the sources are
+        // walled in, moved 0 with blocked high means everything has jammed,
+        // and annihilated 0 with both of those healthy means the waves are
+        // travelling perfectly well and simply never meeting.
+        const s = graph.stats;
+        const line = `t${graph._tickId}  pts ${graph.nodes.length}  emit ${s.emitted}  move ${s.moved}  block ${s.blocked}  kill ${s.annihilated}  turn ${s.turned}  holes ${s.holes}`;
+
+        ctx.font = "11px ui-monospace, SFMono-Regular, Menlo, monospace";
+        ctx.textBaseline = "top";
+        ctx.fillStyle = "rgba(150,158,180,0.75)";
+        ctx.fillText(line, 10, 8);
+
+        /**
+         * How far apart the two sources are, in steps through the structure,
+         * plotted against time.
+         *
+         * Flat means they are not gravitating, whatever the picture above it
+         * appears to be doing. Every step down is space between them that has
+         * been annihilated and is not there any more. It is the one reading
+         * here that cannot be argued with by looking harder: the layout is a
+         * solve and can be stiff or slow, and the coordinates never move at
+         * all, but a path is a count of points and either there are fewer of
+         * them than there were or there are not.
+         */
+        const history = graph.history;
+
+        // Nothing to measure with one source: there is no "apart".
+        if (history.length > 1 && graph.route.length > 1) {
+          const W = 150, H = 38, X = 10, Y = h - H - 12;
+
+          const top = Math.max(...history, 1);
+          const now = history[history.length - 1];
+
+          ctx.strokeStyle = "rgba(150,158,180,0.22)";
+          ctx.lineWidth = 1;
+          ctx.strokeRect(X, Y, W, H);
+
+          ctx.strokeStyle = "rgba(120,230,180,0.85)";
+          ctx.lineWidth = 1.4;
+          ctx.beginPath();
+
+          for (let i = 0; i < history.length; i++) {
+            const x = X + (i / Math.max(history.length - 1, 1)) * W;
+            const y = Y + H - (Math.max(history[i], 0) / top) * (H - 4) - 2;
+
+            if (i) ctx.lineTo(x, y); else ctx.moveTo(x, y);
+          }
+
+          ctx.stroke();
+
+          ctx.fillStyle = "rgba(150,158,180,0.75)";
+          ctx.fillText(`source to source: ${now} steps (from ${history[0]})`, X, Y - 15);
+        }
+      }
+    }
+
+    return {
+      // Whoever owns the universe is told as this comes on and off screen, so
+      // that it can let go of one and make another. See `LatticePlayer`.
+      start: () => latest.current.onVisible?.(true),
+
+      frame: (surface, dt) => {
+        // Ticking lives with the caller: this only ever renders, and never
+        // advances the dynamics itself.
+        latest.current.onFrame?.(dt);
+
+        draw(surface);
+      },
+
+      stop: () => {
+        latest.current.onVisible?.(false);
+
+        // The field as drawn, which is the one thing this keeps between
+        // frames. Everything else it allocates lives and dies inside a draw.
+        eased = null;
+      },
+    };
+  }} />;
+}
+
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/canvas.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/canvas.tsx
new file mode 100644
index 0000000..c371dcf
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/canvas.tsx
@@ -0,0 +1,214 @@
+import { useEffect, useRef } from "react";
+
+import { whileOnScreen } from "./visible";
+
+/**
+ * The canvas as a painter sees it: somewhere to draw and how big it is.
+ *
+ * In css pixels, always. The buffer behind it is larger on a dense display
+ * and the context is pre-scaled to match, so nothing that draws has to know
+ * or care what the device ratio is — which is the whole point of handing it
+ * over rather than handing over the element.
+ */
+export type Surface = {
+  ctx: CanvasRenderingContext2D;
+  width: number;
+  height: number;
+};
+
+/**
+ * Something that draws, and the state it keeps between frames.
+ *
+ * `start` and `stop` are the pair that make an article of thirty of these
+ * affordable. A view that is not on screen does not draw, does not tick, and
+ * does not HOLD anything: `stop` is where whatever `start` made is let go of
+ * — a universe of several thousand points, a field the size of the viewport,
+ * a couple of image buffers — and coming back on screen calls `start` again.
+ * Neither is about drawing. They are about what exists.
+ */
+export type Painter = {
+  /** Called as it comes on screen, before the first frame. */
+  start?: () => void;
+
+  /** One frame, `dt` seconds after the last. */
+  frame: (surface: Surface, dt: number) => void;
+
+  /** Called as it goes off screen. Let go of everything `start` made. */
+  stop?: () => void;
+};
+
+/**
+ * A canvas that draws only while it is worth drawing on.
+ *
+ * Both of this article's renderers are the same shape underneath — take a
+ * canvas, size it to its parent, run a frame loop while it is on screen, and
+ * hand the pixels back when it is not — and they are that shape for reasons
+ * that have nothing to do with either of them. A frame loop is a claim on the
+ * machine for as long as it is alive, and a page like this one is thirty
+ * universes of which at most two can be seen; a canvas the size of the
+ * viewport on a dense display is several megabytes, and clearing it frees
+ * nothing, because the buffer is the same size empty. Setting it to no size
+ * at all is what hands it back, and asking for the size again is what takes
+ * it. The element's own layout is unaffected — that comes from the style
+ * rather than the attributes — so the box stays exactly where it was, which
+ * it has to, or the thing watching for it to come back would have nothing to
+ * watch.
+ *
+ * None of that is a property of what is being drawn, so neither renderer
+ * should have to say it. They say `frame`.
+ */
+export const CanvasView = ({
+  paint,
+  animate = true,
+  height,
+  deps = [],
+}: {
+  /**
+   * Made once per mount, not per frame. Whatever a painter needs to keep
+   * across frames it keeps in its own closure; the loop only calls it.
+   */
+  paint: () => Painter;
+
+  /**
+   * Whether there are later frames at all. Without this the surface is drawn
+   * exactly once each time it comes on screen — which is what a still is, and
+   * is the whole difference between a filmstrip and a player.
+   */
+  animate?: boolean;
+
+  /** Drawn to fill its parent, so the parent is what is given a height. */
+  height?: number;
+
+  /** Anything that, changed, means the painter has to be made again. */
+  deps?: unknown[];
+}) => {
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+
+  // The loop is set up once and outlives every re-render, so it must not
+  // close over the props as they were at mount. Read through the ref, it
+  // always calls the current one.
+  const latest = useRef(paint);
+  latest.current = paint;
+
+  useEffect(() => {
+    const canvas = canvasRef.current!;
+    const ctx = canvas.getContext("2d")!;
+
+    const painter = latest.current();
+
+    let raf = 0;
+    let last = performance.now();
+
+    // Whether anyone is looking. Nothing is drawn, advanced or held on to
+    // until this is true.
+    let seen = false;
+
+    const surface: Surface = { ctx, width: 0, height: 0 };
+
+    const resize = () => {
+      const parent = canvas.parentElement!;
+      const w = parent.clientWidth, h = parent.clientHeight;
+      const ratio = window.devicePixelRatio || 1;
+
+      canvas.width = w * ratio;
+      canvas.height = h * ratio;
+      canvas.style.width = w + "px";
+      canvas.style.height = h + "px";
+
+      // Everything draws in css pixels; the buffer behind is denser, and the
+      // transform is the whole of what makes that somebody else's problem.
+      ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
+
+      surface.width = w;
+      surface.height = h;
+    };
+
+    const once = (dt: number) => {
+      if (!surface.width || !surface.height) return;
+
+      painter.frame(surface, dt);
+    };
+
+    const frame = (now: number) => {
+      // Clamped, so that a tab left in the background does not come back and
+      // advance the world by however long nobody was looking at it.
+      const dt = Math.min((now - last) / 1000, 0.05);
+      last = now;
+
+      once(dt);
+
+      raf = requestAnimationFrame(frame);
+    };
+
+    const stop = () => {
+      if (!raf) return;
+
+      cancelAnimationFrame(raf);
+      raf = 0;
+    };
+
+    const show = (visible: boolean) => {
+      if (visible === seen) return;
+      seen = visible;
+
+      if (visible) {
+        resize();               // the pixels, given back below, taken again
+        painter.start?.();
+
+        if (animate) {
+          last = performance.now();
+          raf = requestAnimationFrame(frame);
+        } else {
+          // A still has no later frames, so this is the only one it gets.
+          once(0);
+        }
+
+        return;
+      }
+
+      stop();
+      painter.stop?.();
+
+      canvas.width = 0;
+      canvas.height = 0;
+
+      surface.width = 0;
+      surface.height = 0;
+    };
+
+    // Unmounting while off screen has nothing to let go of — `show` has
+    // already done it — and calling `stop` twice is at best wasted and at
+    // worst a second "nobody is looking" told to whoever owns the state.
+    const release = () => { if (seen) show(false); };
+
+    // Only while it is on screen: off screen there is no buffer to resize,
+    // and it will be asked for at the size it is when it comes back.
+    const onResize = () => {
+      if (!seen) return;
+
+      resize();
+
+      // No frame loop to pick the new size up, so it is picked up here.
+      if (!animate) once(0);
+    };
+
+    window.addEventListener("resize", onResize);
+
+    const unwatch = whileOnScreen(canvas, show);
+
+    return () => {
+      unwatch();
+      release();
+      window.removeEventListener("resize", onResize);
+    };
+  }, deps);
+
+  const element = <canvas
+    ref={canvasRef}
+    style={{ display: "block", width: "100%", height: "100%" }}
+  />;
+
+  return height === undefined
+    ? element
+    : <div style={{ height }}>{element}</div>;
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
new file mode 100644
index 0000000..cc17a04
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
@@ -0,0 +1,1792 @@
+import { CanvasView, Surface } from "./canvas";
+import { CYCLE, Source, SPIN } from "./lattice";
+import { AMBER, BACKGROUND, CYAN, ground, lift, source } from "./paint";
+
+/**
+ * The whole of it as one expression, which is the other way of having it.
+ *
+ * The lattice in `discrete.ts` is the model run: a few thousand points, each one moved
+ * or not moved by a rule that looks only at its neighbours, and a picture
+ * reconstructed afterwards from where they all ended up. That is the honest
+ * order to do it in — the rules are the claim, and the shape is whatever
+ * comes out of them — but it is expensive twice over. Once in the running,
+ * and once in the reading: a field made of points has to be turned back into
+ * a field, and every choice in that reconstruction is a chance to draw
+ * something the rules did not say.
+ *
+ * There is a second way, available only once you already know what the rules
+ * make, and it is worth having precisely because it is derived rather than
+ * assumed. A source at the origin turning at ω radians a tick, emitting the
+ * charge of whichever pole faces a direction, and a wave that travels one
+ * cell a tick. Then the charge at distance r in direction θ at time t is the
+ * charge that left the source r ticks ago, when its axis pointed at
+ * α + ω(t − r) rather than at α + ωt. So the field is
+ *
+ *     F(r, θ, t) = cos( lobes·θ − ω·(t − r) − α )
+ *
+ * and there is nothing else to it. No points, no reconstruction, no
+ * neighbours to decide between: at any place and any moment the answer is
+ * one cosine, and the picture is that cosine evaluated at every pixel.
+ *
+ * `lobes` is the only thing that separates the two cases in this article, and
+ * it is not a parameter so much as a question about the source. One: it has
+ * an axis, so what it emits depends on the direction — the field carries a θ
+ * in it, the zero set is θ = ω(t − r) + const, and that is an Archimedean
+ * spiral. Nought: it has no sides, so direction drops out altogether, the
+ * zero set is r = t − const, and that is a set of rings travelling outward.
+ * A spiral and a ring are the same function with and without an angle in it,
+ * which is what it means to say the difference between the two sources is
+ * that one turns and the other only flips.
+ *
+ * Several of them add. That is a claim rather than a definition, and it is
+ * the one place this parts company with the model above: charges there do
+ * not superpose, they meet and annihilate. But annihilation IS what addition
+ * does to two opposite numbers, and the thing that survives it — the region
+ * where one charge is left over — is what a sum of cosines has where they do
+ * not cancel. So it is the right continuous shadow of a discrete rule, and
+ * the places where the two disagree are exactly the places worth looking at.
+ */
+export const LIGHT = 1;                                  // cells a wave goes in a tick
+
+export type Emitter = {
+  // Where it is, in cells.
+  at: [number, number];
+
+  // One if it has an axis and so has sides; nought if it puts out the same
+  // thing in every direction at once.
+  lobes: 0 | 1;
+
+  // Radians of pattern per tick, signed. Which way round it turns, for a
+  // source with sides; how fast it flips over, for one without.
+  omega: number;
+
+  // Where in the cycle it starts, which is the only thing one source can be
+  // against another.
+  phase: number;
+
+  /**
+   * How it is already going, in cells a tick, and it keeps going that way.
+   *
+   * There is no force in this model and so there is nothing for a velocity to
+   * be changed BY. A source that was set moving carries on moving, at the one
+   * speed its mass allows, in the direction it was sent; nothing here
+   * accelerates anything, and nothing here can slow anything down. What
+   * happens to a pair with momentum is not that they are pulled off course —
+   * it is that the space they are crossing goes on being eaten while they
+   * cross it, so the two end up closer together than their courses would have
+   * left them, without either having gone anywhere it was not already going.
+   *
+   * Which is a strange enough thing to be worth watching, and is the whole
+   * reason for these cases. An orbit that comes out of this is not a balance
+   * of a pull against an inertia. It is a drift that keeps carrying the two
+   * sideways while the gap between them keeps shortening underneath.
+   */
+  drift?: [number, number];
+
+  /**
+   * Ticks between one pulse and the next, or nothing for a source whose
+   * emission is continuous.
+   *
+   * The cases above emit without pause: the cosine is defined everywhere, so
+   * every point in the field is carrying something and there are no shells,
+   * only a phase that varies. That is the smooth reading of the model and it
+   * is a fair one, but it hides the thing the lattice version makes obvious —
+   * that what is emitted is a shell, that shells are discrete, and that
+   * annihilation is one of them meeting one of them.
+   *
+   * Given a beat, the emission becomes a train: a pulse leaves at every
+   * multiple of it and nothing leaves in between, so what travels out is a
+   * set of rings with space between them rather than a filled field. Which
+   * changes the arithmetic of the eating, and changes it in the direction
+   * that matters. Two sources pulsing every tick have a meeting every tick;
+   * two pulsing every OTHER tick have a meeting every other tick, so the gap
+   * between them goes at half the rate while their courses carry them along
+   * at exactly the speed they did. Moving as fast and eating half as quickly
+   * is the difference between a pair that is captured and a pair that has
+   * time to get somewhere first.
+   */
+  beat?: number;
+};
+
+/**
+ * The same source the lattice was given, read as a cosine.
+ *
+ * This is the entire bridge between the two halves of the article, and it is
+ * deliberately dull — every line of it is a change of units and none of it is
+ * a change of claim. What the lattice does with a `Source` and what this does
+ * with it have to be the same arrangement, or the two pictures are not
+ * comparable and there is no point drawing them beside each other.
+ *
+ * The one thing worth reading twice is `lobes`, because it is where the whole
+ * ring-or-spiral difference sits. A source that TURNS has an axis pointing
+ * somewhere, so what it emits depends on the direction: the field carries a θ
+ * in it, its zero set is θ = ω(t − r) + const, and that is an Archimedean
+ * spiral. A source that only flips has no sides, so direction drops out
+ * altogether, the zero set is r = t − const, and that is rings travelling
+ * outward. Same function, with and without an angle in it.
+ */
+export const emitterOf = (s: Source): Emitter => ({
+  at: [s.at[0] ?? 0, s.at[1] ?? 0],
+
+  lobes: s.turning ? 1 : 0,
+
+  // Which way round, for a source with sides; how fast it flips over, for one
+  // without. A source told to do neither stands still and holds its poles.
+  omega: s.turning ? SPIN * s.turning
+    : (s.flips ?? true) ? SPIN
+      : 0,
+
+  // Turns to radians, which is the only unit either side disagrees on.
+  phase: (s.phase ?? 0) * Math.PI * 2,
+
+  drift: s.drift ? [s.drift[0] ?? 0, s.drift[1] ?? 0] : undefined,
+
+  // A beat of one is a source that never pauses, which here is a field that
+  // is defined everywhere rather than a train of rings — so it is the absence
+  // of a beat and not a beat of one.
+  beat: s.beat && s.beat > 1 ? s.beat : undefined,
+});
+
+// How wide a pulse is, in ticks — so a ring is about this many cells thick to
+// either side of where its front is.
+const PULSE = 0.5;
+
+/**
+ * As fast as a source goes, and here it goes almost as fast as anything can.
+ *
+ * One step a tick is this model's ceiling — a ray moves at most once per tick,
+ * so nothing outruns the wave it emits — and mass is the only thing that
+ * keeps anything under it: a step costs a source `MAGNET_MASS`, a tick pays
+ * one, so a heavy source crawls. Set to within a percent of the ceiling
+ * instead, these are as light as a thing can be and still be a thing.
+ *
+ * Not a percent short for safety's sake. At the ceiling exactly, everything a
+ * source ever emitted in the direction it is going arrives at the same
+ * moment, and the retarded time ahead of it stops having one answer — that is
+ * a real feature of moving at the speed of your own light and not a numerical
+ * complaint, but it is also the point past which nothing can be drawn,
+ * because what is being asked for is not a number. A percent under, the
+ * pile-up ahead is a hundredfold compression, which is a great deal to look
+ * at and is still a finite thing.
+ */
+export const PACE = 0.5 * LIGHT;
+
+
+
+/**
+ * A source as it currently stands, and everywhere it has been.
+ *
+ * The past is not optional here. What is at distance r left r ticks ago, from
+ * wherever the source was then — so a ring already in the air belongs to a
+ * place, and that place does not move again however the thing that made it
+ * carries on. Once these start eating they travel at half of light, and a
+ * ring emitted twenty ticks ago is centred ten cells from where its source
+ * now is; drawn from the present position instead, the whole field is hauled
+ * about every time the speed changes, which is every frame, and what should
+ * be a stack of settled layers becomes one object flapping.
+ *
+ * So it is remembered rather than extrapolated, at a couple of samples a
+ * tick, which is finer than anything in the picture varies over.
+ */
+const TRAIL = 0.5;                                // ticks between remembered places
+
+type Live = Emitter & {
+  // x then y, one pair per TRAIL of t, from the beginning of the run.
+  path: number[];
+
+  // How it is going now, which starts as its `drift` and is then turned by
+  // the space it is going through. Nothing ever changes its SPEED; see the
+  // flow below.
+  vel: [number, number];
+};
+
+// Where it was at a given moment, and how fast it was going then. Between
+// samples, and before the run began, the nearest thing it can honestly say.
+const RETARD: [number, number] = [0, 0];
+const CARRY: [number, number] = [0, 0];
+
+// Which way the thing `emit` just reported on is going.
+const WAY: [number, number] = [0, 0];
+
+const was = (s: Live, when: number) => {
+  const last = s.path.length / 2 - 1;
+  const k = Math.min(Math.max(when / TRAIL, 0), last);
+
+  const i = Math.floor(k), j = Math.min(i + 1, last);
+  const f = k - i;
+
+  RETARD[0] = s.path[2 * i] * (1 - f) + s.path[2 * j] * f;
+  RETARD[1] = s.path[2 * i + 1] * (1 - f) + s.path[2 * j + 1] * f;
+};
+
+const wasGoing = (s: Live, when: number) => {
+  was(s, when);
+
+  const ax = RETARD[0], ay = RETARD[1];
+
+  was(s, when - TRAIL);
+
+  CARRY[0] = (ax - RETARD[0]) / TRAIL;
+  CARRY[1] = (ay - RETARD[1]) / TRAIL;
+
+  RETARD[0] = ax; RETARD[1] = ay;
+};
+
+/**
+ * When what is at a point now left the source that made it.
+ *
+ * The retarded time is the root of |x − p(te)| = t − te, and how it is found
+ * matters entirely at these speeds. The obvious way — guess r from where the
+ * source is now, look up where it was that long ago, measure again — walks
+ * towards the answer, and how fast it walks is exactly the source's speed:
+ * each round takes off a fraction v of what is left. At a third of light that
+ * is three good rounds and done. At ninety-nine hundredths it is six hundred,
+ * which is not a thing that can be done once per source per sample of a
+ * picture, sixty times a second.
+ *
+ * So it is solved rather than approached. Over the short stretch of trail the
+ * answer lies in, the source is going in a straight line at a steady rate,
+ * and for a straight line the equation is a quadratic in te and can simply be
+ * written down. Two rounds of that — one to find roughly where to look, one
+ * to solve properly with the velocity found there — lands on the answer
+ * regardless of how near the ceiling the thing is travelling.
+ *
+ * The position is then read from the trail rather than from the straight
+ * line, so the answer is still a record of where the source actually was.
+ * Nothing already emitted moves, which was the whole reason for keeping a
+ * trail; the straight line is only ever used to work out WHEN to look.
+ */
+const retard = (s: Live, x: number, y: number, t: number) => {
+  let te = t - Math.hypot(x - s.at[0], y - s.at[1]) / LIGHT;
+
+  /**
+   * Two passes, and the second one earned rather than assumed.
+   *
+   * The quadratic below is exact for a source going in a straight line at a
+   * steady rate — but the FIRST guess it starts from is taken from where the
+   * source is now, and for one travelling at ninety-nine hundredths of the
+   * speed of its own light that guess can be most of the picture out. The
+   * velocity then gets looked up at the wrong moment, the quadratic is solved
+   * for the wrong straight line, and the answer is wrong by however far the
+   * source moved in between. Which is not a small error politely spread
+   * about: it is a radius, so it comes out as rings in the wrong place, and
+   * they go wrong only where the source has been quick, which is why it looks
+   * like something tearing rather than something blurred.
+   *
+   * A second pass starts from an answer that is already close and settles it.
+   * Standing still, though, the first pass is exact and the second is a
+   * measurement of nothing — so it is skipped, which is most of the time in
+   * most of these pictures.
+   */
+  for (let pass = 0; pass < 2; pass++) {
+    wasGoing(s, te);
+
+    if (pass > 0 && Math.abs(CARRY[0]) + Math.abs(CARRY[1]) < 1e-6) break;
+
+    const ex = x - RETARD[0], ey = y - RETARD[1];
+    const vx = CARRY[0], vy = CARRY[1];
+
+    // How long there is between te and now, which is what the light has to
+    // cover — less however much further back the answer turns out to be.
+    const a = t - te;
+
+    const A = vx * vx + vy * vy - LIGHT * LIGHT;
+    const B = 2 * (a * LIGHT * LIGHT - (ex * vx + ey * vy));
+    const C = ex * ex + ey * ey - a * a * LIGHT * LIGHT;
+
+    let step = 0;
+
+    if (Math.abs(A) < 1e-9) {
+      if (Math.abs(B) > 1e-9) step = -C / B;
+    } else {
+      const disc = B * B - 4 * A * C;
+      if (disc < 0) break;
+
+      /**
+       * Solved the stable way, which at these speeds is not a nicety.
+       *
+       * A is v² − 1, and a source travelling at ninety-nine hundredths of
+       * light makes that about a fiftieth. Dividing by it is the textbook
+       * formula and it is exactly where the textbook formula falls apart:
+       * one of the two roots comes out as a small difference of two nearly
+       * equal numbers divided by a nearly vanishing one, and what it returns
+       * is not an approximation of the answer, it is thousands of cells of
+       * nonsense. Which is then used as a radius, so the rings it draws are
+       * nowhere near where anything is — and only where the source has been
+       * quick, which is why it tore rather than blurred.
+       *
+       * Taking the well-conditioned root first and getting the other from
+       * the product of the two has neither subtraction of like quantities nor
+       * division by the small coefficient.
+       */
+      const root = Math.sqrt(disc);
+      const q = -0.5 * (B + (B >= 0 ? root : -root));
+
+      const p1 = q / A, p2 = Math.abs(q) > 1e-12 ? C / q : q / A;
+
+      // Of the two, the one that leaves the light a non-negative time to
+      // travel in. The other is the advanced solution, which is the same
+      // algebra describing something arriving before it left.
+      const ok1 = a - p1 >= 0, ok2 = a - p2 >= 0;
+
+      step = ok1 && ok2 ? (Math.abs(p1) < Math.abs(p2) ? p1 : p2)
+        : ok1 ? p1
+          : ok2 ? p2
+            : 0;
+    }
+
+    te = Math.min(te + step, t);
+  }
+
+  return te;
+};
+
+/**
+ * What ONE source puts at a point.
+ *
+ * Two things temper the bare cosine, and both are properties of the world
+ * above rather than decoration. A wave has not arrived yet where r > t·c, so
+ * there is nothing there — softened over a cell, since a lattice front is not
+ * a razor either. And it thins as it goes, because the same emission is
+ * spread over a bigger and bigger circle; in the model that shows up as the
+ * shells growing apart, here as one over the distance.
+ *
+ * And it is measured from where the source WAS, not from where it is: the
+ * ring through this point left when the source was at p(t − r), and it is
+ * centred there for good. Which is what makes a moving source's rings bunch
+ * up ahead of it and stretch out behind, and at the speeds these reach once
+ * they start eating, that bunching is most of what the picture shows.
+ *
+ * r is on both sides of that, so it is solved for rather than computed —
+ * guess it from where the source is now, look up where it was that long ago,
+ * measure again. Three rounds, because a source that is eating closes at the
+ * speed of its own light and the answer directly ahead of it is then a near
+ * thing: everything it emitted on the way arrives at once, which is a real
+ * pile-up and not an artefact, and it takes a round or two to find. The trail
+ * it looks things up in is a record rather than a projection, so nothing
+ * already emitted can move again however hard the solve works.
+ */
+const emit = (
+  s: Live, w: Emitter, x: number, y: number, t: number, reach: number,
+  known?: number,
+) => {
+  // Solving the retarded time is the most expensive thing here, and whoever
+  // called this has usually just done it — for the ray, for the cut, for the
+  // meeting surface. Told the answer, this does not do it a second time.
+  let te = known === undefined ? retard(s, x, y, t) : known;
+
+  was(s, te);
+
+  const dx = x - RETARD[0], dy = y - RETARD[1];
+  const r = Math.hypot(dx, dy);
+
+  // Which way what is here is travelling, which is out from wherever it left.
+  // Local, and needed by anything asking whether two things are meeting or
+  // merely crossing.
+  WAY[0] = r > 1e-9 ? dx / r : 1;
+  WAY[1] = r > 1e-9 ? dy / r : 0;
+
+  /**
+   * Nothing has arrived where the wave has not reached yet, softened over a
+   * cell because a lattice front is not a razor either.
+   *
+   * Only for a source emitting without pause. A pulse train has its own
+   * edges — the shape below is nought outside the pulse and that is the whole
+   * of where it is not — and applying this to one as well says something
+   * false about the first pulse of the train, which left at the very
+   * beginning and so IS the front: its own arrival is used as evidence that
+   * it has not arrived, and it is never drawn at all.
+   */
+  const front = w.beat ? 1 : Math.min((t * LIGHT - r) / 1.5, 1);
+  if (front <= 0) return 0;
+
+  const fade = 1 / (1 + r / reach);
+
+  /**
+   * cos(θ − ψ) without ever working out θ.
+   *
+   * The direction to here is wanted only inside a cosine, and cos(θ − ψ) is
+   * cos θ·cos ψ + sin θ·sin ψ — where cos θ and sin θ are dx/r and dy/r,
+   * which are already to hand. So the arctangent, which is the most expensive
+   * thing in this whole expression and is evaluated once per source per
+   * sample of the picture, is not needed at all.
+   */
+  /**
+   * When what is here left, and — if this source pulses — whether anything
+   * left then at all.
+   *
+   * A pulse train is not a sum over pulses. The nearest multiple of the beat
+   * to the emission time IS the pulse this point could belong to, since the
+   * pulses are narrower than the gaps between them, so one rounding finds it
+   * and one bump says how much of it is here. Everything stays O(1) in the
+   * number of pulses in the air, which by now is a great many.
+   */
+  let shape = 1;
+
+  if (w.beat) {
+    const beat = Math.round(te / w.beat) * w.beat;
+    const u = (te - beat) / PULSE;
+
+    if (u <= -1 || u >= 1 || beat < 0) return 0;
+
+    shape = (1 - u * u) ** 2;
+    te = beat;
+  }
+
+  const psi = w.omega * te + w.phase;
+
+  const wave = w.lobes
+    ? (dx * Math.cos(psi) + dy * Math.sin(psi)) / (r || 1)
+    : Math.cos(psi);
+
+  return front * fade * shape * wave;
+};
+
+/**
+ * And what the two of them do to each other when they are ALIKE, which the
+ * sum on its own does not contain.
+ *
+ * Opposite charges meeting head-on annihilate, and that is the gravity above.
+ * Like charges meeting head-on turn each other around, and nothing so far has
+ * said so — the closed form adds the two contributions and lets them through
+ * one another.
+ *
+ * For most of these pictures that is not the omission it looks like. Two
+ * identical shells bouncing off each other are indistinguishable from two
+ * shells passing through and swapping names: A's charge ends up where B's
+ * would have been and B's where A's would have been, so the set of places
+ * that are charged is the same either way, and so is the phase at each of
+ * them — the bounced charge has travelled exactly as far as the one that came
+ * the other way. The field cannot tell, because the field does not record
+ * which source anything belongs to. Superposition is already right, and the
+ * waves not visibly turning around is not a thing going wrong.
+ *
+ * It stops being right the moment the two are not interchangeable. A bounced
+ * wave carries the phase and the cadence of the source it came from, and
+ * fades with the distance IT has travelled — and if the two sources are half
+ * a cycle apart, or pulsing at different rates, or one of them is moving and
+ * the other is not, then what comes back is not what would have gone through
+ * and the exchange does not cancel.
+ *
+ * A reflection is an image: the wave that bounced arrives as though it had
+ * come from the mirror of its source in the surface it bounced off. That
+ * surface, for a pair, is the plane halfway between them — so the mirror of
+ * one source is the position of the other, and what comes back is the OTHER
+ * one's geometry carrying THIS one's phase. Which is why the two swap out
+ * exactly when they are alike, and why they do not otherwise.
+ *
+ * So the field is the two readings blended by how much of the meeting is
+ * alike rather than opposite, which `survey` measures on its way past. For
+ * matched sources the reflected pair is the direct pair with the names
+ * exchanged, the blend is between a thing and itself, and it reduces to the
+ * plain sum with nothing left over.
+ */
+/**
+ * How far a wave of `a`'s gets before it runs into one of `b`'s.
+ *
+ * Both travel a cell a tick, so waves that left at the same moment meet
+ * halfway — and along a ray that is not aimed straight at the other source,
+ * further, because the surface they meet on is a plane and a slanted ray has
+ * further to go to reach it. Aimed away from the other source it never meets
+ * anything at all, and goes on for ever.
+ *
+ * This is the only thing that stops a wave, and it stops it completely. There
+ * is no thinning, no optical depth, no fraction getting through. A charge
+ * meets another charge and one of two things happens, and neither of them is
+ * "carries on a bit weaker".
+ */
+const HERE: [number, number] = [0, 0];
+const THERE: [number, number] = [0, 0];
+
+const meets = (
+  a: Live, b: Live, dx: number, dy: number, when: number,
+) => {
+  /**
+   * Worked out from where the two of them WERE, not from where they are.
+   *
+   * This is the whole of what makes it local, and getting it wrong is
+   * unmistakable: a wave that left long ago has its stopping place decided by
+   * a surface built out of the sources' present positions, so every time
+   * either of them turns or drifts, the surface swings and every wave already
+   * in the air swings with it. Rings that were laid down years of ticks ago
+   * get up and rotate, which is not a thing waves do. Nothing that has
+   * already happened is allowed to depend on anything that happened after it.
+   *
+   * So both are asked where they were when this wave was in the air, and the
+   * answer is a record — see the trail — rather than anything derived from
+   * now. What was decided then stays decided.
+   */
+  was(a, when);
+  HERE[0] = RETARD[0]; HERE[1] = RETARD[1];
+
+  was(b, when);
+  THERE[0] = RETARD[0]; THERE[1] = RETARD[1];
+
+  let ux = THERE[0] - HERE[0], uy = THERE[1] - HERE[1];
+  const gap = Math.hypot(ux, uy);
+  if (gap < 1e-6) return Infinity;
+
+  ux /= gap; uy /= gap;
+
+  const aim = dx * ux + dy * uy;
+
+  /**
+   * And only where the two would actually be head-on when they got there.
+   *
+   * The surface halfway between a pair is a whole plane, and it is tempting
+   * to stop everything at it — but two waves arriving at a point far out on
+   * that plane are not meeting, they are travelling side by side. Their
+   * directions there are mirror images about the plane, so the angle between
+   * them is set by how squarely the ray was aimed: dead at the other source
+   * they are exactly opposed, and at forty-five degrees off they are already
+   * at right angles and past caring about each other.
+   *
+   * Beyond that the encounter is a crossing. Charges crossing at an angle do
+   * nothing to each other in this model — they pass, and both carry on — so
+   * stopping them there would put a seam down the middle of every picture
+   * where none belongs, and it is why the arms far from the axis have to go
+   * through one another. They are not meeting. They are just both there.
+   */
+  if (aim <= 0.71) return Infinity;
+
+  return (gap / 2) / aim;
+};
+
+/**
+ * A wave of `a`'s that has met one of `b`'s and turned around.
+ *
+ * Which of the two things happened at that meeting is decided THERE, by what
+ * the two of them were, and not by any running average over the picture. Two
+ * charges meeting head-on are alike or they are opposite; alike, they turn
+ * each other round and both go back the way they came; opposite, they
+ * annihilate and neither of them is anywhere afterwards. So this asks the
+ * question at the place and the moment it was settled: what was `a` putting
+ * out along this ray when it got to the meeting, and what was `b` putting
+ * into the same spot at the same instant. Same sign, and there is a wave
+ * coming home. Opposite, and there is nothing — which is the annihilation,
+ * and it needs no separate machinery, because a thing that annihilated simply
+ * has no return.
+ *
+ * And what comes home runs into the shells its own source has emitted since,
+ * head-on, going the other way. A source that turns over is putting out the
+ * opposite charge by then, so what the returning wave meets is its opposite,
+ * and the two cancel. That is the second half of what makes the space between
+ * a pair empty, and it falls out of the arithmetic rather than being put in:
+ * these are all terms in one sum, and terms of opposite sign cancel.
+ *
+ * The going-out and the coming-back are the same wave with the sign of the
+ * radius flipped. Outgoing at distance r left r ago, so its phase runs on
+ * t − r and crests move outward. Having gone to the meeting at R and come
+ * back to r it has travelled 2R − r, so its phase runs on t − 2R + r and
+ * crests move inward. One sign, and that sign is the whole of what bouncing
+ * is.
+ */
+const bounced = (
+  a: Live, b: Live, x: number, y: number, t: number, reach: number,
+  known?: number, given?: number,
+) => {
+  // From where it was when this left it, for the reason given in `fieldAt`.
+  const left = known === undefined ? retard(a, x, y, t) : known;
+
+  was(a, left);
+
+  let dx = x - RETARD[0], dy = y - RETARD[1];
+  const r = Math.hypot(dx, dy);
+  if (r < 1e-6) return 0;
+
+  dx /= r; dy /= r;
+
+  // Asked of the moment this wave was crossing, not of now — or handed
+  // straight over by whoever has already asked.
+  const mirror = given === undefined ? meets(a, b, dx, dy, left) : given;
+  if (!isFinite(mirror) || r >= mirror) return 0;   // nothing has come back to here
+
+  // Out to the meeting and back again: how far this has travelled, and so
+  // how long ago it left.
+  const path = 2 * mirror - r;
+  const te = t - path / LIGHT;
+  if (te < 0) return 0;
+
+  // As above: a train's own pulse shape says where it is, and this would
+  // erase the first of them.
+  const front = a.beat ? 1 : Math.min((t * LIGHT - path) / 1.5, 1);
+  if (front <= 0) return 0;
+
+  let when = te, shape = 1;
+
+  if (a.beat) {
+    const beat = Math.round(when / a.beat) * a.beat;
+    const u = (when - beat) / PULSE;
+
+    if (u <= -1 || u >= 1 || beat < 0) return 0;
+
+    shape = (1 - u * u) ** 2;
+    when = beat;
+  }
+
+  const psi = a.omega * when + a.phase;
+
+  // The angle is the one it LEFT along, since that is the half of the source
+  // it came out of.
+  const mine = a.lobes ? dx * Math.cos(psi) + dy * Math.sin(psi) : Math.cos(psi);
+  if (mine === 0) return 0;
+
+  // What the other one had at that spot when this arrived there. Same sign,
+  // and the two turned each other round; opposite, and they are both gone.
+  was(a, left);
+
+  const hitX = RETARD[0] + dx * mirror, hitY = RETARD[1] + dy * mirror;
+  const struck = t - (mirror - r) / LIGHT;
+
+  const theirs = emit(b, b, hitX, hitY, struck, reach);
+
+  const agree = (mine * theirs) / (Math.abs(mine) * Math.abs(theirs) + 1e-9);
+  const alike = Math.max(agree, 0);
+  if (alike <= 1e-3) return 0;
+
+  // Softened right at the meeting surface, which is a place and not a knife.
+  const edge = Math.min(Math.max((mirror - r) / 1.5, 0), 1);
+
+  /**
+   * Thinned by where it IS, not by how far it has been — which is the
+   * opposite of what it looks like it should be, and is why this was so hard
+   * to see.
+   *
+   * The thinning is a shell spread round a growing circle: the same emission
+   * stretched over a longer and longer ring, so it goes as the radius. A
+   * shell coming home sits on a circle exactly the size of an outgoing
+   * shell's at the same radius, and it is CONTRACTING — its charges are being
+   * gathered back onto a shorter and shorter ring, so it gets denser as it
+   * returns rather than fainter.
+   *
+   * Faded by the whole path instead, as it was, a returning wave is dimmed by
+   * twice the distance to the surface while the outgoing wave drawn at the
+   * same place is dimmed by almost nothing. It was in the arithmetic and
+   * underneath the wave it had bounced off, worst of all near the source
+   * where it should have been brightest.
+   *
+   * The path still sets the phase. How far a thing has travelled is when it
+   * left; it is not how spread out it is.
+   */
+  return alike * edge * front * shape * mine / (1 + r / reach);
+};
+
+/**
+ * What is at a place: everything that got there, going out and coming back.
+ *
+ * A plain sum, and it can be, because nothing in it is a wave that should not
+ * be there. A wave stops dead at the first thing it meets — that is `meets`
+ * above, applied to every outgoing term — so two sources' waves never overlap
+ * beyond their meeting surface and there is no crossing to suppress. What is
+ * left to add up is a handful of waves that genuinely coexist, and adding is
+ * the right thing to do with those: where two of them are opposite they
+ * cancel, which is annihilation, drawn.
+ *
+ * Which is why the returning wave puts out the space between a pair without
+ * anything being written to make it. It comes home into shells its own source
+ * threw out later, and a source that turns over threw the opposite charge;
+ * they are opposite terms in a sum, and they go.
+ */
+const MIRRORS: number[] = [];
+
+const fieldAt = (
+  x: number, y: number, t: number, sources: Live[], reach: number,
+) => {
+  let total = 0;
+
+  for (const a of sources) {
+    /**
+     * Measured from where this source WAS when the wave here left it.
+     *
+     * Not from where it is. The two are the same thing only for a source
+     * standing still, and these travel at ninety-nine hundredths of the speed
+     * of what they emit — so the distance to the present source and the
+     * distance the wave actually came differ by most of the picture. Taking
+     * the ray and the radius from the present position while the surface it
+     * is being cut against is worked out from the past one is two different
+     * geometries compared against each other, and what that produces is a
+     * cut at the wrong radius: a hole where a wave was stopped that never met
+     * anything, standing between the pair and following them about.
+     */
+    const when = retard(a, x, y, t);
+
+    was(a, when);
+
+    let dx = x - RETARD[0], dy = y - RETARD[1];
+    const r = Math.hypot(dx, dy) || 1e-9;
+
+    dx /= r; dy /= r;
+
+    // As far as the nearest thing that was in the way when it went past, and
+    // no further.
+    let stop = Infinity;
+    let seen = 0;
+
+    for (const b of sources) {
+      if (b === a) continue;
+
+      const at = meets(a, b, dx, dy, when);
+
+      MIRRORS[seen++] = at;
+      if (at < stop) stop = at;
+    }
+
+    if (r < stop) {
+      // Faded over a cell at the surface, so the end of a wave is a place
+      // rather than an event.
+      const edge = isFinite(stop) ? Math.min((stop - r) / 1.5, 1) : 1;
+
+      total += emit(a, a, x, y, t, reach, when) * edge;
+    }
+
+    // Only where something was in the way. Over most of any of these pictures
+    // nothing is — a ray not aimed at the other source never meets it — and
+    // asking `bounced` anyway means solving a retarded time and a meeting
+    // surface all over again to be told so.
+    seen = 0;
+
+    for (const b of sources) {
+      if (b === a) continue;
+
+      const mirror = MIRRORS[seen++];
+      if (!isFinite(mirror) || r >= mirror) continue;
+
+      total += bounced(a, b, x, y, t, reach, when, mirror);
+    }
+  }
+
+  return total;
+};
+
+/**
+ * Where space is being destroyed, asked of places rather than of pairs.
+ *
+ * This is the piece that adding cosines does not give you, and without it the
+ * continuous version is not the same physics — it is the same picture with
+ * the gravity left out. Two opposite charges meeting in the model do not
+ * average to nothing and stay where they are. They ANNIHILATE, and
+ * annihilating takes the point each of them was on out of the world, which
+ * leaves whatever was on either side of them nearer together. That is the
+ * whole of why two magnets attract here: not a force between them, an ongoing
+ * loss of the space in between.
+ *
+ * The first version of this asked the question of a PAIR — walk the line
+ * joining two named sources, see how much of what meets there is opposite.
+ * It gives the right rate and it is the wrong question, because it is not a
+ * question about anywhere. It needs to know which sources exist and which two
+ * of them are being considered, and it produces one number for the pair
+ * rather than a fact about each place. Nothing built on it can deflect a
+ * third thing, because a third thing is not in the sum.
+ *
+ * Asked of a place, it is local, and everything it needs is at that place.
+ * How much of each charge is here; which way each of them is travelling; and
+ * therefore how much of what is here is meeting head-on rather than crossing.
+ * Two things annihilate when they are opposite in charge AND opposed in
+ * direction — one without the other is a crossing, not a collision — so both
+ * factors are in it, and both are readable on the spot.
+ *
+ * What comes out is the field this model puts where mass usually goes:
+ * annihilation per unit of space per tick. It is not a property anything has.
+ * It is something that happens somewhere.
+ */
+const SITES: number[] = [];                       // x, y, eaten, nx, ny, met — six at a time
+let siteCount = 0;
+
+/**
+ * How much space a tick's worth of meeting destroys, which is the one number
+ * tying the continuous rate to the discrete one.
+ *
+ * A source emits a shell every tick and shells travel a cell a tick, so along
+ * any line between two of them one shell meets one shell every tick, and a
+ * meeting of opposites takes two cells out of the world. That is the whole of
+ * the rate, and it is a COUNT — one meeting, two cells — with nothing in it
+ * about how large the region is where the meeting happens.
+ *
+ * Which is the thing the survey below cannot supply and must not be asked to.
+ * It measures a density, and a density integrated over an area gives a number
+ * that grows with the area: two sources far apart overlap over more of the
+ * picture than two close together, and reading their annihilation off that
+ * integral has them eating faster the further apart they are, which is not
+ * merely wrong but backwards. Everything the survey knows is WHERE the eating
+ * is happening and along what. How MUCH is set here, by the cadence, and
+ * shared out over the places in proportion to what is going on at each.
+ *
+ * So the survey's numbers are a shape and this is the size of it. The one
+ * thing left for the survey to say about magnitude is the share — how much of
+ * what meets is opposite rather than alike — which is dimensionless, is
+ * between nought and one, and is exactly what it should be reporting: a pair
+ * eating all of what they send each other, or half of it, or none.
+ */
+const BITE = 2 * LIGHT;
+
+/**
+ * And how far the loss of a point is felt, which is not far.
+ *
+ * A collision removes the two points its charges were on and joins what was
+ * behind each directly to the other. That shortens the LINE they were on and
+ * does nothing whatever to a point off to the side, which is joined to the
+ * world by paths that never went through the collision. So the influence of
+ * an annihilation is confined to a neighbourhood of it, and this is the size
+ * of that neighbourhood.
+ *
+ * Which is a real claim and an unusual one. Gravity here is not long-range,
+ * and it is not something a mass has and radiates. It acts along the lines
+ * where annihilation is actually happening, which is to say between things
+ * that are cancelling each other's emissions. A body that emits nothing feels
+ * nothing, however much is going on beside it.
+ *
+ * But it must not be smaller than the grid the annihilation was surveyed on,
+ * and that is what it was. A few cells, against sites laid out one every few
+ * cells, gives a field that is a row of separate little pushes with nothing
+ * between them: a body sitting on the axis is either on top of one, where the
+ * transverse falloff is flat because it is at the peak of it, or between two,
+ * where there is nothing at all. Either way it feels no gradient, and a body
+ * that feels no gradient is never turned — which was the whole complaint. The
+ * loss has to be smeared over at least the spacing of the places it was
+ * measured at, or what is being drawn is the grid rather than the field.
+ */
+let LOCAL = 3;                                    // cells, set by the survey
+
+// How far apart the closest pair are, which is the distance the pull has to
+// work over. Also set by the survey.
+let SPREAD = 1;
+
+/**
+ * Survey the framed region for it, once a tick.
+ *
+ * A coarse grid is enough: what is being looked for is where the annihilation
+ * is, and it is spread over the overlap of two fields rather than
+ * concentrated at points. Everything below a fraction of the strongest is
+ * dropped, because most of any of these pictures is space where nothing is
+ * meeting anything and summing a few hundred nothings into every query is the
+ * whole cost of this.
+ */
+const survey = (live: Live[], t: number, reach: number, span: number) => {
+  const STEPS = 22;
+
+  siteCount = 0;
+  SITES.length = 0;
+
+  if (live.length < 2) return;
+
+  // Centred on the sources, since that is where anything is.
+  let mx = 0, my = 0;
+  for (const s of live) { mx += s.at[0] / live.length; my += s.at[1] / live.length; }
+
+  /**
+   * And it looks at the pair, not at the picture.
+   *
+   * The grid was laid across the whole view, so its cells are a couple of
+   * cells of world across — which is fine while the two are far apart and
+   * useless the moment they are not. A pair three cells apart has the whole
+   * of its encounter inside ONE cell of that grid: the survey finds a site or
+   * two in roughly the right place, or none at all, and the pull collapses
+   * exactly as the two are closing on each other. They drifted together,
+   * slowed for no reason in the model, and stopped short.
+   *
+   * Framed on the pair instead, the resolution follows them down. What is
+   * being measured is where annihilation is happening, and that is between
+   * them, wherever they have got to and however little room it now takes.
+   */
+  let nearest = Infinity;
+
+  for (let i = 0; i < live.length; i++)
+    for (let j = i + 1; j < live.length; j++)
+      nearest = Math.min(nearest, Math.hypot(
+        live[j].at[0] - live[i].at[0], live[j].at[1] - live[i].at[1],
+      ));
+
+  const look = Math.min(span, Math.max(isFinite(nearest) ? nearest * 1.6 : span, 5));
+  const step = (2 * look) / STEPS;
+
+  // Wide enough that the sites blend into a field rather than staying a row
+  // of separate pushes, which is what gives it a gradient to turn anything
+  // with. See `LOCAL`.
+  LOCAL = Math.max(step * 2, 1.5);
+  SPREAD = Math.max(isFinite(nearest) ? nearest / 4 : step, 0.75);
+
+  const val: number[] = [];
+  const dirX: number[] = [];
+  const dirY: number[] = [];
+
+  let strongest = 0;
+
+  // What the picture is doing as a whole: how much of what meets is opposite,
+  // and how much meets at all. Their ratio is the only thing about magnitude
+  // the survey has any business reporting.
+  let cancelling = 0, meeting = 0;
+
+  for (let gy = 0; gy < STEPS; gy++) {
+    const y = my - look + (gy + 0.5) * step;
+
+    for (let gx = 0; gx < STEPS; gx++) {
+      const x = mx - look + (gx + 0.5) * step;
+
+      for (let i = 0; i < live.length; i++) {
+        val[i] = emit(live[i], live[i], x, y, t, reach);
+        dirX[i] = WAY[0]; dirY[i] = WAY[1];
+      }
+
+      // What is annihilating here, and what is meeting here at all — which
+      // is more, because alike charges meeting head-on turn around rather
+      // than cancelling, and either way they stop going forwards.
+      let rate = 0, here = 0, nx = 0, ny = 0;
+
+      for (let i = 0; i < live.length; i++) {
+        for (let j = i + 1; j < live.length; j++) {
+          const both = val[i] * val[j];
+
+          // How much of what is here is one field against the other at all,
+          // whichever way round — the denominator of the share.
+          const closing = Math.max(-(dirX[i] * dirX[j] + dirY[i] * dirY[j]), 0);
+          if (closing <= 0) continue;             // crossing, not meeting
+
+          here += Math.abs(both) * closing;
+          meeting += Math.abs(both) * closing;
+
+          // Opposite in charge as well as opposed in direction: annihilation
+          // rather than a bounce.
+          const against = Math.max(-both, 0) * closing;
+          if (against <= 0) continue;
+
+          rate += against;
+
+          // The line they are meeting along, which is the line that shortens.
+          nx += (dirX[i] - dirX[j]) * against;
+          ny += (dirY[i] - dirY[j]) * against;
+        }
+      }
+
+      if (here <= 0) continue;
+
+      cancelling += rate;
+
+      const len = Math.hypot(nx, ny) || 1;
+
+      SITES.push(x, y, rate, nx / len, ny / len, here);
+      siteCount++;
+
+      if (here > strongest) strongest = here;
+    }
+  }
+
+  // Note there is no global reading of how much bounces and how much
+  // annihilates. That question is settled at each meeting by what the two
+  // charges there are, in `bounced` above — a share taken over the whole
+  // picture is an average of a decision, and an average of a decision is not
+  // a thing anything experiences.
+
+  if (!strongest) { SITES.length = 0; siteCount = 0; return; }
+
+  // Thinned to what is worth summing over, and the total kept with it so that
+  // what is dropped is not quietly handed to what is not.
+  const floor = strongest * 0.05;
+  let kept = 0, total = 0;
+
+  let seen = 0;
+
+  for (let k = 0; k < siteCount; k++) {
+    if (SITES[k * 6 + 5] < floor) continue;
+
+    for (let c = 0; c < 6; c++) SITES[kept * 6 + c] = SITES[k * 6 + c];
+
+    total += SITES[kept * 6 + 2];
+    seen += SITES[kept * 6 + 5];
+    kept++;
+  }
+
+  SITES.length = kept * 6;
+  siteCount = kept;
+
+  // The meeting is kept as it was measured — a density, per unit of space,
+  // per tick. Normalising it to a share of the whole encounter, which is what
+  // it used to do, is what made the shadow useless: a wave crossing the gap
+  // met "a fifth of the total" however thick the thing it was crossing, so
+  // the attenuation stopped depending on how much was actually in the way.
+  // What a wave loses is a density times a path, and both of those have to
+  // survive to the place that multiplies them.
+
+  /**
+   * Rebuilt whatever else is true of this tick, and before anything can
+   * return early.
+   *
+   * A shadow is a fact about where the sources are NOW. Left over from the
+   * tick before while they have moved on — which is what happened whenever a
+   * pair was bouncing without annihilating, since there was nothing to scale
+   * and the function gave up before reaching this — it darkens places nothing
+   * is crossing any more, and the picture fills with patches of black that
+   * belong to a configuration that has gone.
+   */
+
+  if (!kept || total <= 0) return;
+
+  /**
+   * And the whole of it scaled to what a tick's meeting actually costs.
+   *
+   * The share is how much of the encounter annihilates rather than bounces,
+   * which is between nought and one and says nothing about how big the
+   * encounter is. Multiplied by `BITE`, that is the space a tick destroys.
+   * Divided out over the sites in proportion to what each is doing, the
+   * distribution stays exactly what was measured and the total stops being an
+   * accident of how much of the picture the two fields happen to overlap in.
+   */
+  const share = meeting > 1e-12 ? cancelling / meeting : 0;
+
+  /**
+   * And the size of it is fixed by what the pair actually do to each other,
+   * not by what the sites happen to add up to.
+   *
+   * A meeting costs two cells: the charge arriving is on a point, the charge
+   * it meets is on the next one, and annihilating is both of them ceasing to
+   * be anywhere. One meeting a tick, so two cells a tick, times the share of
+   * the encounter that is opposite rather than alike. That is the whole rate
+   * and it is a count — it does not know or care how the annihilation is
+   * spread about.
+   *
+   * Scaling the SITES to sum to it is not the same thing and was the error.
+   * What a source is moved by is not the sum of the sites, it is the flow it
+   * stands in — the sum after each site's reach has fallen away across the
+   * distance and off to the side. Most of it never arrives. So the sites
+   * summed to two cells a tick and the pair closed at a fifth of one, and
+   * every picture of two things attracting was running at a fraction of the
+   * rate the rule gives, with the fraction set by how the survey's kernels
+   * happened to overlap.
+   *
+   * Measured at the sources instead: lay the sites down at whatever relative
+   * strengths they were found with, ask how fast the gap between the pair is
+   * closing under that, and scale the lot until the answer is two cells a
+   * tick. Then the shape is the survey's and the size is the rule's, which is
+   * the right division of labour between the two.
+   */
+  for (let k = 0; k < kept; k++) SITES[k * 6 + 2] /= total;
+
+  let closes = 0;
+
+  for (let i = 0; i < live.length; i++) {
+    for (let j = i + 1; j < live.length; j++) {
+      const a = live[i], b = live[j];
+
+      let ux = b.at[0] - a.at[0], uy = b.at[1] - a.at[1];
+      const apart = Math.hypot(ux, uy);
+      if (apart < 1e-6) continue;
+
+      ux /= apart; uy /= apart;
+
+      flowAt(a.at[0], a.at[1]);
+      const ain = FLOW[0] * ux + FLOW[1] * uy;
+
+      flowAt(b.at[0], b.at[1]);
+      const bin = -(FLOW[0] * ux + FLOW[1] * uy);
+
+      closes += ain + bin;
+    }
+  }
+
+  if (closes <= 1e-9) return;
+
+  const want = BITE * share;
+
+  for (let k = 0; k < kept; k++) SITES[k * 6 + 2] *= want / closes;
+};
+
+// The optical-depth shadow that used to live here is gone. A wave is not
+// thinned by what it passes through — it stops dead at the first thing it
+// meets, which is `meets` above — so there was nothing left for it to say,
+// and it was still being rebuilt over the whole grid every tick.
+
+/**
+ * The flow of space, which is where gravity actually is.
+ *
+ * Each place that is destroying space draws what is around it inwards along
+ * the line the collision there is happening on: everything on one side comes
+ * one way, everything on the other side comes the other, and a point off to
+ * the side barely moves at all. Summed over everywhere that is doing it, that
+ * is the whole field, and nothing in the sum knows about sources or pairs —
+ * only about places and what is happening at them.
+ *
+ * And there is the deflection, for free and without a force anywhere. The
+ * flow has a gradient, so it does not merely carry a body — it turns it. A
+ * velocity is a displacement per tick, and a displacement in a space that is
+ * being sheared comes out pointing somewhere else. Nothing accelerates: the
+ * body's own motion is untouched and its speed never changes. It is carried,
+ * and what carries it is not uniform.
+ */
+/**
+ * The space itself, kept between ticks, and how fast it is going.
+ *
+ * Everything before this treated gravity as a speed: work out where
+ * annihilation is happening, work out how fast that drags each source, move
+ * it that far, throw the answer away and do it again next tick. Which cannot
+ * be right, and the discrete rule says why. `annihilate` does not push
+ * anything. It rewires — the point behind one dying charge is spliced
+ * directly onto the point behind the other — and it STAYS rewired. The state
+ * is in the space, not in the bodies, and a speed recomputed from scratch
+ * every tick is precisely a model with no state in the space at all.
+ *
+ * So the space gets a displacement of its own, `h`, which is how far each
+ * place has been carried from where it started, and it is kept. Annihilation
+ * adds to it and nothing takes it away: once the ground between two things
+ * has gone, it has gone, and they are nearer whether or not anything is still
+ * eating.
+ *
+ * And `h` is given a wave equation rather than being applied where it is
+ * made. A contraction here has to reach a place over there, and it has to
+ * take the time light takes — so the field obeys
+ *
+ *     d²h/dt² = c² ∇²h + S
+ *
+ * with S the annihilation. Ripples in `h` then travel outward at exactly c,
+ * which is what a gravitational wave is: not a thing added to the model, but
+ * what persistence and a finite speed give you together the moment you stop
+ * applying the answer instantly and everywhere. Neither alone produces one.
+ *
+ * A grid fixed for the whole run, unlike the survey's, which re-frames on the
+ * pair every tick. A field that is carried from one tick to the next cannot
+ * be resampled onto a moving grid without smearing everything it remembers.
+ */
+type Warp = {
+  hx: Float32Array; hy: Float32Array;             // where each place has got to
+  vx: Float32Array; vy: Float32Array;             // and how fast it is going
+  sx: Float32Array; sy: Float32Array;             // what is driving it this tick
+  n: number; x0: number; y0: number; step: number;
+};
+
+const warp = (span: number): Warp => {
+  // Forty across is enough to carry a wave and cheap enough to ask the
+  // calibrated flow at every one of its places, once a tick.
+  const n = 40;
+  const step = (2 * span) / n;
+
+  return {
+    hx: new Float32Array(n * n), hy: new Float32Array(n * n),
+    vx: new Float32Array(n * n), vy: new Float32Array(n * n),
+    sx: new Float32Array(n * n), sy: new Float32Array(n * n),
+    n, x0: -span, y0: -span, step,
+  };
+};
+
+// Read between the grid's places, since it is asked at arbitrary points.
+const WARP: [number, number] = [0, 0];
+
+const warpAt = (w: Warp, a: Float32Array, b: Float32Array, x: number, y: number) => {
+  const fx = Math.min(Math.max((x - w.x0) / w.step, 0), w.n - 1.001);
+  const fy = Math.min(Math.max((y - w.y0) / w.step, 0), w.n - 1.001);
+
+  const i = Math.floor(fx), j = Math.floor(fy);
+  const u = fx - i, v = fy - j;
+
+  const k = j * w.n + i;
+
+  WARP[0] = (a[k] * (1 - u) + a[k + 1] * u) * (1 - v)
+    + (a[k + w.n] * (1 - u) + a[k + w.n + 1] * u) * v;
+  WARP[1] = (b[k] * (1 - u) + b[k + 1] * u) * (1 - v)
+    + (b[k + w.n] * (1 - u) + b[k + w.n + 1] * u) * v;
+};
+
+/**
+ * One step of it.
+ *
+ * The annihilation found this tick is laid down as the source term — the same
+ * shape `flowAt` used to hand straight to the sources, put into the field
+ * instead — and then the field is left to carry it. The Laplacian is the
+ * plain five-point one, which is all a wave equation on a grid needs, and the
+ * time step is a fraction of a cell against a speed of one, so it is nowhere
+ * near the limit where that would misbehave.
+ *
+ * A little damping, because nothing here should ring for ever: an annihilation
+ * that has finished leaves its displacement behind, which is the point, but
+ * the SPEED it left the space with has to die away or the picture keeps
+ * sloshing long after anything is happening.
+ */
+const warpStep = (w: Warp, dt: number) => {
+  const { hx, hy, vx, vy, sx, sy, n, step } = w;
+
+  /**
+   * What the space would be doing here if the annihilation acted at once,
+   * which is what the survey has already been calibrated to give.
+   *
+   * Used as the speed the field is DRAWN TOWARDS rather than as a force added
+   * to it — which keeps the one number that ties this to the discrete rule.
+   * `survey` scales the sites so that a pair whose every meeting cancels
+   * would close at two cells a tick, and if that were integrated as an
+   * acceleration the speed would simply grow past it and the calibration
+   * would mean nothing. Relaxed towards, the near field settles at exactly
+   * the rate the rule gives, and everything the wave equation adds is what
+   * happens on the way there and further out.
+   */
+  for (let j = 0; j < n; j++) {
+    for (let i = 0; i < n; i++) {
+      const k = j * n + i;
+
+      flowAt(w.x0 + i * step, w.y0 + j * step);
+
+      sx[k] = FLOW[0]; sy[k] = FLOW[1];
+    }
+  }
+
+  // A step of the wave equation: the Laplacian carries it, at exactly the
+  // speed of light in the units everything else here is in.
+  const c2 = LIGHT * LIGHT / (step * step);
+  const pull = 2.5;
+
+  for (let j = 1; j < n - 1; j++) {
+    for (let i = 1; i < n - 1; i++) {
+      const k = j * n + i;
+
+      const lx = hx[k - 1] + hx[k + 1] + hx[k - n] + hx[k + n] - 4 * hx[k];
+      const ly = hy[k - 1] + hy[k + 1] + hy[k - n] + hy[k + n] - 4 * hy[k];
+
+      vx[k] += (c2 * lx + (sx[k] - vx[k]) * pull) * dt;
+      vy[k] += (c2 * ly + (sy[k] - vy[k]) * pull) * dt;
+    }
+  }
+
+  // And the displacement keeps what the speed has given it. Nothing takes it
+  // back: once the ground has gone it has gone.
+  for (let k = 0; k < hx.length; k++) { hx[k] += vx[k] * dt; hy[k] += vy[k] * dt; }
+};
+
+/**
+ * How steeply the ground falls away here.
+ *
+ * The flow has exactly one scalar in it — how fast the space is going — and
+ * the slope of half its square is where everything else comes from. That is
+ * not a choice: a flow which is the gradient of something obeys
+ * `(u . grad) u = grad(|u|^2 / 2)`, and `(u . grad) u` is what a thing sitting
+ * still in the coordinates is carried by as the flow it is standing in
+ * accelerates. So the slope of `|u|^2 / 2` IS the free-fall acceleration, and
+ * it is the same quantity Newton called the gradient of a potential — a river
+ * running in at `sqrt(2M/r)` has half its square equal to `M/r` exactly.
+ *
+ * Which means nothing here is imported. The rule is still that annihilation
+ * takes two cells out of the space between whatever is annihilating. The flow
+ * is what that does to the space. And a falloff nobody put in — the whole
+ * inverse-square of it — is sitting in that flow already, waiting to be
+ * differentiated.
+ *
+ * Read over three quarters of a cell either side, which is wide enough to see
+ * past the survey's own grid and narrow enough to still be local.
+ */
+const NUDGE = 0.75;
+
+const river = (w: Warp, x: number, y: number) => {
+  warpAt(w, w.vx, w.vy, x, y);
+
+  return (WARP[0] * WARP[0] + WARP[1] * WARP[1]) / 2;
+};
+
+const FALL: [number, number] = [0, 0];
+
+const fallAt = (w: Warp, x: number, y: number) => {
+  FALL[0] = -(river(w, x + NUDGE, y) - river(w, x - NUDGE, y)) / (2 * NUDGE);
+  FALL[1] = -(river(w, x, y + NUDGE) - river(w, x, y - NUDGE)) / (2 * NUDGE);
+};
+
+/**
+ * What movement itself does to the space it is moving through.
+ *
+ * `consumeAhead` is a SWAP: the ray takes the point in front of it and that
+ * point ends up behind. So anything going anywhere is laying space down
+ * behind itself at exactly the rate it takes it up in front, one cell for
+ * every cell it goes — and the space it crosses is not merely crossed, it is
+ * carried from one end of the thing to the other.
+ *
+ * Which is the other half of what happens between two sources. The
+ * annihilation between them takes space OUT and draws them together. The
+ * motion of each puts space BACK, behind it, and pushes them apart. Where
+ * those balance is where a pair neither closes nor escapes.
+ *
+ * Two things about how this is written, and both were got wrong first.
+ *
+ * It is never its own. A thing does not feel its own wake: the taking in
+ * front and the laying behind are not two forces on it that happen to cancel
+ * — they are what its moving IS, and `vel` already counts them. Put on the
+ * grid with everything else, where there is no way to ask whose wake a place
+ * is in, each source read its own and got a shove forward of about two thirds
+ * of its own pace on top of its own pace, every tick, compounding through the
+ * field. That is a rocket, and it showed as sources tearing away in the
+ * direction they were already going.
+ *
+ * And it is retarded, off the same trail `emit` uses. A wake is news, and
+ * news travels at one cell a tick like everything else here.
+ */
+const WAKE: [number, number] = [0, 0];
+
+// How far in front the taking happens and how far behind the laying: one
+// point either side, in a lattice whose points are one apart.
+const SWAP = 0.5;
+
+const wakeAt = (s: Live, x: number, y: number, t: number) => {
+  WAKE[0] = 0; WAKE[1] = 0;
+
+  const when = retard(s, x, y, t);
+  if (!isFinite(when)) return;
+
+  wasGoing(s, when);
+
+  const px = RETARD[0], py = RETARD[1];
+  const pace = Math.hypot(CARRY[0], CARRY[1]);
+  if (pace < 1e-9) return;
+
+  const ax = CARRY[0] / pace, ay = CARRY[1] / pace;
+
+  // A point of space being made pushes what is around it away; a point being
+  // taken up draws it in. Movement is one of each, half a cell apart, and far
+  // off the two very nearly cancel — which is exactly right, and is why a
+  // swap is not a source of anything. Near to, they do not.
+  for (let k = 0; k < 2; k++) {
+    const side = k ? -SWAP : SWAP;
+    const sign = k ? 1 : -1;
+
+    const ex = x - (px + ax * side), ey = y - (py + ay * side);
+
+    const r = Math.hypot(ex, ey);
+    if (r < SWAP) continue;
+
+    WAKE[0] += sign * pace * ex / (r * 2 * Math.PI * r);
+    WAKE[1] += sign * pace * ey / (r * 2 * Math.PI * r);
+  }
+};
+
+const FLOW: [number, number] = [0, 0];
+
+const flowAt = (x: number, y: number) => {
+  FLOW[0] = 0; FLOW[1] = 0;
+
+  for (let k = 0; k < siteCount; k++) {
+    const sx = SITES[k * 6], sy = SITES[k * 6 + 1];
+    const q = SITES[k * 6 + 2];
+    const nx = SITES[k * 6 + 3], ny = SITES[k * 6 + 4];
+
+    const ex = x - sx, ey = y - sy;
+
+    const on = ex * nx + ey * ny;
+    const off = ex * -ny + ey * nx;
+
+    /**
+     * Everything on one side comes one way and everything on the other comes
+     * the other, so the line through it is shorter by `q` and the place
+     * itself does not move.
+     *
+     * Saturating over the distance the pair are apart, not over the size of
+     * the picture. Tied to the picture, the pull quietly gave out exactly
+     * when it should have been strongest: a pair a few cells apart has every
+     * site a few cells from each of them, and `tanh` of a few cells over a
+     * width set by the whole view is almost nothing — so they drifted
+     * together, slowed, and stopped short of touching for no reason in the
+     * model at all.
+     */
+    const side = Math.tanh(on / SPREAD);
+    const fade = Math.exp(-((off / LOCAL) ** 2));
+
+    FLOW[0] -= (q / 2) * side * fade * nx;
+    FLOW[1] -= (q / 2) * side * fade * ny;
+  }
+
+  /**
+   * And no place of space goes faster than light, whatever the sites add up
+   * to.
+   *
+   * Not a safety rail — it is the same rule everything else here obeys, and
+   * without it the calibration in `survey` has a hole in it. That divides by
+   * how fast the sites it found happen to close the pair, and when the two
+   * are nearly touching, or arranged so that what is being eaten is mostly
+   * off to the side of the line between them, the measured closing goes to
+   * almost nothing while the rate the rule asks for does not. The quotient
+   * runs away. Measured on the fly-by that pulses every fifth tick, the flow
+   * carrying a source reached three hundred and fifty thousand cells a tick
+   * and the pair were flung four hundred cells apart in forty.
+   *
+   * Held to light, the same arrangement simply closes as fast as anything can
+   * close and no faster. The pair still meet, the gap still goes at two cells
+   * a tick between them, and the number that used to be unbounded is now the
+   * one bound this whole model has.
+   */
+  const going = Math.hypot(FLOW[0], FLOW[1]);
+
+  if (going > LIGHT) { FLOW[0] *= LIGHT / going; FLOW[1] *= LIGHT / going; }
+};
+
+// A 4x4 ordered pattern, centred on nought and worth about one level of an
+// eight-bit channel. See the use below.
+const DITHER = [
+  0, 8, 2, 10,
+  12, 4, 14, 6,
+  3, 11, 1, 9,
+  15, 7, 13, 5,
+].map(v => (v / 16) - 0.5);
+
+/**
+ * One canvas of it, evaluated rather than simulated.
+ *
+ * Every sample is independent of every other, so there is no state to carry
+ * between frames and nothing to ease: the drawn field IS the field, at
+ * whatever real-valued t the clock has reached. Which is the visible payoff
+ * of having a function rather than a run — the animation above has to walk
+ * towards each tick because the world only exists at whole ones, and this
+ * one is simply continuous, so it moves the way a wave moves.
+ *
+ * Drawn small and stretched. The field has no detail below the scale of its
+ * own bands, so sampling it at every pixel is spending several times over
+ * for a picture that is smooth by construction; a quarter-scale buffer drawn
+ * up with the canvas's own interpolation is the same image for a sixteenth
+ * of the arithmetic.
+ */
+export const ContinuousField = ({
+  sources,
+  height = 320,
+  span = 14,
+  rate = 10,
+  cycle = 200,
+}: {
+  sources: Emitter[];
+
+  // How much of the world is on screen, as a radius in cells.
+  span?: number;
+
+  // Ticks a second, and it need not be a whole number of anything.
+  rate?: number;
+
+  // Ticks before it starts again from the beginning. A pair that closes on
+  // each other ends up adjacent and then has nothing left to do — neither is
+  // space, so neither can be moved through, and adjacent is as close as
+  // adjacent gets. Watching that happen is the point; watching it having
+  // happened is not.
+  cycle?: number;
+
+  height?: number;
+}) => <CanvasView
+  height={height}
+  deps={[sources, span, rate, cycle]}
+  paint={() => {
+    // The small buffer the field is evaluated into, before being drawn up to
+    // the size of the canvas.
+    const buf = document.createElement("canvas");
+    const bufCtx = buf.getContext("2d")!;
+
+    let img: ImageData | null = null;
+
+    let t = 0;
+
+    // Where the sources have got to. The ones handed in say where they start,
+    // and nothing about where they stay.
+    let live: Live[] = [];
+
+    let field = warp(span);
+
+    const reset = () => {
+      t = 0;
+      field = warp(span);
+      live = sources.map(s => ({
+        ...s,
+        at: [...s.at] as [number, number],
+        path: [s.at[0], s.at[1]],
+        vel: [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number],
+      }));
+    };
+
+    // Everywhere each of them has been, kept up to the moment. Filled to the
+    // current time rather than appended to once per frame, so the record is
+    // evenly spaced whatever the frame rate happens to be doing.
+    const remember = () => {
+      for (const s of live) {
+        for (let k = s.path.length / 2; k <= t / TRAIL; k++) {
+          s.path.push(s.at[0], s.at[1]);
+        }
+      }
+    };
+
+    function draw({ ctx, width: w, height: h }: Surface) {
+
+      /**
+       * Css pixels to a sample, and it cannot be one number.
+       *
+       * What has to be resolved is a band, and a band is `CYCLE/2` cells of
+       * world however the view is set — so how many pixels it covers depends
+       * entirely on how far out the camera is. A single source framed at
+       * fourteen cells gives a band forty-odd pixels and four pixels a sample
+       * is plenty. The same four pixels against a pair framed at sixty gives a
+       * band ten pixels wide and two and a half samples across it, which is
+       * under what it takes to see a wave at all: what gets drawn there is not
+       * a coarse version of the field, it is the moiré of a grid beating
+       * against one, and no amount of smoothing afterwards recovers it.
+       *
+       * So the sampling follows the bands rather than the screen. Five or so to
+       * a band everywhere, which is what the wide views were missing and what
+       * the close ones were spending several times over.
+       */
+      const bandPx = (CYCLE / 2) * (Math.min(w, h) / (2 * Math.max(span, 1)));
+
+      const SAMPLE = Math.max(Math.min(bandPx / 5, 4), 1.4);
+
+      const cols = Math.max(Math.round(w / SAMPLE), 1);
+      const rows = Math.max(Math.round(h / SAMPLE), 1);
+
+      if (buf.width !== cols || buf.height !== rows) {
+        buf.width = cols; buf.height = rows;
+        img = null;
+      }
+
+      // Asked for once and written over ever after. At this sampling it is a
+      // hundred thousand pixels a frame, and handing that back to be
+      // collected sixty times a second is most of what the drawing would
+      // otherwise cost.
+      if (!img) img = bufCtx.createImageData(cols, rows);
+
+      const px = img.data;
+
+      // Cells to the shorter side of the picture, so the same world is framed
+      // whatever shape the canvas is.
+      const scale = Math.min(w, h) / (2 * span);
+      const reach = span * 0.6;
+
+      for (let y = 0; y < rows; y++) {
+        const wy = ((y + 0.5) * (h / rows) - h / 2) / scale;
+
+        for (let x = 0; x < cols; x++) {
+          const wx = ((x + 0.5) * (w / cols) - w / 2) / scale;
+
+          const v = Math.max(Math.min(fieldAt(wx, wy, t, live, reach), 1), -1);
+
+          /**
+           * Amber one way, cyan the other, and the background where the two
+           * meet — so a seam is a dark channel and needs no line drawn on it.
+           *
+           * Shown at the strength it actually has, which it was not. A gamma
+           * of about a half lifts the faint parts of a picture towards the
+           * bright ones, and here that is a lie with consequences: a wave
+           * thinned to a hundredth of itself by distance and by everything it
+           * has crossed was being drawn at a fifth, so the outer half of
+           * every picture looked like a place where something was happening.
+           * It is not. Gravity here goes as the product of two waves meeting,
+           * so it falls away faster than either of them does — and if the
+           * waves are drawn brighter than they are, the eye is being told the
+           * opposite of the truth about where anything can still act.
+           *
+           * Straight through, then. What is visible is what is there, and
+           * where the picture goes dark is where the two have nothing left to
+           * do to each other.
+           */
+          const k = Math.abs(v);
+          const i = (y * cols + x) * 4;
+
+          /**
+           * And a little noise added before it is rounded to a byte.
+           *
+           * The field is smooth and the colours it maps to are eight bits, so
+           * a gradient that takes two hundred pixels to go from one shade to
+           * the next has a hard edge every two hundred pixels — a set of
+           * contour lines nothing asked for, which read as the picture being
+           * coarse when what is coarse is only the counting. Half a level of
+           * dither, from a fixed pattern rather than from a random number so
+           * that a still frame is stable, turns each of those edges into a
+           * scatter that averages to the right value and has no edge in it.
+           */
+          const d = DITHER[(y & 3) * 4 + (x & 3)];
+
+          // The ground, plus however far this place leans towards one charge
+          // or the other. At nought it is the ground exactly, which is why a
+          // place where the two cancel needs nothing drawn on it to read as
+          // empty — and why the tints are the same three numbers the lattice
+          // strokes its charges with. See `paint.ts`.
+          const tint = v > 0 ? AMBER : CYAN;
+
+          px[i] = BACKGROUND[0] + lift(tint, 0) * k + d;
+          px[i + 1] = BACKGROUND[1] + lift(tint, 1) * k + d;
+          px[i + 2] = BACKGROUND[2] + lift(tint, 2) * k + d;
+          px[i + 3] = 255;
+        }
+      }
+
+      bufCtx.putImageData(img, 0, 0);
+
+      ground(ctx, w, h);
+
+      ctx.imageSmoothingEnabled = true;
+      ctx.drawImage(buf, 0, 0, w, h);
+
+      // The sources, drawn exactly as the lattice draws its own.
+      for (const s of live)
+        source(ctx, w / 2 + s.at[0] * scale, h / 2 + s.at[1] * scale,
+          { halo: 14, dot: 2.2 });
+    }
+
+    /**
+     * And everything is carried by the flow of the space it is in.
+     *
+     * Three things, in this order, and the order says what the model claims.
+     * A source goes on going the way it was going, because nothing here
+     * accelerates anything. The space it is in is carried by `flowAt`,
+     * wherever annihilation is shortening it. And the source's own direction
+     * is turned by how steeply that flow falls away — not by being pushed,
+     * but because a straight line through ground that is running downhill
+     * across it does not stay straight.
+     *
+     * The turning is `fallAt`, taken across the direction of travel only, so
+     * that a change of direction is all it can ever be. Nothing here changes
+     * speed.
+     *
+     * They stop when they are adjacent, which is not a fudge to keep them
+     * apart: a source is not space, so there is nothing left between them to
+     * annihilate and nothing either could move through if there were.
+     */
+    const TOUCH = 1;                              // as close as adjacent gets
+
+    function pull(dt: number) {
+      const reach = span * 0.6;
+
+      // Where space is going, worked out once for the whole picture. After
+      // this nothing asks about sources again — only about places.
+      survey(live, t, reach, span);
+
+      // What the annihilation does to the space, carried forward and let
+      // travel. See `warpStep` — this is where gravity now lives.
+      warpStep(field, dt);
+
+      /**
+       * And what each source is carried by is the SPEED of the space it is
+       * standing in, not the annihilation happening elsewhere at this moment.
+       *
+       * Which is the whole difference. A contraction over there reaches here
+       * when the wave carrying it does, and having arrived it leaves this
+       * place displaced for good — so a source goes on being where the space
+       * put it after the eating has stopped, and feels nothing at all from an
+       * annihilation whose news has not yet arrived.
+       */
+      const carry = live.map(s => {
+        warpAt(field, field.vx, field.vy, s.at[0], s.at[1]);
+
+        let cx = WARP[0], cy = WARP[1];
+
+        // And what the others have laid down behind them. Never its own —
+        // see `wakeAt`.
+        for (const o of live) {
+          if (o === s) continue;
+
+          wakeAt(o, s.at[0], s.at[1], t);
+
+          cx += WAKE[0]; cy += WAKE[1];
+        }
+
+        return [cx, cy] as [number, number];
+      });
+
+      const turned = live.map(s => {
+        /**
+         * Turned by the slope of the ground, and only across the way it is
+         * going.
+         *
+         * The part of that slope pointing along the direction of travel is
+         * dropped before anything is added, which is what keeps this a
+         * turning and not a pull. Renormalising afterwards would have hidden
+         * the difference and did: what used to be here took the flow's change
+         * along the line of travel, which for a river running straight in is
+         * a change of length and no change of angle at all, and then handed
+         * that length to the renormalisation to be thrown away. Measured, it
+         * delivered a hundredth of what an orbit needs and most of that
+         * parallel — so a pair sent past each other flew past each other, the
+         * line between them swung forty degrees the way any two things
+         * passing would, and stopped. Which is exactly the complaint: no
+         * orbit, just a flyby with the arithmetic of one.
+         *
+         * Across the direction of travel there is nothing to throw away.
+         * `fallAt` is the free-fall acceleration and a component of it
+         * perpendicular to a velocity can only rotate that velocity — so the
+         * speed is left exactly alone by construction, and the
+         * renormalisation below is now just tidying the second-order error of
+         * a finite step rather than doing the work.
+         */
+        const speed = Math.hypot(s.vel[0], s.vel[1]);
+        if (speed < 1e-9) return s.vel;
+
+        fallAt(field, s.at[0], s.at[1]);
+
+        const hx = s.vel[0] / speed, hy = s.vel[1] / speed;
+        const along = FALL[0] * hx + FALL[1] * hy;
+
+        const vx = s.vel[0] + (FALL[0] - along * hx) * dt;
+        const vy = s.vel[1] + (FALL[1] - along * hy) * dt;
+
+        const now = Math.hypot(vx, vy);
+        if (now < 1e-9) return s.vel;
+
+        return [vx * speed / now, vy * speed / now] as [number, number];
+      });
+
+      for (let i = 0; i < live.length; i++) {
+        const s = live[i];
+
+        s.vel = turned[i];
+
+        s.at[0] += (s.vel[0] + carry[i][0]) * dt;
+        s.at[1] += (s.vel[1] + carry[i][1]) * dt;
+      }
+
+      // Not through one another: a source is not space.
+      for (let i = 0; i < live.length; i++) {
+        for (let j = i + 1; j < live.length; j++) {
+          const a = live[i], b = live[j];
+
+          const dx = b.at[0] - a.at[0], dy = b.at[1] - a.at[1];
+          const gap = Math.hypot(dx, dy);
+          if (gap >= TOUCH || gap < 1e-9) continue;
+
+          const back = (TOUCH - gap) / 2;
+          const ux = dx / gap, uy = dy / gap;
+
+          a.at[0] -= ux * back; a.at[1] -= uy * back;
+          b.at[0] += ux * back; b.at[1] += uy * back;
+        }
+      }
+
+      /**
+       * And the trail is NOT carried with it, which is the whole of what
+       * makes any of this local.
+       *
+       * It was, and the argument for it sounded right: a ring is centred
+       * where its source was when it left, that place is in the space too,
+       * and if the space is going then so is everywhere in it. What that
+       * argument misses is that the trail is not a set of places. It is a
+       * RECORD of where something was at a moment, and a record that gets
+       * amended is not a record of anything.
+       *
+       * Amended every frame, every position in it drifts a little further
+       * from what was actually the case — so `was` gives a different answer
+       * today than it gave yesterday for the same instant, and every wave in
+       * the air, however old, quietly re-centres itself on the answer. Rings
+       * laid down a hundred ticks ago get up and move because their source
+       * has since been pulled somewhere. Nothing that has already happened
+       * may depend on anything that happened after it, and this was the last
+       * place in the model where it did.
+       */
+    }
+
+    return {
+      start: reset,
+
+      frame: (surface, elapsed) => {
+        // Seconds to ticks, which is the only clock this has. There is no
+        // state carried between frames beyond it, so `t` may be any real
+        // number and the waves travel smoothly rather than a cell at a time.
+        const dt = elapsed * rate;
+
+        t += dt;
+
+        if (t >= cycle) reset();
+        else pull(dt);
+
+        remember();
+
+        draw(surface);
+      },
+
+      // The buffer this holds on to, over and above the canvas the view hands
+      // back for it. There is no other state in it besides a clock.
+      stop: () => {
+        buf.width = 0;
+        buf.height = 0;
+        img = null;
+      },
+    };
+  }}
+/>;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
new file mode 100644
index 0000000..bebb861
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
@@ -0,0 +1,3237 @@
+import {
+  axes, CYCLE, directions, latticeStep, LATTICE_STEP, opposite, Polarity,
+  randomPolarity, shuffle, Source, speedOf, TURN, turnRing, Vec, World,
+} from "./lattice";
+
+// Every coordinate of a `size`-wide box in `dims` dimensions, from the origin
+// out. What a seed does with them is its own business; enumerating them is
+// the same job every time.
+const box = (dims: number, size: number): number[][] => {
+  const out: number[][] = [];
+
+  (function build(prefix: number[]) {
+    if (prefix.length === dims) { out.push(prefix); return; }
+
+    for (let i = 0; i < size; i++) build([...prefix, i]);
+  })([]);
+
+  return out;
+};
+
+// How close the closest two of them are, or nothing at all if there are not
+// two. Several things want to be measured against the encounter rather than
+// against the world it happens in.
+const spacing = (sources: Source[]): number | undefined => {
+  let nearest = Infinity;
+
+  for (let i = 0; i < sources.length; i++)
+    for (let j = i + 1; j < sources.length; j++)
+      nearest = Math.min(nearest, Math.hypot(
+        ...sources[i].at.map((v, k) => (sources[j].at[k] ?? 0) - v),
+      ));
+
+  return isFinite(nearest) ? nearest : undefined;
+};
+
+/**
+ * Charges for the two halves of a pair of blocks: everything left of the
+ * middle one polarity, everything right of it the other.
+ */
+export const bySide = (left: Polarity, right: Polarity) =>
+  (coord: number[]) => coord[0] < 0 ? left : right;
+
+/**
+ * A charge drawn per point rather than per block.
+ *
+ * `lay` asks per boundary, but a point is one thing: the draw is remembered
+ * by coordinate so every boundary of a point carries the same charge, and it
+ * is the point that is positive or negative.
+ */
+export const perPoint = (draw: () => Polarity = randomPolarity) => {
+  const drawn = new Map<string, Polarity>();
+
+  return (coord: number[]) => {
+    const key = coord.join(",");
+
+    if (!drawn.has(key)) drawn.set(key, draw());
+
+    return drawn.get(key)!;
+  };
+};
+
+/**
+ * How much harder a source is to move than the charges it emits: a multiple
+ * of the step's own length, paid out of the same one-per-tick everything else
+ * is paid (see the movement half of `tick`). It is mass, arrived at from the
+ * only direction this model offers — the cost of going somewhere.
+ *
+ * A source at mass m covers 1/m cells a tick. Two conditions decide whether a
+ * moving pair can interact at all, and both are arithmetic rather than
+ * judgement:
+ *
+ *  - One step a tick is this model's top speed — a ray moves at most once per
+ *    tick, so nothing goes faster and the field cannot be sped up to keep
+ *    pace. Two sources heading opposite ways separate at 2/m, and their light
+ *    closes at 1, so anything each emits can only ever reach the other while
+ *    2/m < 1. At m = 1 they are outrunning their own field from the first
+ *    tick; at m = 2 the light exactly keeps pace and never gains. It takes
+ *    m > 2 before a pulse can cross from one to the other at all.
+ *
+ *  - And a source can only emit onto a point it is connected to. Once it has
+ *    travelled out of the seeded ball it is in territory `grow` laid down one
+ *    node at a time as it went, with nothing on the far side of its other
+ *    twenty-five directions, so it stops radiating in all but the one it is
+ *    heading in. Over a 60-tick run it moves 60/m, and starting 8 out along x
+ *    it stays inside the absorbing edge at 11 while √(8² + (60/m)²) ≤ 11 —
+ *    which wants m ≥ 8.
+ *
+ * Eight is what those two conditions ask for together. The value below is the
+ * one the runs in this article are actually set to, and it is smaller: these
+ * are shorter runs at closer quarters than that derivation assumes, and a
+ * source at eight barely moves within one of them. A source given a `drift`
+ * overrides it outright — see `massFor` — since a stated speed is a stated
+ * mass, and this is only what a source that was never told how fast to go
+ * falls back on.
+ */
+export const MAGNET_MASS = 3;
+
+// What a step costs a source that was told how fast to go. A step is one
+// cell, a tick pays one, so covering `speed` cells a tick costs 1/speed —
+// and nothing goes quicker than a cell a tick, which is where the floor
+// comes from.
+export const massFor = (speed?: number) =>
+  speed && speed > 0 ? Math.max(1 / speed, 1) : MAGNET_MASS;
+
+// Two rays meeting head-on, over the connection whose mutual boundaries are
+// `a` and `b`. Opposite charges cancel; like ones turn around. Movement isn't
+// here because it isn't an interaction: it is what a ray does when nothing is
+// coming the other way.
+type Interaction = {
+  kind: 'annihilate' | 'turn';
+  r: Ray; a: Boundary;
+  r2: Ray; b: Boundary;
+};
+
+/**
+ * One point of a line of charges: its polarity, and which way along the line
+ * it goes. With more than two there is no "towards each other" to name a
+ * direction by, so the line itself is what they are named against.
+ */
+export type LineSide = {
+  polarity: Polarity;
+  moving: 'left' | 'right';
+};
+
+export class Graph {
+  nodes: node[] = []
+
+  gridPos = new Map<node, number[]>();
+
+  // gridPos read the other way round, so that "what is at this coordinate"
+  // isn't a scan over the whole universe. Positions are real-valued and two
+  // points can briefly share one, so this is last-writer-wins: it is an
+  // index, and `gridPos` above is the truth it indexes.
+  private at = new Map<string, node>();
+
+  private static posKey(pos: number[]): string {
+    return pos.map(v => Math.round(v * 1e6)).join(",");
+  }
+
+  // Every write to a position goes through these, so the index can never
+  // fall behind the thing it indexes.
+  private setPos(nd: node, pos: number[]) {
+    this.unindex(nd);
+    this.gridPos.set(nd, pos);
+    this.at.set(Graph.posKey(pos), nd);
+  }
+
+  private delPos(nd: node) {
+    this.unindex(nd);
+    this.gridPos.delete(nd);
+  }
+
+  private unindex(nd: node) {
+    const was = this.gridPos.get(nd);
+    if (!was) return;
+
+    const key = Graph.posKey(was);
+    if (this.at.get(key) === nd) this.at.delete(key);
+  }
+
+  // Lattice dimensionality and the seed's initial radius (used only by the
+  // cube→sphere layout morph now).
+  dims = 3;
+  ringRadius = 0;
+
+  /**
+   * What the camera is for, if it isn't for everything: a radius in grid
+   * coordinates, and everything inside it is the subject.
+   *
+   * A universe that grows has no fixed size to frame, and framing whatever is
+   * currently furthest out means the picture zooms out to chase whichever
+   * charge has got the furthest — so the thing being watched shrinks away in
+   * the middle while nothing much happens at the edges.
+   *
+   * It has to be a region rather than a list of the points that were there at
+   * the start, because those points do not stay. Moving is a swap with space:
+   * every charge that goes anywhere eats a point of the original ball and
+   * leaves a new one behind it. Name the seed's points and within a few ticks
+   * you are framing a handful of survivors; name the seed's extent and you
+   * are framing the same place throughout, whatever is currently in it.
+   */
+  focus?: number;
+
+  inFocus(nd: node): boolean {
+    if (this.focus === undefined) return true;
+
+    const pos = this.gridPos.get(nd);
+
+    return !!pos && Math.hypot(...pos) <= this.focus;
+  }
+
+  /**
+   * How often a ray takes one of the ways its direction is made of, instead
+   * of the direction itself. Nought is movement strictly conserved, which is
+   * what everything before this ran on.
+   *
+   * A direction like (1,1,1) is not one thing: it is three axial steps taken
+   * at once, and a point that can go that way can also go any of the three
+   * separately, or any of them backwards. So at each move a ray either
+   * carries on along the whole diagonal or takes one of the pieces it is
+   * composed of — chosen at random, with the pieces' opposites in the draw
+   * too, so it can give ground on an axis as well as gain it.
+   *
+   * What that buys is the thing a field made of travelling charges needs and
+   * did not have: a path that can curve. Movement conserved exactly means a
+   * ray leaves its source in one of twenty-six directions and is committed to
+   * it forever, so two streams either coincide or never touch, and no line
+   * can go looking for anything. Wandering makes a trajectory a random walk
+   * with a drift down its original direction, which spreads it over the space
+   * between — and since annihilation removes exactly those that find their
+   * opposite, what survives to be seen is selected by what met. The lines
+   * find each other by searching and being culled where they succeed, rather
+   * than by being aimed.
+   *
+   * The drift is what keeps it a field rather than a fog: the whole diagonal
+   * is one option among its pieces, and the pieces' opposites cancel in the
+   * average, so the mean step still points the way it set out.
+   */
+  wander = 0;
+
+  /**
+   * No holes, ever.
+   *
+   * A direction with nothing on the far side of it is a way out of the
+   * lattice. In a line that is exactly right — the end of a line is where you
+   * can walk off it, and growing the structure by moving into nothing is how
+   * these universes expand. In a closed lattice it is a tear, and every rule
+   * that removes a point has been quietly making them: hundreds a tick, tens
+   * of thousands over a run, all of them in the region where the two fields
+   * are trying to reach each other.
+   *
+   * Sealed, a direction is a direction TO something. Take away what it
+   * pointed at and it is not a direction any more — it is dropped, and
+   * whatever else the vanished point joined stays joined (`closeUp`). Nothing
+   * is ever left facing nowhere, so nothing can leak out through a face that
+   * was never there, and the space contracts instead of coming apart.
+   *
+   * Off by default: the line and grid seeds are open worlds with real edges,
+   * and they need to be able to grow.
+   */
+  sealed = false;
+
+  // A direction that is not one any more.
+  private drop(bd: Boundary) {
+    bd.target = undefined;
+    bd.outward = undefined;
+    bd.at.boundaries = bd.at.boundaries.filter(x => x !== bd);
+  }
+
+  // Left pointing at nothing — dropped in a sealed world, kept as a bare way
+  // out in an open one.
+  private loose(bd: Boundary) {
+    if (this.sealed) { this.drop(bd); return; }
+
+    const d = this.bare(bd);
+    bd.target = undefined;
+    bd.outward = d;
+  }
+
+  // Whether the drawn positions are the coordinates, or the structure.
+  //
+  // Off, a point is drawn where its coordinate says it is, and space that has
+  // been annihilated out of the world leaves a hole in the picture. On, the
+  // picture is relaxed against the connections that actually exist, so a
+  // connection that has closed up over destroyed space pulls its two ends
+  // together — which is the whole of what attraction is here.
+  relax = false;
+
+  // Monotonic tick counter.
+  _tickId = 0;
+
+  /**
+   * What just happened, and where.
+   *
+   * Every interaction in this model is over in the tick it occurs in: two
+   * charges cancel and the points they were are gone, or two turn round and
+   * are indistinguishable a moment later from two that were always going that
+   * way. Drawn only as the state they leave behind, the events themselves are
+   * invisible — the picture shows a field that is quietly a bit smaller than
+   * it was, and never shows the cancelling that made it so.
+   *
+   * So each one is noted as it happens, at the place it happened, and kept
+   * for a tick or two afterwards. Nothing in the dynamics reads this; it is
+   * the record, not the thing.
+   */
+  events: { at: Vec, kind: 'annihilate' | 'turn', tick: number }[] = [];
+
+  /**
+   * A count of what the last tick consisted of.
+   *
+   * A universe of a dozen points can be read off the picture. One of several
+   * thousand cannot: "nothing seems to be happening any more" has half a
+   * dozen quite different causes — the sources have stopped emitting, or
+   * everything has jammed and nothing can move, or things are moving fine and
+   * simply never meeting — and they look identical from outside. These are
+   * the numbers that tell them apart.
+   */
+  stats = { emitted: 0, moved: 0, blocked: 0, annihilated: 0, turned: 0, path: 0, holes: 0 };
+
+  // How far apart the two sources have been, tick by tick.
+  history: number[] = [];
+
+  // And the way between them as it currently runs.
+  route: node[] = [];
+
+  /**
+   * How far it is from one source to the other — in steps through the
+   * structure, not in coordinates.
+   *
+   * This is the measurement the whole thing is for, and it is the only one
+   * that answers the question without argument. Coordinates say nothing: the
+   * sources sit at the coordinates they were seeded at and will do forever,
+   * whether or not anything has happened between them. The picture is
+   * suggestive but it is a solve, and a solve can be stiff, or slow, or
+   * simply drawn small.
+   *
+   * The number of points you have to pass through to get from one to the
+   * other is neither. It starts at whatever the seed made it, and it goes
+   * down when and only when the space between them is annihilated. If two
+   * things gravitate in this model, THIS is what it means, and if it doesn't
+   * fall then nothing else on screen is attraction however much it looks
+   * like it.
+   */
+  shortestPath(): node[] {
+    const sources: node[] = [];
+    for (const nd of this.nodes) if (nd.some(r => r.magnet)) sources.push(nd);
+    if (sources.length < 2) return [];
+
+    const [from, to] = sources;
+    const cameFrom = new Map<node, node>([[from, from]]);
+
+    let frontier = [from];
+
+    while (frontier.length) {
+      const next: node[] = [];
+
+      for (const nd of frontier) {
+        for (const ray of nd) {
+          for (const bd of ray.boundaries) {
+            const other = bd.target?.at.node;
+            if (!other || cameFrom.has(other)) continue;
+
+            cameFrom.set(other, nd);
+
+            if (other === to) {
+              const route = [other];
+              while (route[0] !== from) route.unshift(cameFrom.get(route[0])!);
+
+              return route;
+            }
+
+            next.push(other);
+          }
+        }
+      }
+
+      frontier = next;
+    }
+
+    return []; // no way from one to the other at all
+  }
+
+  private mark(kind: 'annihilate' | 'turn', ...rays: Ray[]) {
+    const at: Vec[] = [];
+
+    for (const ray of rays) {
+      const p = this.relaxed?.at.get(ray.node) ?? this.layoutCache?.get(ray.node);
+      if (p) at.push(p);
+    }
+
+    if (!at.length) return;
+
+    const centre = new Array(at[0].length).fill(0);
+    for (const p of at)
+      for (let k = 0; k < centre.length; k++) centre[k] += p[k] / at.length;
+
+    this.events.push({ at: centre, kind, tick: this._tickId });
+  }
+
+  // Something the seed has arranged for the world to go on doing, run at the
+  // start of every tick before the rules get their say. Nothing in the rules
+  // needs one — it is how a source that is never itself an event gets to be
+  // one, which is the only way to ask what a thing that keeps emitting does
+  // to the space around it.
+  onTick?: (graph: Graph) => void;
+
+  // How far and which way a boundary reaches, in grid units. A bare direction
+  // says so itself; a connection is the offset from the point it is on to the
+  // point on the other side, which after an annihilation can be several steps
+  // rather than one.
+  private offset(bd: Boundary): number[] | undefined {
+    if (bd.outward) return bd.outward;
+
+    const from = this.gridPos.get(bd.at.node);
+    const to = bd.target && this.gridPos.get(bd.target.at.node);
+    if (!from || !to) return undefined;
+
+    return to.map((v, i) => v - from[i]);
+  }
+
+  // Which way a boundary points, as a unit vector — for comparing directions
+  // against each other, where only the way they face matters.
+  private direction(bd: Boundary): number[] | undefined {
+    const offset = this.offset(bd);
+    if (!offset) return undefined;
+
+    const length = Math.hypot(...offset);
+
+    return length ? offset.map(v => v / length) : undefined;
+  }
+
+  /**
+   * The same direction as one step of the lattice — components in {-1, 0, 1}.
+   *
+   * This is what goes into a position (a new point is put down one step over,
+   * not a unit distance over, which off the axes is not the same thing) and
+   * what a boundary with nothing on the far side is left holding. A unit
+   * vector would be neither: in a 360° discrete space the corner directions
+   * have length √3, and normalising them puts new points at coordinates the
+   * lattice doesn't have.
+   */
+  private bare(bd: Boundary): number[] | undefined {
+    const offset = this.offset(bd);
+
+    return offset && latticeStep(offset);
+  }
+
+  // The boundary of `ray` pointing most nearly along `dir` (`sign` of -1 for
+  // most nearly opposite). Movement is conserved rather than reselected, so
+  // whenever a ray has to change which boundary it moves along, it does the
+  // thing closest to carrying straight on — or, turning around, closest to
+  // coming straight back.
+  private along(ray: Ray, dir: number[] | undefined, sign: 1 | -1, exclude?: Boundary): Boundary | undefined {
+    const options = ray.boundaries.filter(b => b !== exclude);
+    if (!options.length) return undefined;
+    if (!dir) return options[0];
+
+    let best: Boundary | undefined;
+    let bestDot = -Infinity;
+
+    for (const option of options) {
+      const d = this.direction(option);
+      if (!d) continue;
+
+      const dot = sign * d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
+      if (dot > bestDot) { bestDot = dot; best = option; }
+    }
+
+    return best ?? options[0];
+  }
+
+  /**
+   * Which way is behind us: the boundary pointing most nearly opposite to the
+   * one we are moving along. Only a genuinely backward direction counts — a
+   * perpendicular one is beside us, not behind us — so a ray with nothing
+   * behind it gets `undefined` and the space it sheds into has to be made.
+   */
+  private behind(ray: Ray, dir: number[] | undefined, exclude: Boundary): Boundary | undefined {
+    if (!dir) return undefined;
+
+    let best: Boundary | undefined;
+    let bestDot = 0.1; // has to actually point back, not sideways
+
+    for (const option of ray.boundaries) {
+      if (option === exclude) continue;
+
+      const d = this.direction(option);
+      if (!d) continue;
+
+      const dot = -d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
+      if (dot > bestDot) { bestDot = dot; best = option; }
+    }
+
+    return best;
+  }
+
+  // The point sitting at a grid position, if there is one. Positions are
+  // real-valued (space instantiated between two points lands at their
+  // midpoint), so this is a tolerance match rather than a key lookup.
+  private nodeAt(pos: number[]): node | undefined {
+    const found = this.at.get(Graph.posKey(pos));
+    if (!found) return undefined;
+
+    const p = this.gridPos.get(found);
+
+    return p && p.length === pos.length && p.every((v, i) => Math.abs(v - pos[i]) < 1e-6)
+      ? found
+      : undefined;
+  }
+
+  /**
+   * The directions of a point that lie ACROSS the way we are going.
+   *
+   * The axis we are travelling on never changes hands: it is the thing being
+   * travelled, and taking it would tear the line we are moving along in two.
+   * Everything else is what a point IS as opposed to where it is, and it is
+   * exactly what gets handed over as something moves through.
+   */
+  private transverse(rays: Ray[], dir: number[] | undefined, exclude?: Boundary): Boundary[] {
+    if (!dir) return [];
+
+    const out: Boundary[] = [];
+
+    for (const ray of rays) {
+      for (const bd of ray.boundaries) {
+        if (bd === exclude) continue;
+
+        const d = this.direction(bd);
+        if (!d) continue;
+
+        const along = Math.abs(d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0));
+        if (along < 0.9) out.push(bd);
+      }
+    }
+
+    return out;
+  }
+
+  // The same directions, held by somewhere else now.
+  private hand(taken: Boundary[], onto: Ray) {
+    for (const bd of taken) {
+      bd.at.boundaries = bd.at.boundaries.filter(x => x !== bd);
+      bd.at = onto;
+      onto.boundaries.push(bd);
+    }
+  }
+
+  /**
+   * Two opposite charges meeting head-on: they cancel, and the space they
+   * were goes with them.
+   *
+   * Not by being destroyed — space is never destroyed here, it is handed
+   * backwards. Everything each of them held across the line they met on goes
+   * to the point behind it, the two of them are spliced out of that line, and
+   * what was behind them closes up directly onto what was behind the other.
+   * Nothing comes apart: there is simply less space than there was, and what
+   * that space was carrying is still carried.
+   *
+   * With nothing behind either of them there is nowhere backwards to hand
+   * anything to, so the two collapse onto each other instead — one neutral
+   * point left holding everything both of them held. A row of charges
+   * annihilating pair by pair therefore ends as exactly that one point.
+   */
+  private annihilate(r: Ray, a: Boundary, r2: Ray, b: Boundary, removed: Set<node>) {
+    const dirA = this.direction(a), dirB = this.direction(b);
+
+    const backA = this.behind(r, dirA, a), backB = this.behind(r2, dirB, b);
+
+    // What was behind each — but never a source. A source is not somewhere
+    // space can be put down; it is the thing space is coming out of. Handing
+    // it what a dying charge was carrying leaves it holding connections to
+    // half the world, which it then radiates down, and every one of those
+    // comes back to leave more. Treated as nothing behind, the structure goes
+    // to the other side, or the two collapse onto each other as they do when
+    // there is nowhere behind either.
+    const behindA = backA?.target?.at;
+    const behindB = backB?.target?.at;
+
+    const homeA = behindA?.magnet ? undefined : behindA;
+    const homeB = behindB?.magnet ? undefined : behindB;
+
+    /**
+     * The connection between the two of them, severed first of all.
+     *
+     * It is the one thing this event actually destroys, and it has to go
+     * before anything else is decided — both of its ends are on points that
+     * are about to stop existing, so any rule that tries to preserve it later
+     * preserves a connection to a corpse. Done here, every branch below is
+     * dealing only with connections that genuinely survive.
+     *
+     * Meeting head-on that is `a` and `b`. Arriving at the same place from
+     * different directions there is no such connection at all — `a` leads to
+     * the point they were both making for, which is somebody else and stays.
+     */
+    for (const bd of [a, b]) {
+      const partner = bd.target;
+      if (!partner || (partner.at !== r && partner.at !== r2)) continue;
+
+      partner.target = undefined;
+      bd.target = undefined;
+    }
+
+    if (homeA || homeB) {
+      /**
+       * Everything each of them held goes to the point behind it.
+       *
+       * Not just what it held across its line of travel — everything, bar the
+       * two that this event is actually about: the connection between the two
+       * of them, which is what they were approaching each other along and is
+       * the one thing here that genuinely ceases to exist, and the connection
+       * to the point behind, which is where all of it is going and so becomes
+       * internal to that.
+       *
+       * Handing only the transverse part is what leaves the rest to be
+       * guessed at, and every version of that guess loses something: a
+       * direction with no readable heading gets dropped, two that lead to the
+       * same neighbour refuse to pair, and the point on the other end of them
+       * quietly loses a connection it never gave up. Measured, that is
+       * hundreds of points falling below three connections and some to none
+       * at all, cut out of the world by an event two cells away.
+       *
+       * Handed wholesale, nothing has to be decided and nothing can be lost.
+       * The point stops existing; what it was holding is held by the place
+       * behind it; and every point that was connected to it is still
+       * connected to exactly as much as it was.
+       */
+      // Everything either of them is still joined to, bar the way back —
+      // which is where all of it is going, and so becomes internal to that.
+      // The approach between them is already severed, so it cannot be here.
+      const inherit = (dying: Ray, back: Boundary | undefined, onto: Ray) =>
+        this.hand(dying.boundaries.filter(bd => bd !== back && bd.target), onto);
+
+      inherit(r, backA, homeA ?? homeB!);
+      inherit(r2, backB, homeB ?? homeA!);
+
+      // The line closes up: what was behind one is now directly onto what was
+      // behind the other.
+      const pa = backA?.target, pb = backB?.target;
+
+      if (pa && pb) {
+        pa.target = pb;
+        pb.target = pa;
+      } else for (const p of [pa, pb]) {
+        if (!p) continue;
+
+        // Nothing on the far side to close onto, so the direction is all that
+        // is left of what used to be there — and in a sealed world, not even
+        // that.
+        this.loose(p);
+      }
+
+      this.discard(r, homeA ?? homeB!, removed);
+      this.discard(r2, homeB ?? homeA!, removed);
+
+      return;
+    }
+
+    // Nowhere behind either of them: everything the two were carrying ends up
+    // on one point, which is all that is left of both — and here that one
+    // point is the place behind, there being no other.
+    this.hand(r2.boundaries.filter(bd => bd.target), r);
+
+    r.boundaries = r.boundaries.filter(x => x !== a);
+    this.discard(r2, r, removed);
+
+    r.moving = undefined;
+    for (const bd of r.boundaries) bd.polarity = Polarity.Neutral;
+  }
+
+  /**
+   * A point that is no longer anywhere.
+   *
+   * Whatever it was carrying has already gone wherever it was going; this is
+   * only the removal. Anything still pointing at it is left holding the bare
+   * direction — the way is still that way, there is just nothing there — and
+   * anything still sitting on it goes wherever its structure went.
+   */
+  /**
+   * A point stops being anywhere, and every way through it closes up.
+   *
+   * Whatever was on one side of it and whatever was on the other are now
+   * directly connected — the connection still exists, it is simply shorter
+   * now by the point that is no longer in it. Done for all thirteen axes
+   * through the point rather than only the one something happened to be
+   * travelling along, because a point in a lattice is in the middle of
+   * thirteen lines at once and every one of them has to survive losing it.
+   *
+   * Only a direction with nothing coming the other way is left bare, and that
+   * is a genuine edge of the world rather than a tear in it.
+   */
+  private closeUp(boundaries: Boundary[], of: Ray) {
+    const facing = new Map<string, Boundary>();
+    const waiting: Boundary[] = [];
+
+    const join = (x: Boundary, y: Boundary) => {
+      x.target = y;
+      x.outward = undefined;
+      y.target = x;
+      y.outward = undefined;
+    };
+
+    for (const bd of boundaries) {
+      const partner = bd.target;
+
+      // Only if it is still pointing back at us: a connection that has
+      // already been closed up onto something else is not ours to break.
+      if (!partner || partner.target !== bd) continue;
+
+      const step = this.bare(bd);
+      if (!step) { waiting.push(partner); continue; }
+
+      const key = step.join(",");
+      const opposite = step.map(v => -v).join(",");
+      const back = facing.get(opposite);
+
+      // Straight through: the two that were either side of us are now either
+      // side of nothing, so they are next to each other.
+      if (back && back !== partner && back.at.node !== partner.at.node) {
+        join(back, partner);
+        facing.delete(opposite);
+
+        continue;
+      }
+
+      if (facing.has(key)) waiting.push(partner);
+      else facing.set(key, partner);
+    }
+
+    /**
+     * And whatever had nothing coming the other way is joined up anyway.
+     *
+     * Every one of these was a neighbour of the point that has gone, so they
+     * are all within a step of where it was and so within two of each other:
+     * joining them is contraction, the same as the straight-through case, not
+     * a shortcut between places that were never near. What it is not is a
+     * hole. A direction left pointing at nothing is a way out of the lattice
+     * that was not there before, and thousands of them are what stop a wave
+     * ever crossing the middle — which is measurable, and was the whole of
+     * why two magnets stopped interacting after a dozen ticks.
+     *
+     * A point removed from a line leaves its two ends facing each other. A
+     * point removed from a lattice leaves twenty-six neighbours facing each
+     * other, and all of them staying connected is what "the space contracts"
+     * has to mean when there is more than one way through.
+     */
+    const left = [...facing.values(), ...waiting]
+      .filter(p => p.target?.at === of);
+
+    for (let i = 0; i + 1 < left.length; i += 2)
+      if (left[i].at.node !== left[i + 1].at.node) join(left[i], left[i + 1]);
+
+    // An odd one out: joined to whoever it was just beside, rather than left
+    // facing nowhere.
+    if (left.length % 2) {
+      const last = left[left.length - 1];
+      const mate = left.find(p => p !== last && p.at.node !== last.at.node);
+
+      if (mate) {
+        const spare = new Boundary(mate.at);
+        spare.polarity = Polarity.Neutral;
+        mate.at.boundaries.push(spare);
+        join(last, spare);
+      } else this.loose(last);
+    }
+  }
+
+  private discard(ray: Ray, onto: Ray, removed: Set<node>) {
+    const nd = ray.node;
+
+    /**
+     * Everything that was connected to us is now connected to where our
+     * structure went.
+     *
+     * This used to leave them holding a bare direction — the way is still
+     * that way, there is just nothing there — which is right for a line and
+     * catastrophic for a lattice. On a line a point has two neighbours, the
+     * two ends get spliced onto each other by the caller, and nothing is left
+     * dangling. Here a point has twenty-six, one of them gets the splice, and
+     * the other twenty-five are left pointing at nowhere.
+     *
+     * That is a hole, and every annihilation punches two dozen of them. They
+     * accumulate exactly where the action is, the lattice between the sources
+     * comes apart into fragments joined by fewer and fewer connections, and
+     * the way from one source to the other has to start going round. Which
+     * is why the distance between them falls for a while and then stops
+     * falling: it is not that they have finished coming together, it is that
+     * the space they were coming together through has been shredded.
+     *
+     * Following the structure instead keeps the lattice whole. The point is
+     * gone and its structure is at `onto`, so its neighbours are neighbours
+     * of `onto` now — which is the same rule the annihilation itself runs on,
+     * applied to every direction rather than only to the one behind.
+     */
+    /**
+     * The space closes up across itself, direction by direction.
+     *
+     * Two earlier versions of this were wrong in opposite ways. Leaving every
+     * neighbour holding a bare direction tears two dozen holes per removal.
+     * Reconnecting them all to wherever the structure went does keep the
+     * lattice joined — but `onto` can be anywhere, so every removal welds a
+     * couple of dozen points to one distant point, and after a few thousand
+     * of them the lattice is a mass of long-range shortcuts. That is
+     * measurable rather than theoretical: the shortest way from one source to
+     * the other ends up running (−8,0,0) → (−9,0,0) → (−1,9,9) → (7,0,0) →
+     * (8,0,0), hopping through a point in the far corner of the world, and it
+     * stops changing at all. Both sources still have their whole
+     * neighbourhood; what has gone is any relation between being connected
+     * and being near, and with it any sense in which the two are approaching.
+     *
+     * What a point actually is, to its neighbours, is the thing between them:
+     * take it away and the two on opposite sides of it are what close up.
+     * That is the same rule the annihilation uses along its own line, applied
+     * to every direction through the point rather than only that one — so the
+     * ways through survive, and none of them reaches anywhere the two ends
+     * were not already either side of.
+     */
+    this.closeUp(ray.boundaries, ray);
+
+    ray.boundaries = [];
+
+    for (const other of [...nd]) {
+      if (other === ray) continue;
+
+      other.node = onto.node;
+      onto.node.push(other);
+    }
+
+    nd.length = 0;
+
+    this.delPos(nd);
+    // Taken out of the world at the end of the tick rather than here: `nodes`
+    // is scanned by everything, and cutting one point out of it costs a pass
+    // over all of them, which with a few thousand points and a few thousand
+    // of them moving is the whole frame. `removed` is what everything in the
+    // tick actually consults, so the array can be caught up with once.
+    removed.add(nd);
+  }
+
+  /**
+   * Two like charges meeting head-on: neither cancels the other and neither
+   * can move through the other, so each simply turns itself around.
+   *
+   * Movement is conserved rather than reselected — it comes back the way it
+   * came instead of setting off somewhere new — and if there is no way back
+   * yet then the way back is something it has to have, so it gets one.
+   */
+  private turnAround(ray: Ray, a: Boundary) {
+    const dir = this.direction(a);
+
+    let back = this.behind(ray, dir, a);
+
+    // Nothing behind it at all, so the way back is something it has to have —
+    // except in a sealed world, where a direction it hasn't got is not a
+    // direction it may invent. There it comes back along whichever of its own
+    // ways points most nearly backwards, and if it truly has only the one, it
+    // stays where it is rather than tearing a way out to leave by.
+    if (!back) {
+      if (this.sealed) {
+        back = this.along(ray, dir, -1, a);
+
+        if (back) ray.moving = back;
+
+        return;
+      }
+
+      const step = this.bare(a);
+
+      back = new Boundary(ray);
+      back.polarity = a.polarity;
+      if (step) back.outward = step.map(v => -v);
+      ray.boundaries.push(back);
+    }
+
+    ray.moving = back;
+
+    // It is genuinely going somewhere else now, so the way it was going is
+    // not a detour from anything. Taken up afresh from wherever it now
+    // points.
+    ray.heading = undefined;
+  }
+
+  /**
+   * Whether there is anywhere to go.
+   *
+   * Space can be moved through. So can a point that is itself moving out of
+   * our way, because by the time we get there it will have put down the space
+   * it left behind, and that space is what we move through. Anything else is
+   * in the way — including something on its way somewhere that is itself
+   * blocked, which is why this is asked of a whole queue at once rather than
+   * of one point in isolation.
+   */
+  private canMove(ray: Ray, a: Boundary, blocked: Set<Ray>): boolean {
+    // An actual boundary of the structure: we make our own way — as long as
+    // there is a way to make. A direction we can't name is one we can't grow
+    // into, and setting off into it means putting down the space we are
+    // leaving and then not leaving.
+    if (!a.target) return !!this.bare(a);
+
+    for (const other of a.target.at.node) {
+      // A source is never space, whether or not it happens to be going
+      // anywhere. Without this a charge arriving at a standing magnet reads
+      // it as somewhere to be, walks into it, and finds it can't — having
+      // already put down the space it was leaving, which is space made out of
+      // nothing, every tick, forever.
+      if (other.magnet) return false;
+
+      if (!other.moving) continue; // space: ours to move through
+
+      /**
+       * It is going somewhere, so its place will be free — whichever way it
+       * happens to be going. What it leaves behind is one point of space,
+       * spliced in on its way out, and that point is what we move into.
+       *
+       * Only one of us can have it, and which one is settled by the claim
+       * below rather than by geometry: a point being moved out of typically
+       * has several things coming up behind it at various angles, and if
+       * whoever is actually following has to also be the one lying exactly
+       * opposite the direction of travel, then in a field where directions
+       * change from tick to tick almost nobody qualifies and almost
+       * everything is stuck waiting on a queue that is moving fine.
+       *
+       * So: it is leaving, therefore it can be followed. Whoever claims the
+       * place gets it (`claimed`), and `emitBehind` puts the space it leaves
+       * on that one's connection rather than on whichever happens to be
+       * behind.
+       */
+      if (blocked.has(other)) return false; // not leaving after all
+    }
+
+    return true;
+  }
+
+  /**
+   * The space something leaves behind it.
+   *
+   * We never move ourselves — a point is what "where" is made of, and has
+   * nowhere to go. What moves is space: a fresh point is put behind us,
+   * spliced in between us and whatever was already back there, and everything
+   * we were carrying across our direction of travel is handed to it. It is
+   * neutral and has no direction of its own; nothing has happened to it yet,
+   * and giving it a charge at random would be an event this model didn't
+   * have.
+   */
+  private emitBehind(ray: Ray, a: Boundary, vacated: Map<node, number[]>, heir?: Ray) {
+    const dir = this.direction(a);
+    const step = this.bare(a);
+    const here = this.gridPos.get(ray.node);
+
+    // The space we leave goes to whoever is actually moving into our place,
+    // if anyone is — spliced in on the connection they are coming along, so
+    // that what they find in front of them next is it. Failing that (nobody
+    // following), it goes behind us in the geometric sense, which is where it
+    // would have gone anyway.
+    let back = heir
+      && ray.boundaries.find(bd => bd !== a && bd.target?.at.node === heir.node);
+
+    if (!back) back = this.behind(ray, dir, a);
+    const was = back?.target;
+    const there = was && this.gridPos.get(was.at.node);
+
+    const nd: node = [];
+    const fresh = new Ray(nd);
+    fresh.boundaries = []; // drop the constructor's default
+
+    const facing = new Boundary(fresh);
+    facing.polarity = Polarity.Neutral;
+    fresh.boundaries.push(facing);
+
+    // Nothing behind us at all, not even a bare direction, so the way back is
+    // itself something we have to have.
+    if (!back) {
+      back = new Boundary(ray);
+      back.polarity = Polarity.Neutral;
+      ray.boundaries.push(back);
+    }
+
+    back.outward = undefined;
+    back.target = facing;
+    facing.target = back;
+
+    const onward = new Boundary(fresh);
+    onward.polarity = Polarity.Neutral;
+
+    // Whatever was behind us is behind the point we just put there — and if
+    // there was nothing behind us at all, then the point we put down has
+    // nothing behind it either. In an open world that is a way out, and it
+    // gets one; sealed, it is simply a point with one fewer direction, which
+    // is not a hole because there was never anything there to lose.
+    if (was) {
+      onward.target = was;
+      was.target = onward;
+      fresh.boundaries.push(onward);
+    } else if (!this.sealed) {
+      if (step) onward.outward = step.map(v => -v);
+      fresh.boundaries.push(onward);
+    }
+
+    this.nodes.push(nd);
+
+    // Where it ends up is where we are: we are about to be one step further
+    // on, and this is what we will have left at the place we were. It can't
+    // be put there yet, though — until we have actually gone, that place is
+    // still occupied by us, and two points sharing one position have no
+    // direction between them for anything else to read. So it waits between
+    // us and what is behind us, and is put down properly once the moving is
+    // over.
+    this.setPos(nd, !here ? []
+      : there ? here.map((v, i) => (v + there[i]) / 2)
+        : step ? here.map((v, i) => v - step[i])
+          : here.slice());
+
+    if (here) vacated.set(nd, here.slice());
+
+    this.hand(this.transverse([ray], dir, back), fresh);
+  }
+
+  /**
+   * Moving through the space in front of us: it comes onto us, and stops
+   * being anywhere.
+   *
+   * This is the half of movement that makes it movement rather than drift.
+   * Its structure becomes ours, its place becomes our place, and the
+   * connection we came in on is rewired straight through to whatever lay
+   * beyond it, so nothing comes apart. One point is consumed here for the one
+   * emitted behind, so space is conserved: a thing moving is a thing swapping
+   * places with the space in front of it while everything else stays where it
+   * was.
+   *
+   * Only space is ever consumed. Anything with a direction of its own is
+   * somebody rather than somewhere.
+   */
+  private consumeAhead(ray: Ray, a: Boundary, removed: Set<node>, vacated: Map<node, number[]>) {
+    // Nothing in front of us at all: we assume we can go that way anyway, and
+    // make what we are moving into.
+    if (!a.target) this.grow(ray, a);
+
+    const ahead = a.target;
+    if (!ahead) return;
+
+    const nd = ahead.at.node;
+    if (nd === ray.node || removed.has(nd)) return;
+
+    // Only space is ever eaten. Anything going somewhere is somebody — and so
+    // is a magnet, which is a somebody that happens to be standing still: it
+    // is the source of everything happening here, and a source that its own
+    // first pulse can swallow is not a source.
+    for (const other of nd)
+      if (other.moving || other.magnet) return;
+
+    const dir = this.direction(a);
+    const bareA = this.bare(a);
+
+    // Where it is going to be, which is not yet where it is if it is space
+    // something else has just put down on its way out.
+    const there = vacated.get(nd) ?? this.gridPos.get(nd);
+
+    /**
+     * What lies beyond it the way we are going — carrying on, rather than
+     * across. Our own direction of travel is rewired onto that, so the line
+     * we are moving along stays a line.
+     *
+     * And this is where gravity is, which is worth saying plainly because
+     * nothing here looks like it.
+     *
+     * "The way we are going" is not a remembered vector. It is `dir`, the
+     * direction of the connection we are moving along, measured between the
+     * two points it currently joins — so it is a fact about the lattice as it
+     * stands rather than about where we set out. What continues it is
+     * likewise chosen from the connections the point ahead actually has, now.
+     * Nothing in this reads an absolute frame, and nothing in it remembers
+     * anything.
+     *
+     * So when an annihilation somewhere nearby splices two points together
+     * that were not joined before, the fan of directions at this point is a
+     * different fan, and the best continuation of our line is a connection
+     * that was not there and does not lead where the old one led. The ray
+     * does exactly what it always does — carry on — and arrives somewhere it
+     * would not have. That is a path bending with nothing bending it, which
+     * is the whole of what a geodesic is.
+     *
+     * What used to prevent it was asking for a continuation within about
+     * twenty-five degrees of dead ahead, and taking nothing at all otherwise.
+     * That is a fine rule in a lattice that is still square, and it is
+     * precisely wrong where one is not: exactly where the space has been bent
+     * by an annihilation, the ray would find nothing straight enough, give up
+     * its line, and either stop having a direction or walk out of a bare one.
+     * The deflection was there to be had and was being thrown away for not
+     * being small.
+     *
+     * Best available, then, and forwards. A ray follows the straightest thing
+     * this point has got, whatever that has become — which in flat lattice is
+     * the same connection it would have taken anyway, and near a collision is
+     * the one that has been moved.
+     */
+    let onward: Boundary | undefined;
+    let onwardStep: number[] | undefined;
+    let straightest = 0;
+
+    for (const other of nd) {
+      for (const bd of other.boundaries) {
+        if (bd === ahead) continue;
+
+        const d = this.direction(bd);
+        if (!d || !dir) continue;
+
+        const dot = d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
+
+        // Forwards, at least. A connection at right angles or behind is not a
+        // continuation of anything, it is a different journey.
+        if (dot <= straightest) continue;
+
+        straightest = dot;
+        onward = bd;
+        onwardStep = this.bare(bd);
+      }
+    }
+
+    // Everything it held across our path is ours now.
+    this.hand(this.transverse(nd, dir, ahead), ray);
+
+    const beyond = onward?.target;
+
+    if (beyond) {
+      a.target = beyond;
+      beyond.target = a;
+    } else {
+      // Nothing beyond it: what we are moving along is a bare direction
+      // again, and growing into it is the next thing we do. Sealed, there is
+      // no growing into anything, so it simply stops being one of our
+      // directions.
+      if (this.sealed) this.drop(a);
+      else {
+        a.target = undefined;
+        a.outward = onwardStep ?? bareA;
+      }
+    }
+
+    // And everything else it was holding is held by us, since we are where it
+    // was. Same rule as annihilation: the point stops existing and the place
+    // behind takes what it had — here the place behind is the mover, which
+    // has just arrived. Anything left out of this is a connection whose far
+    // end is still pointing at a point that no longer exists.
+    for (const other of nd) {
+      this.hand(
+        other.boundaries.filter(bd => bd !== ahead && bd !== onward && bd.target !== a),
+        ray,
+      );
+
+      other.boundaries = [];
+    }
+
+    // Its place is our place: we have moved.
+    if (there) this.setPos(ray.node, there.slice());
+
+    this.delPos(nd);
+    // Taken out of the world at the end of the tick rather than here: `nodes`
+    // is scanned by everything, and cutting one point out of it costs a pass
+    // over all of them, which with a few thousand points and a few thousand
+    // of them moving is the whole frame. `removed` is what everything in the
+    // tick actually consults, so the array can be caught up with once.
+    removed.add(nd);
+    vacated.delete(nd);
+  }
+
+  /**
+   * An actual boundary of the structure: there is nothing in front of us at
+   * all. We assume we can go that way anyway, and make what we are going
+   * into — a new point, connected to what we are connected to, so that what
+   * grows is more of the same lattice rather than a spur hanging off it.
+   *
+   * Neutral, like anything else instantiated: it is somewhere to be, not
+   * something to be. It is space, so the move that made it consumes it in the
+   * same tick, which is what moving into nothing amounts to.
+   */
+  private grow(ray: Ray, a: Boundary) {
+    const step = this.bare(a);
+    const here = this.gridPos.get(ray.node);
+    if (!step || !here) return;
+
+    const pos = here.map((v, i) => v + step[i]);
+
+    const nd: node = [];
+    const fresh = new Ray(nd);
+    fresh.boundaries = []; // drop the constructor's default
+
+    const facing = new Boundary(fresh);
+    facing.polarity = Polarity.Neutral;
+    facing.target = a;
+    fresh.boundaries.push(facing);
+
+    a.outward = undefined; // a connection now, not a bare direction
+    a.target = facing;
+
+    this.nodes.push(nd);
+    this.setPos(nd, pos);
+
+    // Connected to what we are connected to: one direction for each of ours,
+    // a real connection where a point is already there and a bare direction
+    // where there isn't one yet, so the frontier can keep going.
+    for (const boundary of ray.boundaries) {
+      if (boundary === a) continue;
+
+      const d = this.bare(boundary);
+      if (!d) continue;
+
+      const neighbour = this.nodeAt(pos.map((v, i) => v + d[i]));
+      if (neighbour === ray.node || neighbour === nd) continue; // back at us
+
+      // Nowhere there yet: an open world gets a bare direction so the
+      // frontier can keep going, a sealed one simply doesn't have that
+      // direction.
+      if (!neighbour && this.sealed) continue;
+
+      const side = new Boundary(fresh);
+      side.polarity = Polarity.Neutral;
+
+      if (neighbour) {
+        const facingBack = new Boundary(neighbour[0]);
+        facingBack.polarity = Polarity.Neutral;
+        facingBack.target = side;
+        side.target = facingBack;
+        neighbour[0].boundaries.push(facingBack);
+      } else {
+        side.outward = d;
+      }
+
+      fresh.boundaries.push(side);
+    }
+  }
+
+  /**
+   * One tick. Every ray acts, and each acts on one thing only: the boundary
+   * it is moving towards. There is nothing else it consults.
+   *
+   * Two of them meeting head-on is the one thing that isn't movement, and
+   * what it is depends only on the two charges that met:
+   *
+   *  - opposite → they cancel, leaving the space they were still connected
+   *    and still there, just neutral and still;
+   *  - alike → neither can cancel and neither can pass, so each turns itself
+   *    around.
+   *
+   * Everything else moves, and moving is a trade with space: put a point down
+   * behind, take the point in front. Space is conserved by it, which is what
+   * makes a column of things moving in step actually travel — the space each
+   * one leaves is the space the one behind it moves into.
+   */
+  tick() {
+    this._tickId++;
+
+    // Zeroed before the sources get their say, so what they emit this tick is
+    // counted against this tick.
+    this.stats = { emitted: 0, moved: 0, blocked: 0, annihilated: 0, turned: 0, path: 0, holes: 0 };
+
+    this.onTick?.(this);
+
+    // Snapshot the rays first, so structural changes don't disturb iteration.
+    const rays: Ray[] = [];
+    for (const node of this.nodes)
+      for (const ray of node)
+        rays.push(ray);
+
+    /**
+     * Before anything is read off: whoever is wandering, wanders.
+     *
+     * Done here rather than at the point of moving, because a change of
+     * direction has to be settled before it is asked who is meeting whom —
+     * otherwise a ray is judged to be about to collide on a heading it has
+     * already given up, and half the interactions in the tick are worked out
+     * against a world nobody is in any more.
+     */
+    /*
+     * Age is counted in the movement phase below, in steps actually taken
+     * rather than in ticks lived through.
+     *
+     * It is read as a distance everywhere it is used — how far out a charge
+     * has got, for fanning and for the range at which it gives up being one —
+     * and for anything moving at a cell a tick the two are the same number.
+     * For anything slower they are not: a charge held to a cell every third
+     * tick ages three times as fast as it travels, so it expires a third of
+     * the way out and the field never reaches the edge of the world.
+     */
+
+    if (this.wander > 0) {
+      for (const r of rays) {
+        if (!r.moving || r.magnet) continue;
+
+        // Where it is going, remembered — not where it went last time.
+        const head = r.heading ?? this.bare(r.moving);
+        if (!head) continue;
+
+        r.heading = head;
+
+        // The ways this direction is made of. Its own pieces only: a step of
+        // (1,1,1) is (1,0,0) and (0,1,0) and (0,0,1) taken at once, and those
+        // three are the whole of what taking it apart can mean. Their
+        // opposites are not detours down the same road, they are a different
+        // road — a ray that takes them is not going where it was going, and
+        // the direction stops meaning anything.
+        const ways: number[][] = [head];
+
+        for (let axis = 0; axis < head.length; axis++) {
+          if (!head[axis]) continue;
+
+          const one = new Array(head.length).fill(0);
+          one[axis] = head[axis];
+
+          ways.push(one);
+        }
+
+        // Straight on unless it draws otherwise, and always the whole
+        // direction if there is nothing it can be broken into — an axial
+        // heading has no longer way round.
+        const way = ways.length > 2 && Math.random() < this.wander
+          ? ways[1 + Math.floor(Math.random() * (ways.length - 1))]
+          : head;
+
+        const length = Math.hypot(...way) || 1;
+
+        const chosen = this.along(r, way.map(v => v / length), 1);
+        if (chosen) r.moving = chosen;
+      }
+    }
+
+    // Which way each ray was headed when the tick began. Read once, so that
+    // acting in some order doesn't let the earlier actions decide what the
+    // later ones are — head-on is head-on as of the start of the tick.
+    const headed = new Map<Ray, Boundary | undefined>();
+    for (const r of rays) headed.set(r, r.moving);
+
+    // 1. Who is meeting whom head-on. Both ends of such a pair have had their
+    // tick: turning around, or cancelling, is the whole of what they do in
+    // it.
+    const collisions: Interaction[] = [];
+    const reflections: { r: Ray, a: Boundary }[] = [];
+    const met = new Set<Ray>();
+
+    for (const r of rays) {
+      if (met.has(r)) continue;
+
+      const a = headed.get(r);
+      if (!a) continue;
+
+      const ahead = a.target?.at.node;
+      if (!ahead || ahead === r.node) continue;
+
+      // Arriving at a source. It carries no charge, so there is nothing to
+      // cancel with, and it is never space, so there is no moving through it
+      // — which leaves the only other thing anything does here: it turns
+      // around. A source reflects what reaches it, and it does so whether or
+      // not it is itself going anywhere, which is what makes it different
+      // from every other head-on case.
+      if (ahead.some(x => x.magnet)) {
+        met.add(r);
+        reflections.push({ r, a });
+        continue;
+      }
+
+      /**
+       * Whoever over there is coming back at us.
+       *
+       * Not necessarily along the same connection. On a line there is only
+       * one way to be coming the other way, and "head-on" can be checked by
+       * asking whether the far side is moving along this very boundary. With
+       * twenty-six directions two things can be moving into each other
+       * without being anywhere near opposite — one going along an edge, one
+       * through a corner — and by that test neither of them is meeting
+       * anything.
+       *
+       * Which is worse than a missed case: neither can move, because the
+       * other is in the way and isn't leaving, so two fronts that should pass
+       * through each other (cancelling as they go) instead stop dead against
+       * each other and stay there. Nothing happens, and nothing goes on
+       * happening.
+       *
+       * So the test is the thing itself: I am moving into where you are, and
+       * you are moving into where I am.
+       */
+      let r2: Ray | undefined;
+      let b: Boundary | undefined;
+
+      for (const other of ahead) {
+        if (met.has(other)) continue;
+
+        // Not against itself: two charges of the same source are two parts of
+        // one field, and a field arriving where it already is is not an
+        // event. See the arriving-together case below.
+        if (r.source !== undefined && r.source === other.source) continue;
+
+        const bd = headed.get(other);
+        if (!bd || bd.target?.at.node !== r.node) continue;
+
+        r2 = other;
+        b = bd;
+        break;
+      }
+
+      if (!r2 || !b) continue;
+
+      met.add(r); met.add(r2);
+
+      // Only two actual charges, one of each, cancel. Neutral space has no
+      // charge to cancel with, so anything else that meets head-on turns
+      // around instead.
+      const opposed =
+        (a.polarity === Polarity.Positive && b.polarity === Polarity.Negative) ||
+        (a.polarity === Polarity.Negative && b.polarity === Polarity.Positive);
+
+      collisions.push({ kind: opposed ? 'annihilate' : 'turn', r, a, r2, b });
+    }
+
+    /**
+     * Two charges arriving at the same point.
+     *
+     * Everything above asks whether two things are moving into each other,
+     * which is to say whether they are next to each other and pointed the
+     * opposite way. On a line that is the only way two things can meet, and
+     * it is where this rule came from.
+     *
+     * In three dimensions it is the exceptional way. Two shells sweeping
+     * through each other are made of rays coming in at all angles, and what
+     * those rays overwhelmingly do is converge on the SAME cell from
+     * different directions — never becoming neighbours, never pointed at each
+     * other, both pointed at the same third place. By the test above neither
+     * of them is meeting anything. They are resolved as traffic instead: one
+     * takes the place, the other waits, and two fields pass straight through
+     * one another with nothing to show for it.
+     *
+     * Which is the answer to why the fields overlap and never attract. It was
+     * never that the shells missed each other; it is that arriving together
+     * was not on the list of ways to meet.
+     *
+     * So it is now, and it is the same event: two opposite charges cancel,
+     * their points go, and what was behind each closes onto what was behind
+     * the other — the whole of it exactly as for two that met head-on, since
+     * `annihilate` cares about what is BEHIND the two rather than about how
+     * they came to be in the same place. Alike charges arriving together are
+     * left to traffic, as before: they cannot cancel, and nothing about
+     * wanting the same cell makes them turn around.
+     */
+    const arriving = new Map<node, Ray>();
+
+    for (const r of rays) {
+      if (met.has(r) || r.magnet) continue;
+
+      const a = headed.get(r);
+      const there = a?.target?.at.node;
+      if (!a || !there || there === r.node) continue;
+
+      const other = arriving.get(there);
+
+      if (!other) { arriving.set(there, r); continue; }
+
+      const b = headed.get(other)!;
+
+      /**
+       * A field does not interact with itself.
+       *
+       * Two charges thrown out by the same source are two parts of one thing
+       * it is doing, and one part of a field arriving where another part of
+       * the same field already is has never been an event. Left to interact,
+       * they are a disaster: a source that turns puts consecutive shells out
+       * at an eighth of a turn from each other, so where one shell's north
+       * lobe overtakes the next one's south they are opposite, and they
+       * cancel — the field eats itself as fast as it is made. What survives
+       * blocks, stalls, and is overtaken, and the shells lose their order.
+       * Measured: waves emitted fourteen, twelve, nine and eight pulses ago
+       * all sitting at the same radius, each pointing a different way, their
+       * lobes averaging out to nothing in particular.
+       *
+       * Each shell is a clean two-lobed thing on its own — that much is
+       * emitted correctly and always was. It is only in being allowed to
+       * annihilate against its own neighbours that the order is lost.
+       *
+       * Charges from DIFFERENT sources still meet in the ordinary way, which
+       * is the whole of what two magnets do to each other.
+       */
+      if (r.source !== undefined && r.source === other.source) continue;
+
+      const opposed =
+        (a.polarity === Polarity.Positive && b.polarity === Polarity.Negative) ||
+        (a.polarity === Polarity.Negative && b.polarity === Polarity.Positive);
+
+      met.add(r); met.add(other);
+
+      /**
+       * Alike, and both wanting the same place: they turn around.
+       *
+       * This used to be left to traffic — one takes the place, the other
+       * waits — and that is why two sources turning in step do nothing at
+       * all. They emit the same charge on the same tick, so their shells are
+       * the same polarity, so the two that meet in the middle are always
+       * alike. Never opposite, so nothing ever cancelled there; and merely
+       * queued rather than turned, so nothing ever came back either. The
+       * whole interaction between them was one of them waiting a tick.
+       *
+       * Turning is what actually happens: neither can cancel the other and
+       * neither can pass through it, which is the same situation as meeting
+       * head-on and has the same answer. And it is what makes the two spin
+       * cases the same thing in the end — each of them comes back into the
+       * opposite-charged shell following behind it, and cancels against that.
+       * The space between the two still gets eaten; it takes one more step
+       * about it.
+       */
+      if (!opposed) {
+        arriving.delete(there); // both going back the way they came
+
+        collisions.push({ kind: 'turn', r, a, r2: other, b });
+
+        continue;
+      }
+
+      arriving.delete(there); // both gone; the place is free again
+
+      collisions.push({ kind: 'annihilate', r, a, r2: other, b });
+    }
+
+    const removed = new Set<node>();
+
+    // Only the last couple of ticks' worth is kept: an event is a thing that
+    // happened, not a thing that is there.
+    this.events = this.events.filter(e => e.tick > this._tickId - 2);
+
+    /**
+     * Whether an interaction worked out at the top of the tick is still an
+     * interaction by the time we get to it.
+     *
+     * They were all found against the world as it was when the tick began,
+     * and then they are carried out one after another — so each one is
+     * carried out against a world the ones before it have been changing.
+     * Annihilating splices two points out and hands what they were carrying
+     * to whatever was behind them, which can pick a ray up off the node it
+     * was on and leave it holding none of the boundaries it had.
+     *
+     * With one interface between two waves there is only ever one of these a
+     * tick and it cannot happen. With a field full of shells there are
+     * hundreds, and the ones that are stale get carried out anyway: rewiring
+     * `target`s across connections that have already been spliced, in exactly
+     * the region where everything is happening. What comes of it is a
+     * knot — points connected to points that no longer exist, rays that can
+     * no longer move, nothing more able to reach anything else — which looks
+     * from outside like the first wave interacting beautifully and every
+     * wave after it doing nothing at all.
+     *
+     * Every other phase of the tick already checks this (see `movers`). This
+     * one didn't.
+     */
+    const alive = (r: Ray, bd: Boundary) =>
+      !removed.has(r.node) && r.boundaries.includes(bd);
+
+    for (const it of collisions) {
+      if (!alive(it.r, it.a) || !alive(it.r2, it.b)) continue;
+
+      // Noted before it is carried out — an annihilation removes both of the
+      // points it happened between, and afterwards there is nowhere to say it
+      // happened at.
+      this.mark(it.kind, it.r, it.r2);
+
+      if (it.kind === 'annihilate') {
+        this.stats.annihilated++;
+        this.annihilate(it.r, it.a, it.r2, it.b, removed);
+      } else {
+        this.stats.turned++;
+        this.turnAround(it.r, it.a);
+        this.turnAround(it.r2, it.b);
+      }
+    }
+
+    /**
+     * What arrives at a source is taken back into it.
+     *
+     * This used to turn around, on the grounds that a source can neither
+     * cancel a charge nor be moved through, so the only thing left was to
+     * come back the way it came. True as far as it goes, and it silts the
+     * source up: a reflected charge is still a charge, still sitting in one
+     * of the couple of dozen cells its source has to emit into, and free to
+     * wander straight back. A handful of them and the source is walled in by
+     * its own output — emitting nothing, ever again.
+     *
+     * A thing that writes charge onto space can take it off again; a source
+     * is a sink for the same reason it is a source. So the charge is simply
+     * undone — its polarity goes, it stops going anywhere, and it is space
+     * once more. No point is created or destroyed by it, and the source is
+     * left with somewhere to emit next tick, which is the whole condition of
+     * it going on being a source at all.
+     */
+    for (const { r, a } of reflections) {
+      if (!alive(r, a)) continue;
+
+      r.moving = undefined;
+      r.wave = undefined;
+      r.age = 0;
+      r.fanned = false;
+      r.heading = undefined;
+
+      for (const bd of r.boundaries) bd.polarity = Polarity.Neutral;
+    }
+
+    // 2. Everything else moves — read off the world as the collisions have
+    // left it, so that space that has just closed up behind an annihilation
+    // is gone before anything tries to move through it.
+    const movers = rays.filter(r =>
+      !met.has(r)
+      && r.moving
+      && !removed.has(r.node)
+      && r.boundaries.includes(r.moving));
+
+    const blocked = new Set<Ray>();
+
+    /**
+     * One step, one tick, whichever way it goes.
+     *
+     * Everything moves away every tick, and that is the whole of it: a cell
+     * emptied this tick is available the next, so a source is never waiting
+     * on its own last pulse and every shell leaves complete.
+     *
+     * The alternative is to charge a step its own length — √2 through an
+     * edge, √3 through a corner — so that every direction covers the same
+     * DISTANCE per tick and a shell stays a round shell. It is the tidier
+     * geometry and it costs too much: the corner directions then take nearly
+     * two ticks a step, the cells they occupy are still occupied when the
+     * next pulse is due, and what leaves is fourteen of the twenty-six
+     * directions with holes in the same places every time.
+     *
+     * A step per tick makes the front a cube rather than a sphere — the
+     * corners of it run out at 1.73 times the speed of the faces — and that
+     * is simply the true shape of "one move a tick" in a space with
+     * twenty-six directions. It is a coherent front either way: shell k is
+     * the points k steps out, all of them, and no shell ever overtakes
+     * another.
+     */
+    const cost = new Map<Ray, number>();
+
+    for (const r of movers) {
+      const price = r.mass ?? 1;
+
+      cost.set(r, price);
+      r.credit = (r.credit ?? 0) + 1;
+
+      // Not yet paid for. It is still going where it was going, and anything
+      // queued up behind it is still behind something that isn't leaving —
+      // which is exactly what `blocked` means, so it goes in there and the
+      // settling below carries it back down the queue.
+      if (r.credit + 1e-9 < price) blocked.add(r);
+    }
+
+    /**
+     * Who is actually going anywhere.
+     *
+     * Two conditions, settled together rather than one after the other,
+     * because each can undo the other's answer: something cleared to follow a
+     * mover has to be reconsidered if that mover turns out not to be going
+     * after all, whatever the reason it isn't.
+     *
+     * The first is traffic — being behind something that is leaving is fine,
+     * being behind something that only looked like it was leaving is not.
+     *
+     * The second is that a place can only be taken by one thing. Two points
+     * can both be moving into the same empty cell — on a line they can't, but
+     * with twenty-six directions to come from it is the ordinary case — and
+     * both are clear to go by every other test, since every other test is
+     * about whether the way ahead is clear and for both of them it is. Then
+     * they go: both put down the space they are leaving, the first to arrive
+     * consumes the cell, and the second finds the place it was moving to no
+     * longer exists and stops, having already emitted. One point made out of
+     * nothing, and one charge that has not moved.
+     *
+     * So the place is claimed before anything sets off, and whoever doesn't
+     * get it waits — which is what being behind something else amounts to,
+     * arrived at sideways.
+     */
+    const order = shuffle(movers);
+    const claimed = new Map<node, Ray>();
+
+    for (let pass = 0; pass < movers.length; pass++) {
+      let changed = false;
+
+      for (const r of order) {
+        if (blocked.has(r)) continue;
+        if (this.canMove(r, r.moving!, blocked)) continue;
+
+        blocked.add(r);
+        changed = true;
+      }
+
+      claimed.clear();
+
+      for (const r of order) {
+        if (blocked.has(r)) continue;
+
+        const there = r.moving!.target?.at.node;
+        if (!there) continue; // making its own way: nowhere yet to be claimed
+
+        const holder = claimed.get(there);
+
+        if (!holder) { claimed.set(there, r); continue; }
+
+        blocked.add(r);
+        changed = true;
+      }
+
+      if (!changed) break;
+    }
+
+    const going = order.filter(r => !blocked.has(r));
+
+    // Paid on going, not on being ready to: something held up in traffic
+    // keeps what it has saved and leaves the moment the way is clear.
+    for (const r of going) {
+      r.credit = (r.credit ?? 0) - (cost.get(r) ?? 1);
+
+      // One cell older, because it is one cell further on.
+      if (!r.magnet) r.age = (r.age ?? 0) + 1;
+    }
+
+    this.stats.moved = going.length;
+    this.stats.blocked = movers.length - going.length;
+
+    // Two passes over the same rays. Everything puts down the space it is
+    // leaving before anything goes anywhere, because the space one of them
+    // leaves is what the one behind it moves through — done one ray at a time
+    // instead, the one behind would find its way blocked by a neighbour that
+    // hasn't left yet.
+    const vacated = new Map<node, number[]>();
+
+    // `claimed` says who is taking each place, so for anything leaving it
+    // also says who is coming up behind it — which is who its space goes to.
+    for (const r of going) this.emitBehind(r, r.moving!, vacated, claimed.get(r.node));
+    for (const r of going) this.consumeAhead(r, r.moving!, removed, vacated);
+
+    // Everything has gone where it was going, so the space left behind can
+    // take the places that were left.
+    for (const [nd, pos] of vacated)
+      if (!removed.has(nd)) this.setPos(nd, pos);
+
+    // And everything that stopped being anywhere during the tick stops being
+    // in the world, in one pass rather than one pass each.
+    if (removed.size) this.nodes = this.nodes.filter(n => !removed.has(n));
+
+    // Directions with nothing on the far side of them. A handful at the rim
+    // of the world is the world having a rim; a number that climbs tick after
+    // tick is the lattice being torn apart from the inside, which is what a
+    // path that stops shortening usually means.
+    this.stats.holes = 0;
+    for (const nd of this.nodes)
+      for (const ray of nd)
+        for (const bd of ray.boundaries)
+          if (!bd.target) this.stats.holes++;
+
+    this.route = this.shortestPath();
+    this.stats.path = Math.max(this.route.length - 1, 0);
+    this.history.push(this.stats.path);
+    if (this.history.length > 240) this.history.shift();
+
+    this.invalidateLayout();
+  }
+
+  /**
+   * Seed an initial "expanding universe": a small connected patch of nodes,
+   * each a single ray with one boundary per orthogonal neighbour. Every
+   * boundary gets a random polarity, and every ray a random `moving`
+   * direction (one of its boundaries). From there the tick rules —
+   * annihilation (opposite polarities meeting head-on), merging (like
+   * polarities meeting head-on), and movement (everything else) — drive the
+   * evolution.
+   *
+   * The patch is small because everything in it moves, and everything that
+   * moves instantiates the space it leaves behind: the population grows by
+   * roughly one point per moving ray per tick, so what you seed is what you
+   * pay for on every tick thereafter.
+   */
+  static grid({ dims = 3, size = 5 }: { dims?: number, size?: number } = {}): Graph {
+    const graph = new Graph();
+    graph.dims = dims;
+    const center = Math.floor(size / 2);
+
+    const { nodes } = Graph.lay(graph, box(dims, size).map(c => c.map(v => v - center)), {
+      charge: randomPolarity,
+    });
+
+    // Give every ray an initial movement direction — a random one of its
+    // boundaries. This is an initial condition, not a choice the dynamics
+    // ever make again: from here on movement is conserved.
+    for (const node of nodes) {
+      const ray = node[0];
+      if (ray.boundaries.length)
+        ray.moving = ray.boundaries[Math.floor(Math.random() * ray.boundaries.length)];
+    }
+
+    graph.ringRadius = center;
+
+    return graph;
+  }
+
+  /**
+   * Lay a patch of points out on a lattice: one point per coordinate, each a
+   * single ray carrying one boundary per neighbour present in the patch,
+   * wired to that neighbour's boundary facing back.
+   *
+   * `around` is which neighbours those are, and it is the whole of what "how
+   * many ways out of here are there" means. The default is the axes — the six
+   * faces of a cell in 3D — which is all anything moving along a line ever
+   * needs. Passing `directions(dims)` instead gives a point all 3^d − 1 of
+   * them, and that is what a source radiating in every direction at once
+   * requires: it can only emit into directions the space it is sitting in
+   * actually has.
+   *
+   * This is the one way points are ever laid down. Every seed below is a
+   * choice of three things and nothing else — which coordinates there are,
+   * what charge each carries, and how many ways out of each — so the seeds
+   * differ in what they say rather than in how they say it.
+   *
+   * Returns everything a caller needs to say which way things move: the
+   * points in coordinate order, a lookup by coordinate, and, per point, which
+   * of its boundaries faces which neighbour.
+   */
+  private static lay(
+    graph: Graph,
+    coords: number[][],
+    { charge = () => Polarity.Neutral, around }: {
+      charge?: (coord: number[]) => Polarity,
+      around?: number[][],
+    } = {},
+  ) {
+    const key = (c: number[]) => c.join(",");
+
+    const nodes: node[] = [];
+    const byCoord = new Map<string, node>();
+    const coordOf = new Map<node, number[]>();
+
+    for (const coord of coords) {
+      const nd: node = [];
+      const ray = new Ray(nd);
+      ray.boundaries = []; // drop the constructor's default boundary
+
+      graph.nodes.push(nd);
+      graph.setPos(nd, coord);
+
+      nodes.push(nd);
+      byCoord.set(key(coord), nd);
+      coordOf.set(nd, coord);
+    }
+
+    const facing = new Map<node, Map<node, Boundary>>();
+    for (const nd of nodes) {
+      const coord = coordOf.get(nd)!;
+      const ray = nd[0];
+      const m = new Map<node, Boundary>();
+      facing.set(nd, m);
+
+      for (const step of around ?? axes(coord.length)) {
+        const neighbour = byCoord.get(key(coord.map((v, i) => v + step[i])));
+        if (!neighbour) continue;
+
+        const b = new Boundary(ray);
+        b.polarity = charge(coord);
+        ray.boundaries.push(b);
+        m.set(neighbour, b);
+      }
+    }
+
+    // Mutual targets: this point's boundary facing a neighbour points at that
+    // neighbour's boundary facing back.
+    for (const nd of nodes) {
+      for (const [neighbour, b] of facing.get(nd)!) {
+        const back = facing.get(neighbour)!.get(nd);
+        if (back) b.target = back;
+      }
+    }
+
+    return {
+      nodes,
+      facing,
+      // What is at a coordinate, if anything is. Callers name places rather
+      // than indices, so this is the only lookup any of them needs.
+      at: (coord: number[]) => byCoord.get(key(coord)),
+    };
+  }
+
+  /**
+   * Two solid blocks of points, side by side along x, every point in each one
+   * moving into the other. So the two innermost columns meet head-on, and
+   * every column behind them is moving into the back of the one in front —
+   * interior points are moving into their own block, which isn't head-on (the
+   * point ahead is moving the same way, not back), so behind the interface
+   * every column is simply moving.
+   *
+   * `charge` is the whole of what separates the interesting cases, and there
+   * are two shapes of answer to it.
+   *
+   * Uniform per block (`bySide`): every point of a block carries that block's
+   * polarity, so the whole interface meets head-on at once, and the three ways
+   * two polarities can be arranged are three things happening to a surface
+   * rather than to a single pair. Opposite, the interface annihilates a column
+   * at a time, each annihilation throwing what it was carrying out behind it,
+   * so the two blocks come apart backwards. Alike, they cannot annihilate, so
+   * the interface merges and the two blocks become one.
+   *
+   * Drawn per point (`perPoint`): nothing uniform about either block, so the
+   * interface is not one thing happening to a surface but a different thing
+   * happening at every row of it. Opposite pairs cancel and take their space
+   * with them, alike pairs turn around and head back out through their own
+   * block — at the same moment, along the same surface. What a block is, then,
+   * isn't decided by the block. It is decided pair by pair, and the two of
+   * them come apart along a line neither of them had.
+   */
+  static blocks(
+    { size = 3, charge }: { size?: number, charge: (coord: number[]) => Polarity },
+  ): Graph {
+    const graph = new Graph();
+    graph.dims = 2;
+    graph.ringRadius = size;
+
+    const half = Math.floor(size / 2);
+
+    const coords: number[][] = [];
+    for (let x = -size; x < size; x++)
+      for (let y = -half; y <= half; y++)
+        coords.push([x, y]);
+
+    const { nodes, at, facing } = Graph.lay(graph, coords, { charge });
+
+    for (const nd of nodes) {
+      const coord = graph.gridPos.get(nd)!;
+      const towards = at([coord[0] + (coord[0] < 0 ? 1 : -1), coord[1]]);
+      if (towards) nd[0].moving = facing.get(nd)!.get(towards);
+    }
+
+    return graph;
+  }
+
+  /**
+   * The same two blocks, but not touching: a wide field of neutral space
+   * between them, and neither of them moving. Nothing here is told to fall
+   * towards anything.
+   *
+   * What they do instead is emit. Every tick each block writes a charge onto
+   * the space at its face and points it across the gap — alternating, so a
+   * charged pulse goes out every other tick and a neutral one in between. A
+   * pulse is not a new thing added to the world: it is a point of the space
+   * that was already there, told what it is and which way it is going. It
+   * crosses by trading places with the space in front of it, so the field
+   * stays the same size while something travels through it.
+   *
+   * The two streams meet in the middle, and what they do there is the whole
+   * experiment:
+   *
+   *  - opposite charges annihilate, and annihilation is the one rule that
+   *    takes space out of the world. The two points that cancelled are gone
+   *    and what was behind each closes directly onto what was behind the
+   *    other, so every meeting leaves the two blocks fewer points apart than
+   *    they were. Nothing moved them. The distance between them is just
+   *    smaller — which is what it would mean, here, for them to be falling
+   *    towards each other. Once the first pair meets there is a meeting every
+   *    tick, each eating the two columns that met, and it runs until the field
+   *    is gone and the two blocks are directly connected.
+   *  - like charges can't cancel, so they turn around and go home instead.
+   *    The field is exactly as wide as it was — and what comes back is a
+   *    charge arriving at a block that isn't moving, which the block has no
+   *    way to refuse, so the blocks end up being driven apart by their own
+   *    emissions rather than drawn together.
+   *
+   * So `left` and `right` are what each block emits, and that alone is the
+   * difference between attraction and repulsion.
+   *
+   * What is drawn is still where each point was put down, and annihilation
+   * doesn't move what it leaves behind: the field empties from the middle
+   * outwards and the blocks stay where they were drawn, joined across the
+   * emptied part by the connection that closed up over it. The gap in the
+   * picture is the space that no longer exists.
+   *
+   * `every` is how many ticks apart the emissions are, and `spin` flips what
+   * each block is emitting between one emission and the next — a magnet being
+   * turned over and over rather than held still. `left` and `right` are then
+   * only what each side starts as, and what matters is whether the two are
+   * turning together or against each other.
+   */
+  static emitters(
+    {
+      left = Polarity.Positive,
+      right = Polarity.Negative,
+      size = 2,
+      gap = 16,
+      height = 3,
+      every = 2,
+      spin = false,
+    }: {
+      left?: Polarity, right?: Polarity,
+      size?: number, gap?: number, height?: number,
+      every?: number, spin?: boolean,
+    } = {},
+  ): Graph {
+    const graph = new Graph();
+    graph.dims = 2;
+    graph.ringRadius = 1; // a flat lattice: nothing here wants rounding off
+
+    const half = Math.floor(height / 2);
+
+    // The field is an even number of columns wide, so that the two streams
+    // end up adjacent and meet each other rather than both arriving at the
+    // same empty cell — which is two things trying to be in one place, and
+    // not a meeting at all.
+    const width = gap + (gap % 2);
+    const l0 = -width / 2, r0 = width / 2 - 1; // the two columns at the faces
+
+    const coords: number[][] = [];
+    for (let x = l0 - size; x <= r0 + size; x++)
+      for (let y = -half; y <= half; y++)
+        coords.push([x, y]);
+
+    // Only the blocks are charged. The field between them is what space is
+    // when nothing has happened to it yet.
+    const { at } = Graph.lay(graph, coords, {
+      charge: coord =>
+        coord[0] < l0 ? left
+          : coord[0] > r0 ? right
+            : Polarity.Neutral,
+    });
+
+    // The two faces: the innermost column of each block, and the way out of
+    // it. Blocks never move, so these stay the points they are.
+    const faces: { at: node, dir: number[], polarity: Polarity }[] = [];
+
+    for (let y = -half; y <= half; y++) {
+      const l = at([l0 - 1, y]);
+      const r = at([r0 + 1, y]);
+
+      if (l) faces.push({ at: l, dir: [1, 0], polarity: left });
+      if (r) faces.push({ at: r, dir: [-1, 0], polarity: right });
+    }
+
+    graph.onTick = g => {
+      // Ticks are counted from the first one, so `every = 2` puts a step of
+      // untouched space between one pulse and the next — the tick in between
+      // emits neutral, and emitting neutral is emitting what the space at the
+      // face already is, which is to say nothing leaves. `every = 1` is a
+      // block that never stops: one pulse directly behind the last, with no
+      // space in between for either of them to move through.
+      if ((g._tickId - 1) % every !== 0) return;
+
+      // Which way round the magnet is by now.
+      const turned = spin && Math.floor((g._tickId - 1) / every) % 2 === 1;
+
+      for (const face of faces) {
+        const here = g.gridPos.get(face.at);
+        if (!here) continue;
+
+        const ahead = g.nodeAt(here.map((v, i) => v + face.dir[i]));
+        const ray = ahead?.[0];
+
+        // Only space can be told what to be. Anything already going somewhere
+        // is somebody, and the face waits rather than overwriting it.
+        if (!ray || ray.moving) continue;
+
+        const polarity = turned ? opposite(face.polarity) : face.polarity;
+
+        for (const bd of ray.boundaries)
+          bd.polarity = polarity;
+
+        ray.moving = g.along(ray, face.dir, 1);
+      }
+    };
+
+    return graph;
+  }
+
+  /**
+   * A world with sources in it, in as many dimensions as it has, radiating in
+   * every direction there is.
+   *
+   * `emitters` above is a flat experiment: two walls facing each other across
+   * a corridor, each writing a charge onto the one column of space in front
+   * of it. Everything that happens there happens along one axis, which is
+   * exactly why it is legible — and exactly why it can't answer the question
+   * it raises. Two things pulling on each other along the line between them
+   * can only ever move along that line. Nothing can go round anything.
+   *
+   * So: a ball of neutral space wired with all 3^d − 1 directions (see
+   * `directions`), and in it however many sources the world says, each of
+   * which every `beat` ticks writes its charge onto every point it is
+   * connected to and sends each one outward along the direction it was
+   * written in. A source that flips puts out the opposite of what it put out
+   * last time, so what fills the ball is alternating shells rather than one
+   * thing over and over; a source that turns brings its poles round instead,
+   * so what a given direction receives alternates because the thing is going
+   * round. `phase` says where in that cycle each one starts, which decides
+   * whether the shells meeting in the middle are alike (and bounce) or
+   * opposite (and cancel, taking the space between the sources with them).
+   *
+   * There is nothing special about two of them. Every rule here is about a
+   * point and what is next to it, so a third source is not a third body to be
+   * accounted for — it is more of the same thing happening, and the only
+   * difference is that three gaps go at once and no symmetry is left holding
+   * any of them.
+   *
+   * A pulse is a shell rather than a beam, and it stays one: see the Huygens
+   * step in `onTick`, without which it is a couple of dozen bullets that get
+   * further apart the further they go and almost never meet anything.
+   *
+   * Three things had to be decided to make this work at all, and each one is
+   * a claim rather than a convenience:
+   *
+   *  - A direction is one step of the lattice, not a unit of distance. Off
+   *    the axes those differ (`latticeStep`), and using the second is what
+   *    puts points at coordinates the lattice hasn't got.
+   *
+   *  - The body of a magnet is NEUTRAL. A charged one is cancelled by the
+   *    first opposite pulse that reaches it, and two magnets that annihilate
+   *    each other on contact have no chance to orbit anything. Neutral, it
+   *    can't cancel and can't be cancelled: a charge arriving head-on turns
+   *    it round instead, which is the only way anything here is ever pushed.
+   *
+   *  - What is drawn is the structure, not the coordinates (`relax`). Two
+   *    magnets attract in this model by the space between them being
+   *    annihilated and the connection closing up over the gap — which, drawn
+   *    by coordinate, is two bodies sitting exactly where they were with a
+   *    hole between them. Drawn by structure, a connection that now spans
+   *    three cells of nothing pulls its ends together, and attraction is
+   *    something you can watch instead of something you have to be told.
+   */
+  static sources(
+    {
+      sources,
+      dims = 3,
+
+      // Far enough apart to have somewhere to go.
+      //
+      // Every direction counts as a step here, diagonals included, so two
+      // points eight either side of the origin are only sixteen steps apart
+      // however far that is in coordinates — which the first few pulses eat
+      // through before there is anything to watch. What is left afterwards is
+      // two sources sitting next to each other not moving into one another,
+      // which is not them failing to attract, it is them having finished:
+      // neither is space, so neither can be moved through, and adjacent is as
+      // close as adjacent gets.
+      radius = 13,
+
+      turnEvery = 1,
+
+      // Half the moves taken as one of the pieces the direction is made of:
+      // enough that a stream genuinely searches the space around it, while
+      // the whole diagonal being one option among its pieces keeps the drift
+      // pointing the way it set out.
+      wander = 0.5,
+
+      /**
+       * How many moves a charge lasts before it is space again.
+       *
+       * Without this the field has no way of losing anything except by
+       * cancelling or by reaching the rim, and both are far too slow: a
+       * source puts fifty charges a tick into a finite ball, the fan
+       * multiplies each of them, and nothing takes them out again. The space
+       * between two fills — measurably, two hundred and thirty-three charges
+       * in a box of two hundred and twenty-five cells — and then every single
+       * thing in the model stops at once, because moving is trading places
+       * with space and there is no space left to trade with. Not a slowdown:
+       * the population, the distance between the sources and the connections
+       * of both of them go constant on the same tick and never change again.
+       *
+       * A range fixes the population instead of letting it climb: emitted per
+       * tick times how long each lasts, which is a number that can be kept
+       * well under what the ball holds. And it is the right shape of rule —
+       * a pulse spreading over a bigger and bigger shell is thinning as it
+       * goes, and at some distance it is no longer anything the space it is
+       * crossing can tell from space.
+       */
+      range = 14,
+      spread = 0.45,
+      fanAt,
+    }: World,
+  ): Graph {
+    const graph = new Graph();
+    graph.dims = dims;
+    graph.ringRadius = 1; // the lattice is the picture; nothing to round off
+    graph.relax = true;
+    graph.wander = wander;
+    graph.sealed = true; // a closed ball: no edges to walk off, no tears
+
+    // A ball rather than a cube, so that "the same in every direction" is
+    // true of the space as well as of what is emitted into it. A disc, in two
+    // dimensions, for the same reason and by the same test.
+    const coords: number[][] = [];
+
+    (function fill(at: number[]) {
+      if (at.length === dims) {
+        if (at.reduce((r, v) => r + v * v, 0) <= radius * radius) coords.push(at);
+        return;
+      }
+
+      for (let v = -radius; v <= radius; v++) fill([...at, v]);
+    })([]);
+
+    // Nothing is charged to begin with. Every charge in this universe comes
+    // out of one of the sources, so there is nothing to confuse a pulse with
+    // — what you see moving was emitted.
+    const { at } = Graph.lay(graph, coords, { around: directions(dims) });
+
+    // The camera is for the part of the ball that anything ever happens in,
+    // which is the part inside the absorbing edge below. Framing the whole
+    // ball instead leaves a fifth of the picture as lattice nothing can reach
+    // — and makes the shells look as though they vanish well short of the
+    // edge, when in fact they are running the whole way to it.
+    graph.focus = radius - 2;
+
+    // Far enough out that a shell has room for its fan, and close enough in
+    // that it has fanned before it gets to whatever it is going to meet —
+    // which is halfway to the nearest other source.
+    const gap = spacing(sources);
+
+    const fan = fanAt ?? Math.max(Math.floor((gap ?? radius / 1.5) / 4), 2);
+
+    const count = sources.length;
+
+    sources.forEach((source, index) => {
+      // Shorter than the world has dimensions means nought in the rest, so a
+      // pair can be laid out along x without saying so in every dimension.
+      const nd = at(new Array(dims).fill(0).map((v, i) => source.at[i] ?? v));
+      if (!nd) return;
+
+      const ray = nd[0];
+      ray.magnet = true;
+      ray.source = index;
+      ray.emits = source.emits ?? Polarity.Positive;
+      ray.phase = source.phase ?? 0;
+      ray.axis = source.axis;
+      ray.turning = source.turning;
+      ray.beat = source.beat ?? 1;
+
+      // A turning source is already alternating and does not also flip; one
+      // that is not turning has nothing to make a wave out of unless it does.
+      ray.flips = source.flips ?? !source.turning;
+
+      // A stated speed is a stated mass, and one that was never stated falls
+      // back on what a source weighs.
+      ray.mass = massFor(speedOf(source));
+
+      if (source.plane) ray.ring = turnRing(source.plane[0], source.plane[1]);
+
+      // An initial direction is named as a lattice step and resolved to the
+      // boundary that actually goes that way, so a direction the point hasn't
+      // got lands on the nearest one it has rather than on nothing.
+      if (source.drift) {
+        const length = Math.hypot(...source.drift) || 1;
+        ray.moving = graph.along(ray, source.drift.map(v => v / length), 1);
+      }
+    });
+
+    graph.onTick = g => {
+      /**
+       * The edge of the world absorbs.
+       *
+       * Left to itself this universe does not run: it fills. Every pulse
+       * charges more space than the last, nothing ever gives its charge back
+       * (a charge only stops being one by meeting its opposite head-on), and
+       * within a dozen ticks every point in the ball is a charge going
+       * somewhere. At which point the sources have nothing left to emit
+       * into — a source can only write onto space, and there isn't any — so
+       * the pulsing stops, and what is left is a ball of stuff drifting
+       * outwards, dragging the frame after it as it goes.
+       *
+       * So a charge that reaches the edge is simply undone: its polarity goes
+       * and it stops going anywhere, which is to say it becomes space again.
+       * Space is neither created nor destroyed by it — the point is still
+       * there, it is just nobody. The ball stays the size it was, the
+       * frame stays where it was, and there is always somewhere for the next
+       * pulse to go, so the pulsing is continuous rather than a burst that
+       * silts the world up.
+       *
+       * It is a boundary condition and not a rule: it says what happens at
+       * the edge of the part we are looking at, which in a universe that
+       * didn't have an edge would be nothing at all.
+       */
+      // How far out the world is still live. Ordinarily the seeded ball —
+      // held two in from its edge, since the longest step here is a corner
+      // one at √3 ≈ 1.74 and nothing may step over the edge before it is
+      // reached. But sources that travel take the experiment with them:
+      // absorbing at a fixed distance from where they STARTED would undo
+      // their field the moment they had gone anywhere, and framing there
+      // would leave them sailing off the edge of a picture of the space they
+      // had left.
+      let reach = radius - 2;
+
+      for (const nd of g.nodes) {
+        if (!nd.some(r => r.magnet)) continue;
+
+        const pos = g.gridPos.get(nd);
+        if (pos) reach = Math.max(reach, Math.hypot(...pos) + 4);
+      }
+
+      g.focus = reach;
+
+      // Spent, or out at the rim: either way it stops being a charge and goes
+      // back to being somewhere. No point is made or destroyed by it — see
+      // `range` for why the second condition alone is not enough.
+      for (const nd of g.nodes) {
+        const pos = g.gridPos.get(nd);
+        if (!pos) continue;
+
+        const out = Math.hypot(...pos) >= reach;
+
+        for (const ray of nd) {
+          if (ray.magnet) continue;
+          if (!out && (ray.age ?? 0) < range) continue;
+
+          ray.moving = undefined;
+          ray.wave = undefined;
+          ray.heading = undefined;
+          ray.age = 0;
+          ray.fanned = false;
+          for (const bd of ray.boundaries) bd.polarity = Polarity.Neutral;
+        }
+      }
+
+      /**
+       * Huygens: every point of a front is itself a source of the front to
+       * come.
+       *
+       * Without this a pulse is twenty-six bullets. Moving is a swap with
+       * space, so the number of charges in a pulse is fixed at the number of
+       * directions the source had — while the shell they are supposed to make
+       * up needs more points the bigger it gets. Twenty-six points on a shell
+       * of radius one is a shell; twenty-six on a shell of radius ten is
+       * twenty-six rays with nothing in between, and two of those crossing
+       * almost never meet.
+       *
+       * So a charge in flight writes its polarity onto the neutral space
+       * around it that lies AHEAD — `spread` is how far round the front
+       * counts as ahead, as a dot product against where it is going — and
+       * each of those goes on in the direction it was written in. Nothing is
+       * created by this: a point that was space becomes a point that is a
+       * charge, and the population is what it was. What grows is how much of
+       * the space the wave passes through it is actually in.
+       */
+      const since = g._tickId - 1;
+
+      /*
+       * There was a rule here that cleared every cell touching a source, on
+       * the grounds that the space around a source belongs to it. It kept the
+       * sources emitting, and it is why the distance between them stops
+       * falling.
+       *
+       * A cell that is wiped clean every tick can never be holding a charge,
+       * so it can never be one of two that cancel, so it can never be
+       * destroyed. Each source was therefore wrapped in a shell of
+       * indestructible space, and two such shells with the sources inside
+       * them are a floor under how close the two can get — around six steps,
+       * which is exactly where it stopped. Nothing was wrong with the
+       * attraction; it had eaten everything it was allowed to eat.
+       *
+       * What the sources actually needed was not to be silted up by charges
+       * arriving back at them, and that is handled where it happens: a charge
+       * that moves into a source is absorbed by it (see `reflections` in
+       * `tick`). One rule, at the point of contact, and no protected region
+       * anywhere.
+       */
+
+      /**
+       * The sources emit FIRST, before the front below spreads.
+       *
+       * This is not a detail of ordering, it is what decides whether there is
+       * more than one pulse at all. A source can only write onto space, and
+       * the only space it ever has is the shell of points immediately around
+       * it — which is fresh every tick, because last tick's pulse moved off
+       * it and left new space behind. Spread the existing front first and
+       * that shell is claimed by the pulse that has just left it, tagged with
+       * the pulse before's name; the source then looks round, finds itself
+       * walled in by its own last emission, and emits nothing.
+       *
+       * What comes of that is one blob rather than a train of shells: a
+       * single wave id filling outwards, whose middle radius climbs much
+       * faster than one step a tick because it is thickening as well as
+       * travelling.
+       */
+      {
+        for (const nd of [...g.nodes]) {
+          for (const ray of [...nd]) {
+            if (!ray.magnet) continue;
+
+            // How often this one lets go of a shell, which is a property of
+            // the source rather than of a clock they all share — so two of
+            // them can be pulsing at different rates in the same world, and
+            // the ratio of those rates is a thing the arrangement can ask
+            // about.
+            const every = ray.beat ?? 1;
+            if (since % every !== 0) continue;
+
+            // Which emission of this one it is, and so where in its cycle it
+            // has got to.
+            const pulse = Math.floor(since / every);
+
+            const here = g.gridPos.get(nd);
+            if (!here) continue;
+
+            // One point per place, and only places next door.
+            //
+            // A source emits onto the space AROUND it, which is the couple of
+            // dozen points a step away. What it must not do is emit down
+            // every connection it happens to hold: annihilation hands what
+            // the dying points were carrying to whatever was behind them, and
+            // a charge that turns round and cancels next to its own source
+            // leaves all of it there. The source accumulates connections
+            // reaching right across the world, emits down all of them, and
+            // each emission makes more charges to come back and leave more —
+            // which is a few dozen a tick becoming a few thousand, and a
+            // universe several times the size it was seeded at.
+            const written = new Set<node>();
+
+            // A magnet that turns is somewhere else by now. Its axis steps
+            // round the plane an eighth of a turn every `turnEvery` ticks,
+            // one way or the other, and everything below reads it as it
+            // stands rather than as it was set.
+            if (ray.turning) {
+              const ring = ray.ring ?? TURN;
+              // `phase` is in turns, so a whole ring of them is what it
+              // counts against.
+              const step = Math.floor(since / turnEvery) * ray.turning
+                + Math.round((ray.phase ?? 0) * ring.length);
+
+              ray.axis = ring[((step % ring.length) + ring.length) % ring.length];
+            }
+
+            const emits = ray.emits ?? Polarity.Positive;
+
+            /**
+             * One turn of a source takes a turn's worth of ticks, whatever
+             * kind of turning it does.
+             *
+             * A source that rotates comes round through the eight directions
+             * of its plane, one a tick, and is back where it started after
+             * eight. A source that only flips over has two states rather than
+             * eight — and flipping between them every tick made its cycle
+             * four times shorter than the other's, which is not a difference
+             * in kind between the two sources but an accident of counting.
+             *
+             * What it cost was space. Each ring a wave lays down is one
+             * tick's emission, and a wave advances a cell a tick, so a cycle
+             * of two ticks puts the same charge every other cell: bands one
+             * cell wide with one cell between them, which no drawing can
+             * separate and which average to nothing the moment they are
+             * smoothed. Held for half a cycle each way, the same source lays
+             * down bands four cells wide with four cells between them, and
+             * they are bands you can see.
+             *
+             * The two then differ only in what the state is FOR. A flip is
+             * the same everywhere at once, so what it writes is rings. A
+             * rotation points somewhere, so what it writes is spirals. Same
+             * clock, same wave, same spacing — the difference is whether the
+             * source's state has a direction in it.
+             */
+            const cycle = ray.turning ? TURN.length : CYCLE;
+            const turn = pulse + (ray.phase ?? 0) * cycle;
+            const turned = ray.flips && ((turn % cycle) + cycle) % cycle >= cycle / 2;
+
+            const polarity = turned ? opposite(emits) : emits;
+
+            // Every direction at once: the pulse is written onto everything
+            // the source is connected to, and each point of it leaves along
+            // the direction it was written in. A boundary with nothing on the
+            // far side is a direction with nowhere yet to put anything, so it
+            // waits — the frontier grows by things moving into it, not by the
+            // source shouting past the end of the world.
+            for (const bd of [...ray.boundaries]) {
+              const facing = bd.target;
+              if (!facing) continue;
+
+              const there = facing.at.node;
+              if (there === nd || written.has(there)) continue;
+
+              const at = g.gridPos.get(there);
+              if (!at) continue;
+
+              // Next door, and not down some connection that closed up over
+              // the space it used to pass through.
+              if (Math.max(...here.map((v, i) => Math.abs(at[i] - v))) !== 1) continue;
+
+              written.add(there);
+
+              // Only space can be told what to be. Anything already going
+              // somewhere is somebody, and so is the other magnet.
+              if (there.some(r => r.moving || r.magnet)) continue;
+
+              const dir = g.direction(bd);
+              if (!dir) continue;
+
+              // Which pole this direction is out of. A source with no axis
+              // has no poles and puts the same thing out everywhere; one with
+              // an axis puts `polarity` out of the half facing along it and
+              // the opposite out of the half facing back, with the ring
+              // exactly across it emitting nothing — an equator, which is
+              // what makes it a magnet and not a lamp.
+              let out = polarity;
+
+              // How nearly this direction lies along the magnet's axis: +1
+              // straight out of the north pole, −1 out of the south, 0 on the
+              // equator between them.
+              const cos = ray.axis
+                ? dir.reduce((sum, v, i) => sum + v * (ray.axis![i] ?? 0), 0)
+                  / (Math.hypot(...ray.axis) || 1)
+                : 0;
+
+              if (ray.axis) {
+                if (Math.abs(cos) < 1e-9) continue; // the equator emits nothing
+
+                if (cos < 0) out = opposite(polarity);
+              }
+
+              /**
+               * A magnet that turns radiates into the plane it turns in.
+               *
+               * Its poles are in that plane and sweeping round it, so a
+               * direction lying in the plane is swept by north, then the
+               * equator, then south — the full stroke, once per revolution.
+               * A direction along the axis it turns ABOUT is perpendicular to
+               * the poles at every moment of the turn: it sits on the dipole's
+               * equator permanently, and the equator is exactly what emits
+               * nothing. In between, the further out of the plane you are,
+               * the less of the stroke reaches you.
+               *
+               * So the emission is thrown outward rather than all around, and
+               * a revolution lays down a disk. Which is not something added
+               * to make the picture flat — the poles being in the plane is
+               * what makes it flat, and the version without this was drawing
+               * a sphere for a source that has no business making one.
+               */
+              /**
+               * A turning magnet emits along its poles, not out of half of
+               * itself.
+               *
+               * Held still, a pole is a hemisphere: everything on the north
+               * side gets north's charge, and it does not matter that the
+               * side is a hundred and eighty degrees wide, because the thing
+               * is not going anywhere and every direction in that half is
+               * being given the same answer forever.
+               *
+               * Turning, the width is the whole problem. A hemisphere pointed
+               * one way overlaps almost entirely with a hemisphere pointed an
+               * eighth of a turn later, so consecutive pulses land on top of
+               * one another and what winds out from the source is not a
+               * pattern but a wash. Measured: the distance from the source
+               * tracks how long ago a pulse left, cleanly — but the direction
+               * of it does not track where the magnet was pointing at all,
+               * because a lobe spanning half the sky has no direction to
+               * speak of.
+               *
+               * Narrowed to the poles themselves, each pulse goes one way,
+               * the next goes an eighth of a turn round from it, and the
+               * locus of them is an arm winding outward. Which is what a
+               * lighthouse is, and a pulsar, and why the beam has to be a
+               * beam for there to be a sweep at all.
+               */
+              /*
+               * Every direction, here as everywhere else.
+               *
+               * There was a cone here, narrowing a turning magnet's emission
+               * to a beam near its poles, on the reasoning that a lighthouse
+               * needs a beam to have a sweep. It does — but this is not a
+               * lighthouse, and the sweep does not have to be made of where
+               * the pulse went.
+               *
+               * A pulse goes everywhere, as it does for every other source in
+               * this article. What rotates is WHICH WAY ROUND it goes: the
+               * half of the sky facing the north pole gets one charge and the
+               * half facing south gets the other, and the line between those
+               * halves comes round an eighth of a turn every tick. So the
+               * charge a given direction receives alternates as the poles
+               * sweep past it, and the boundary between the two — traced
+               * outward through everything already in flight, each shell
+               * having been laid down with the magnet pointing somewhere
+               * slightly different — is a spiral. Not a spiral anything
+               * travels along. A spiral in the arrangement of what was
+               * emitted, which is what a rotating dipole actually makes.
+               */
+
+              for (const r of there)
+                for (const x of r.boundaries) x.polarity = out;
+
+              facing.at.moving = g.along(facing.at, dir, 1);
+
+// Nothing travels slower than anything else: a charge is a
+              // charge, and it leaves at one step a tick like everything
+              // here does.
+              
+
+              // Which emission this is: one pulse per source per turn of it,
+              // which is what makes a pulse a thing with a surface.
+              facing.at.wave = pulse * count + (ray.source ?? 0);
+
+              // And whose it is, which for a turning source is what says
+              // which arm a charge is on — see the spiral pass in the
+              // renderer.
+              facing.at.source = ray.source;
+              facing.at.turning = ray.turning;
+
+              g.stats.emitted++;
+            }
+          }
+        }
+      }
+
+      /**
+       * Once each, and not straight away.
+       *
+       * Concentric shells one step apart, one per tick, moving one step per
+       * tick, are exactly the shells that tile a ball — so filling every one
+       * of them fills the ball completely, and a ball with no space in it is
+       * a ball in which nothing can move, since moving is trading places with
+       * space. That is not a near miss to be tuned around; unit shells at
+       * every radius sum to the volume they sit in, and it is why spreading
+       * on every tick froze the field solid.
+       *
+       * What is affordable is a fixed number of points per shell rather than
+       * a filled one: each ray fans out ONCE, into the ring of directions
+       * across its path, and its children never fan again. A pulse is then
+       * twenty-six rays and their fan — a couple of hundred points — however
+       * far out it gets.
+       *
+       * And it waits until `fanAt` before doing it. A shell of radius two has
+       * only a few dozen cells in it and is already as full as it can be, so
+       * fanning immediately puts every child straight into the crush around
+       * the source, walls the source in, and stops the emission. Waiting
+       * until the shell is wide enough to have somewhere to put them spends
+       * the same points where there is room for them — and where they are
+       * wanted, since what a shell is for is meeting the other one, and that
+       * happens out at the distance between the sources rather than next
+       * door.
+       */
+      if (spread <= 1) {
+        const front: { ray: Ray, dir: number[], polarity: Polarity, wave?: number }[] = [];
+
+        for (const nd of g.nodes) {
+          for (const ray of nd) {
+            if (ray.magnet || !ray.moving) continue;
+            if (ray.moving.polarity === Polarity.Neutral) continue;
+
+            // Age is counted in `tick`, once, for everything in flight.
+            if (ray.fanned || (ray.age ?? 0) < fan) continue;
+
+            const dir = g.direction(ray.moving);
+            if (!dir) continue;
+
+            ray.fanned = true;
+            front.push({ ray, dir, polarity: ray.moving.polarity, wave: ray.wave });
+          }
+        }
+
+        for (const { ray, dir, polarity, wave } of front) {
+          for (const bd of ray.boundaries) {
+            const facing = bd.target;
+            if (!facing) continue;
+
+            const there = facing.at.node;
+            if (there === ray.node) continue;
+            if (there.some(r => r.moving || r.magnet)) continue;
+
+            const d = g.direction(bd);
+            if (!d) continue;
+
+            // BESIDE us — not behind, and not ahead either.
+            //
+            // Behind is everywhere the wave has already been, and filling
+            // that in is a wave that never leaves anywhere. Ahead is where we
+            // are going ourselves, and filling that in is a wave that thickens
+            // into a solid ball instead of staying a surface. What is left is
+            // the ring of directions across our path, which is the front
+            // itself: the shell grows sideways, into the room a bigger shell
+            // has that a smaller one didn't.
+            const along = d.reduce((sum, v, i) => sum + v * dir[i], 0);
+            if (along < spread || along > 0.9) continue;
+
+            for (const r of there)
+              for (const x of r.boundaries) x.polarity = polarity;
+
+            // And it leaves in the direction between ours and its own, so the
+            // front fans out as it goes rather than travelling as a sheaf of
+            // parallel lines. Twenty-six directions repeatedly split between
+            // is how a lattice with twenty-six of them makes a round shell.
+            const bias = dir.map((v, i) => v + d[i]);
+
+            facing.at.moving = g.along(facing.at, bias, 1);
+            facing.at.wave = wave; // still the same pulse, spread wider
+            facing.at.source = ray.source;
+            facing.at.turning = ray.turning;
+            facing.at.age = ray.age;
+
+            // And it travels at the speed its parent does.
+            //
+            // Without this a fanned charge is quick and the charge it came
+            // from is slow — three times as quick, where the source is one
+            // that turns — so it runs out through the shell ahead of it and
+            // the one ahead of that, carrying its own polarity into the
+            // middle of theirs. Every shell ends up holding both charges at
+            // once, mixed, and the neat alternation that IS the spiral is
+            // stirred out of the field before anything gets to draw it.
+            facing.at.mass = ray.mass;
+
+            // Already fanned, as far as it is concerned. Otherwise each child
+            // fans in turn and the shell doubles every tick until it has
+            // filled everything, which is where this started.
+            facing.at.fanned = true;
+            facing.at.age = ray.age;
+          }
+        }
+      }
+    };
+
+    return graph;
+  }
+
+  /**
+   * The same universe with room in it: n charges in a row, each with a
+   * polarity and a direction along the line, every point connected to the
+   * next.
+   *
+   * A pair can only do the one thing its two ends do to each other. A line
+   * of three or four has an inside — charges with something on both sides of
+   * them — so what one interaction leaves behind is what the next one has to
+   * work with. Annihilations close the line up behind them, movement trades
+   * places with the space between, and the ends grow more line to move into.
+   *
+   * Both ends carry an OUTWARD boundary (no target, pointing off the end).
+   * Without it an end moving outwards would have nowhere to be moving — it is
+   * at an actual boundary of the structure, and moves by making more of it.
+   */
+  static line(sides: LineSide[]): Graph {
+    const graph = new Graph();
+    graph.dims = 3;
+    graph.ringRadius = 1;
+
+    const n = sides.length;
+    const lefts: Boundary[] = [];
+    const rights: Boundary[] = [];
+
+    sides.forEach((side, i) => {
+      const nd: node = [];
+      const ray = new Ray(nd);
+      ray.boundaries = []; // drop the constructor's default
+
+      const left = new Boundary(ray);
+      left.polarity = side.polarity;
+      if (i === 0) left.outward = [-1, 0, 0];
+
+      const right = new Boundary(ray);
+      right.polarity = side.polarity;
+      if (i === n - 1) right.outward = [1, 0, 0];
+
+      ray.boundaries.push(left, right);
+      ray.moving = side.moving === 'left' ? left : right;
+
+      lefts.push(left);
+      rights.push(right);
+
+      graph.nodes.push(nd);
+      graph.setPos(nd, [i - (n - 1) / 2, 0, 0]);
+    });
+
+    for (let i = 0; i + 1 < n; i++) {
+      rights[i].target = lefts[i + 1];
+      lefts[i + 1].target = rights[i];
+    }
+
+    return graph;
+  }
+
+  /**
+   * A deep copy: new nodes, rays and boundaries, with every `target` and
+   * `moving` reference remapped onto the copies. Ticking the original leaves
+   * the clone untouched, which is what lets a run be frozen state by state.
+   *
+   * Rays and boundaries are built with `Object.create` rather than `new`,
+   * because their constructors have side effects — a Ray registers itself on
+   * its node and grows a default boundary — that would corrupt the copy.
+   */
+  clone(): Graph {
+    const graph = new Graph();
+    graph.dims = this.dims;
+    graph.ringRadius = this.ringRadius;
+    graph._tickId = this._tickId;
+    graph.onTick = this.onTick;
+    graph.relax = this.relax;
+    graph.wander = this.wander;
+    graph.sealed = this.sealed;
+    graph.focus = this.focus;
+    graph.events = this.events.map(e => ({ ...e, at: e.at.slice() }));
+    graph.history = this.history.slice();
+
+    const rays = new Map<Ray, Ray>();
+    const boundaries = new Map<Boundary, Boundary>();
+
+    for (const nd of this.nodes) {
+      const copy: node = [];
+
+      for (const ray of nd) {
+        const r: Ray = Object.create(Ray.prototype);
+        r.id = ray.id;
+        r.node = copy;
+        r.boundaries = [];
+        r.magnet = ray.magnet;
+        r.emits = ray.emits;
+        r.phase = ray.phase;
+        r.source = ray.source;
+        r.wave = ray.wave;
+        r.credit = ray.credit;
+        r.mass = ray.mass;
+        r.age = ray.age;
+        r.fanned = ray.fanned;
+        r.axis = ray.axis?.slice();
+        r.turning = ray.turning;
+        r.ring = ray.ring;
+        r.heading = ray.heading?.slice();
+        rays.set(ray, r);
+        copy.push(r);
+
+        for (const bd of ray.boundaries) {
+          const b: Boundary = Object.create(Boundary.prototype);
+          b.polarity = bd.polarity;
+          b.at = r;
+          if (bd.outward) b.outward = bd.outward.slice();
+          boundaries.set(bd, b);
+          r.boundaries.push(b);
+        }
+      }
+
+      graph.nodes.push(copy);
+
+      const pos = this.gridPos.get(nd);
+      if (pos) graph.setPos(copy, pos.slice());
+    }
+
+    // Second pass — every boundary now exists, so the references between
+    // them can be resolved.
+    for (const nd of this.nodes) {
+      for (const ray of nd) {
+        const r = rays.get(ray)!;
+        if (ray.moving) r.moving = boundaries.get(ray.moving);
+
+        ray.boundaries.forEach((bd, i) => {
+          if (bd.target) r.boundaries[i].target = boundaries.get(bd.target);
+        });
+      }
+    }
+
+    return graph;
+  }
+
+  private layoutCache?: Map<node, Vec>;
+  private dirty = true;
+
+  get layout(): Map<node, Vec> {
+    // A relaxed layout is never done: it eases towards the shape the
+    // connections are asking for, and is recomputed every time it is looked
+    // at rather than once per tick, so what the structure does to it is
+    // something that happens over frames instead of in one jump.
+    if (this.relax) return this.relaxedLayout();
+
+    if (!this.layoutCache || this.dirty) {
+      this.layoutCache = this.sphereLayout({ scale: LATTICE_STEP });
+      this.dirty = false;
+    }
+
+    return this.layoutCache;
+  }
+
+  /**
+   * The last relaxed layout, which the next one starts from — and, with it,
+   * the working set the solve runs on.
+   *
+   * This is cached across frames on purpose. The connections only change when
+   * the world does, which is once a tick, while the solve runs every frame:
+   * rebuilding the list of them sixty times a second means allocating some
+   * eighty thousand of them sixty times a second, for a list that was already
+   * correct. So the structure is rebuilt when the structure changes, and in
+   * between, the passes run over what is already there — mutating the
+   * position vectors in place, which is also why the map handed to the
+   * renderer doesn't have to be rebuilt either.
+   */
+  private relaxed?: {
+    at: Map<node, Vec>;
+    P: Vec[];
+    links: { i: number, j: number, rest: number, weight: number }[];
+    correction: Vec[];
+    asked: number[];
+  };
+
+  /**
+   * Where the points are, if where they are is decided by what they are
+   * connected to.
+   *
+   * Every connection wants to be one step long — one step in ITS direction,
+   * so a face connection wants 1 and a corner connection √3, which is what
+   * keeps a lattice wired in all twenty-six directions from crumpling. A
+   * connection whose two ends are three cells apart in coordinates still
+   * wants to be one step, because the two cells in between were annihilated
+   * and are not anywhere any more. That single sentence is the gravity in
+   * this model: destroyed space is shorter space, and shorter space pulls
+   * whatever is on either side of it together.
+   *
+   * It is a positional solve rather than a force integration — each pass
+   * moves every point by the average of what its connections are asking of
+   * it — so there is no velocity to blow up and no timestep to tune. It
+   * cannot overshoot at stiffness ≤ 1, which matters when the thing being
+   * solved gains and loses points every tick.
+   */
+  relaxedLayout(
+    {
+      scale = LATTICE_STEP,
+      iterations = 3,
+      stiffness = 0.65,
+      adjacency = 12,
+    }: {
+      scale?: number, iterations?: number,
+      stiffness?: number, adjacency?: number,
+    } = {},
+  ): Map<node, Vec> {
+    const dims = this.dims;
+
+    if (!this.dirty && this.relaxed) {
+      this.solve(this.relaxed, iterations, stiffness, dims);
+
+      return this.relaxed.at;
+    }
+
+    this.dirty = false;
+
+    const previous = this.relaxed?.at;
+    const list = this.nodes;
+
+    const index = new Map<node, number>();
+    list.forEach((nd, i) => index.set(nd, i));
+
+    const P: Vec[] = new Array(list.length);
+    const fresh: number[] = [];
+
+    for (let i = 0; i < list.length; i++) {
+      const was = previous?.get(list[i]);
+
+      if (was) { P[i] = was; continue; }
+
+      fresh.push(i);
+      const grid = this.gridPos.get(list[i]);
+      P[i] = grid && grid.length ? grid.map(v => v * scale) : new Array(dims).fill(0);
+    }
+
+    // A point that has only just come into being appears where its neighbours
+    // already are, one step off them in the direction its coordinate says it
+    // lies — not at the coordinate itself. It was put down in space that has
+    // already been bent, and dropping it in at the unbent position would be a
+    // kick delivered every time anything moves.
+    const isFresh = new Set(fresh);
+
+    for (const i of fresh) {
+      const here = this.gridPos.get(list[i]);
+      if (!here) continue;
+
+      const sum = new Array(dims).fill(0);
+      let n = 0;
+
+      for (const ray of list[i]) {
+        for (const bd of ray.boundaries) {
+          const other = bd.target?.at.node;
+          if (!other) continue;
+
+          const j = index.get(other);
+          if (j === undefined || isFresh.has(j)) continue;
+
+          const there = this.gridPos.get(other);
+          if (!there) continue;
+
+          const step = latticeStep(here.map((v, k) => v - there[k]));
+          if (!step) continue;
+
+          for (let k = 0; k < dims; k++) sum[k] += P[j][k] + step[k] * scale;
+          n++;
+        }
+      }
+
+      if (n) P[i] = sum.map(v => v / n);
+    }
+
+    /**
+     * Every connection, once, with the length it is asking for and how loudly
+     * it asks. Built up front rather than per pass, since it is the same list
+     * every pass.
+     *
+     * `adjacency` is how much more a connection that spans destroyed space
+     * counts than an ordinary one, per cell it spans. At 1 they count the
+     * same, and the picture is the honest compromise: two sources that have
+     * eaten their way to each other are held apart anyway, because each of
+     * them has twenty-six other connections all quite happy where they are,
+     * and one voice against twenty-six moves nothing.
+     *
+     * Above 1 the picture takes a side. It says that a connection standing
+     * where sixteen points used to be is a stronger claim about what is next
+     * to what than a connection that has never had anything happen to it —
+     * that adjacency arrived at by destroying everything in between should
+     * win against the undisturbed shape of the lattice around it.
+     *
+     * That is a decision about the drawing and not a law of the model, and it
+     * is worth being plain that nothing derives it. What it buys is a picture
+     * in which two things that have become neighbours are drawn as
+     * neighbours, which is the thing the whole exercise is trying to show and
+     * which the even-handed version will not show at any zoom.
+     */
+    const links: { i: number, j: number, rest: number, weight: number }[] = [];
+
+    for (let i = 0; i < list.length; i++) {
+      const here = this.gridPos.get(list[i]);
+
+      for (const ray of list[i]) {
+        for (const bd of ray.boundaries) {
+          const other = bd.target?.at.node;
+          if (!other) continue;
+
+          const j = index.get(other);
+          if (j === undefined || j <= i) continue; // once per pair
+
+          const there = this.gridPos.get(other);
+          const offset = here && there ? here.map((v, k) => v - there[k]) : undefined;
+          const step = offset && latticeStep(offset);
+
+          // How far apart the two ends still are in coordinates — which, for
+          // a connection, is how much has been taken out from between them.
+          const spans = offset ? Math.max(...offset.map(Math.abs)) : 1;
+
+          links.push({
+            i, j,
+            rest: (step ? Math.hypot(...step) : 1) * scale,
+            weight: 1 + Math.max(spans - 1, 0) * adjacency,
+          });
+        }
+      }
+    }
+
+    const at = new Map<node, Vec>();
+    for (let i = 0; i < list.length; i++) at.set(list[i], P[i]);
+
+    this.relaxed = {
+      at, P, links,
+      correction: list.map(() => new Array(dims).fill(0)),
+      asked: new Array(list.length).fill(0),
+    };
+
+    this.solve(this.relaxed, iterations, stiffness, dims);
+
+    return at;
+  }
+
+  // One or more passes of the solve above, over a working set that is already
+  // built. Positions are moved in place, so everything holding a reference to
+  // one — the map the renderer reads, above all — is up to date by the time
+  // this returns.
+  private solve(
+    { P, links, correction, asked }: NonNullable<Graph['relaxed']>,
+    iterations: number,
+    stiffness: number,
+    dims: number,
+  ) {
+    for (let pass = 0; pass < iterations; pass++) {
+      for (let i = 0; i < P.length; i++) {
+        correction[i].fill(0);
+        asked[i] = 0;
+      }
+
+      for (const { i, j, rest, weight } of links) {
+        let lengthSq = 0;
+
+        for (let k = 0; k < dims; k++) {
+          const d = P[j][k] - P[i][k];
+          lengthSq += d * d;
+        }
+
+        const length = Math.sqrt(lengthSq);
+        if (length < 1e-6) continue;
+
+        // Half the error each, so neither end is privileged over the other.
+        const pull = ((length - rest) / length) * 0.5 * stiffness * weight;
+
+        for (let k = 0; k < dims; k++) {
+          const d = (P[j][k] - P[i][k]) * pull;
+          correction[i][k] += d;
+          correction[j][k] -= d;
+        }
+
+        // A weighted average, so a connection that counts for more moves its
+        // ends more — rather than a louder constraint simply overshooting,
+        // which is what an unweighted divisor would turn it into.
+        asked[i] += weight;
+        asked[j] += weight;
+      }
+
+      for (let i = 0; i < P.length; i++) {
+        const n = asked[i] || 1;
+        for (let k = 0; k < dims; k++) P[i][k] += correction[i][k] / n;
+      }
+    }
+  }
+
+  /**
+   * Deterministic cube→sphere layout.
+   *
+   * Each cell has a cube position (gridPos · scale — a crisp lattice, so
+   * the 3×3×3 seed reads as a clean cube) and a sphere position (the same
+   * direction but at a radius set by its Chebyshev ring, so corners get
+   * pulled in to share a shell). The two are blended by how far the graph
+   * has grown: pure cube at ring 1, easing to a pure sphere by MORPH_RINGS.
+   * So it starts as a nice cube and rounds into a sphere as it expands.
+   * Same graph => same output every run (no forces, no iteration).
+   */
+  sphereLayout({ scale = 50 }: { scale?: number } = {}): Map<node, Vec> {
+    const pos = new Map<node, Vec>();
+
+    const MORPH_RINGS = 6;
+    const raw = Math.min(Math.max((this.ringRadius - 1) / (MORPH_RINGS - 1), 0), 1);
+    const t = raw * raw * (3 - 2 * raw); // smoothstep cube→sphere
+
+    for (const node of this.nodes) {
+      const grid = this.gridPos.get(node);
+
+      if (!grid) {
+        pos.set(node, [0, 0, 0]);
+        continue;
+      }
+
+      const ring = Math.max(...grid.map(v => Math.abs(v)));
+
+      if (ring === 0) {
+        pos.set(node, grid.map(() => 0));
+        continue;
+      }
+
+      const euclidean = Math.hypot(...grid) || 1;
+      const sphereR = ring * scale;
+
+      pos.set(node, grid.map(v => {
+        const cube = v * scale;
+        const sphere = (v / euclidean) * sphereR;
+        return cube * (1 - t) + sphere * t;
+      }));
+    }
+
+    return pos;
+  }
+
+  invalidateLayout() {
+    this.dirty = true;
+  }
+
+}
+export type node = Ray[]
+
+let NEXT_ID = 0;
+
+export class Ray {
+  id: number;
+  boundaries: Boundary[] = [];
+
+  // The directional movement of this ray: the boundary (one of its own) it
+  // is currently moving towards. It heads towards the node on the far side
+  // of that boundary's connection (moving.target's node).
+  moving?: Boundary;
+
+  // A source: something that goes on writing a charge onto the space around
+  // it, tick after tick, rather than being written once and then only ever
+  // interacting. Nothing in the rules makes one — the rules have no way to
+  // begin anything — so it is the seed's doing, and the only thing the rules
+  // have to know about it is that it is never mistaken for space.
+  //
+  // `emits` is the polarity it puts out, and `phase` is where in its cycle it
+  // starts, IN TURNS — the same unit the closed form measures it in, so that
+  // half a turn out of step means the same thing on both sides. It is the
+  // only thing one source can be against another.
+  magnet?: boolean;
+  emits?: Polarity;
+  phase?: number;
+
+  // How often it lets go of a shell, in ticks, and whether it turns its poles
+  // over between one and the next. Both are properties of the source rather
+  // than of the clock every source shares, so two of them in one world can be
+  // doing different things at different rates.
+  beat?: number;
+  flips?: boolean;
+
+  // Which way round it is: `emits` out of the half pointing this way, the
+  // opposite out of the half pointing back, nothing across the middle. Absent
+  // for a source with no sides, which puts the same thing out everywhere.
+  axis?: number[];
+
+  // Which way the axis comes round, an eighth of a turn at a time, or nothing
+  // for a magnet that is held still, and the ring of directions it comes
+  // round through. See `turnRing`.
+  turning?: number;
+  ring?: number[][];
+
+  // What a step costs this ray, as a multiple of the step's own length. One
+  // for everything the rules make; more for a source, which is the only thing
+  // here heavy enough to be worth pushing. See `MAGNET_MASS`.
+  mass?: number;
+
+  // Which source, for a source; which emission of it, for a charge that came
+  // out of one. The dynamics never read either — a charge is a charge and
+  // what it does depends on nothing but its polarity and where it is going.
+  // It is bookkeeping for the picture: what makes one pulse one pulse, and
+  // therefore something that can be drawn as a surface instead of as a few
+  // thousand unrelated points.
+  source?: number;
+  wave?: number;
+
+  // How many ticks a charge has been in flight, and whether it has yet fanned
+  // out into the room a bigger shell has that a smaller one hadn't. See the
+  // Huygens step in `Graph.sources`.
+  age?: number;
+  fanned?: boolean;
+
+  /**
+   * The way it is going in the large, which is not the same as the step it is
+   * taking this tick.
+   *
+   * Wandering takes a direction apart — a ray heading along (1,1,1) may spend
+   * this move going (1,0,0) instead — and without somewhere to keep the whole
+   * direction, taking it apart destroys it: the step becomes the direction,
+   * its only piece is itself, and the ray is committed to an axis forever
+   * after one unlucky move. Kept here, the pieces are only ever a detour, and
+   * the way it was going is still there to come back to.
+   */
+  heading?: number[];
+
+  // How much of its next step it has paid for. A step costs its own length
+  // and a tick pays one, so a ray going along an axis is always ready and one
+  // going through a corner is ready five times in nine — which is what makes
+  // every direction travel at the same speed. See the movement half of
+  // `tick`.
+  credit?: number;
+
+  constructor(
+    public node: node, // reassignable: nodes merge on annihilation
+  ) {
+    this.id = NEXT_ID++;
+
+    node.push(this);
+
+    this.boundaries.push(new Boundary(this));
+  }
+}
+
+export class Boundary {
+  polarity: Polarity = Polarity.Positive;
+
+  // The boundary on the neighbouring node this one connects to / points at.
+  target?: Boundary;
+
+  // A boundary with no target has no neighbour to be drawn towards. `outward`
+  // gives it a bare direction (in grid units) so it can still be rendered —
+  // and so a ray has somewhere to move that ISN'T one of its connections,
+  // which is what "moving away from this connection" means.
+  outward?: number[];
+
+  constructor(public at: Ray) { }
+}
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
new file mode 100644
index 0000000..4d3b8d0
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
@@ -0,0 +1,44 @@
+import Post, {
+  Arc, BlueprintIcons16, BlueprintIcons20, JetBrainsMono, PaperProps, Section,
+  useCounter,
+} from "../../../lib/post/Post";
+import { RAY_CALCULI_AND_PHYSICS } from "../../references";
+import { MODELS } from "./models";
+import { Models } from "./views";
+
+/**
+ * Ray calculi and physics.
+ *
+ * The article is a list of arrangements and nothing else. Each one is a
+ * `Model` (see `model.ts`): what is in the world, said once, and drawn every
+ * way it can be read — run on a lattice, written down as a closed form, or
+ * both side by side where both apply.
+ *
+ * Which means there is nothing to edit here. To change an arrangement, add
+ * one, or change the order they are read in, edit `models.ts`; to change what
+ * an arrangement MEANS, edit `discrete.ts` and `continuous.tsx`, which are
+ * the two readings, and which share their vocabulary through `lattice.ts` so
+ * that neither can drift from the other by redefining a term.
+ */
+const RayCalculiAndPhysics = () => {
+  const referenceCounter = useCounter();
+
+  const paper: Omit<PaperProps, 'children'> = {
+    ...RAY_CALCULI_AND_PHYSICS.reference,
+    pdf: {
+      fonts: [JetBrainsMono, BlueprintIcons20, BlueprintIcons16],
+    },
+    Reference: (props: {}) => (<></>),
+    references: referenceCounter,
+  };
+
+  return <Post {...paper}>
+    <Arc head="">
+      <Section head="">
+        <Models models={MODELS} />
+      </Section>
+    </Arc>
+  </Post>;
+};
+
+export default RayCalculiAndPhysics;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts
new file mode 100644
index 0000000..e234cd7
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts
@@ -0,0 +1,304 @@
+/**
+ * The vocabulary both readings of this article are written in.
+ *
+ * There are two models here — a lattice of points run one tick at a time, and
+ * the closed form of what that lattice makes — and the whole point of putting
+ * them side by side is that they are the same claim said twice. That only
+ * holds if they agree on their terms: what a charge is, how many directions a
+ * point has, how long a turn takes. Those terms live here, so that neither
+ * side can quietly drift from the other by redefining one of them.
+ */
+
+export type Vec = number[];
+
+/**
+ * What a boundary carries.
+ *
+ * Neutral is what space is when nothing has happened to it yet: it is what
+ * gets instantiated as something moves — ahead of it at a boundary of the
+ * structure, and behind it as it goes — rather than a charge drawn at random.
+ */
+export enum Polarity {
+  Positive,
+  Negative,
+  Neutral
+}
+
+export const opposite = (p: Polarity): Polarity =>
+  p === Polarity.Positive ? Polarity.Negative
+    : p === Polarity.Negative ? Polarity.Positive
+      : Polarity.Neutral;
+
+//TODO Should probably be something oscillating instead of random
+export const randomPolarity = () =>
+  Math.random() < 0.5 ? Polarity.Positive : Polarity.Negative;
+
+// A fresh order, so that what interacts with what is a draw rather than an
+// artefact of the order things happen to sit in.
+export const shuffle = <T,>(arr: T[]): T[] => {
+  const out = arr.slice();
+
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [out[i], out[j]] = [out[j], out[i]];
+  }
+
+  return out;
+};
+
+// World units per lattice step. Shared by the layout and by the renderer,
+// which needs it to place boundaries that have a direction but no neighbour.
+export const LATTICE_STEP = 50;
+
+// How far along its connection a boundary is drawn, as a fraction. Both ends
+// draw one, so they meet with a gap of 1 - 2×this in between. The viewport
+// fit uses it too, so that what it measures is what gets drawn.
+export const BOUNDARY_STUB = 0.25;
+
+/**
+ * The direction a lattice offset names, as the shortest step that goes that
+ * way: every component in {-1, 0, 1}.
+ *
+ * (1,0,0) is already one step. (3,0,0) is the same direction, three steps at
+ * a time — which is what a connection looks like once the space it used to
+ * pass through has been annihilated out of it. (2,2,0) is the diagonal
+ * (1,1,0).
+ *
+ * This is what keeps a direction a direction rather than a distance. It is
+ * also what a boundary with no neighbour has to hold: `outward` is a way to
+ * go, and a way to go is one step, however far apart the last two points that
+ * went that way happened to end up.
+ */
+export function latticeStep(offset: number[]): number[] | undefined {
+  const norm = Math.max(...offset.map(Math.abs));
+  if (!norm) return undefined;
+
+  return offset.map(v => Math.round(v / norm));
+}
+
+// The directions that lie along an axis: the 2d faces of a cell. A lattice
+// wired only with these is what anything moving along a line ever needs.
+export function axes(dims: number): number[][] {
+  const out: number[][] = [];
+
+  for (let axis = 0; axis < dims; axis++)
+    for (const dir of [-1, 1]) {
+      const v = new Array(dims).fill(0);
+      v[axis] = dir;
+      out.push(v);
+    }
+
+  return out;
+}
+
+/**
+ * Every way out of a point: all 3^d − 1 non-zero offsets with components in
+ * {-1, 0, 1}. In 2D that is the eight directions of a compass rose; in 3D the
+ * twenty-six ways off a cell — six through a face, twelve through an edge,
+ * eight through a corner.
+ *
+ * This is what "360°" is when space is discrete. Not a circle cut into 360
+ * pieces: a lattice has exactly as many directions as a point has neighbours,
+ * and the honest thing is to take all of them rather than the six that happen
+ * to line up with the axes. A point wired only to its faces cannot be moved
+ * through diagonally, so a wave leaving it can only ever go six ways, and
+ * anything built on that is a cross rather than a sphere.
+ *
+ * The price is that the directions are not the same length — a face step
+ * covers 1, an edge step √2, a corner step √3 — so a pulse emitted into all
+ * of them at once, one step per tick, is a cube shell and not a round one.
+ * That IS the sphere of this space: the set of points one move away.
+ */
+export function directions(dims: number): number[][] {
+  const out: number[][] = [];
+
+  (function build(prefix: number[]) {
+    if (prefix.length === dims) {
+      if (prefix.some(v => v !== 0)) out.push(prefix);
+      return;
+    }
+
+    for (const v of [-1, 0, 1]) build([...prefix, v]);
+  })([]);
+
+  return out;
+}
+
+/**
+ * A turn, in a space that has eight directions to a plane.
+ *
+ * These are the in-plane directions in order round the circle, so stepping
+ * along the list by one is a rotation of an eighth of a turn and stepping by
+ * eight is back where it started. It is the whole of what "rotating" can mean
+ * on a lattice: there is no angle between neighbouring directions to
+ * subdivide further, and a magnet whose axis moved by less than this would
+ * not have moved at all.
+ *
+ * A turn is only ever a turn in a plane, and a plane is two directions to
+ * turn between. Given those, this walks the circle they span in eighths and
+ * rounds each step onto the nearest direction the lattice actually has — so a
+ * magnet can come round in the xy-plane, or the xz, or about any diagonal,
+ * and the axis it sweeps is the axis it was given rather than the one the
+ * code was written with.
+ *
+ * The default is x towards y, which is the plane sources are laid out in, so
+ * a pair of them turn in the plane they face each other across.
+ */
+export function turnRing(u: number[] = [1, 0, 0], v: number[] = [0, 1, 0]): number[][] {
+  const out: number[][] = [];
+
+  for (let k = 0; k < 8; k++) {
+    const a = (k / 8) * Math.PI * 2;
+    const c = Math.cos(a), s = Math.sin(a);
+
+    const dir = u.map((x, i) => x * c + (v[i] ?? 0) * s);
+    const step = latticeStep(dir.map(x => (Math.abs(x) < 0.3827 ? 0 : x)));
+
+    if (step) out.push(step);
+  }
+
+  return out;
+}
+
+export const TURN = turnRing();
+
+/**
+ * How many ticks a source takes to come back to what it was doing.
+ *
+ * The same for every kind of source, which is the whole point of it. A
+ * rotation through the eight directions of a plane and a flip held half the
+ * time each way are both one cycle, and both lay their structure down at the
+ * same spacing: a wave advances a cell a tick, so a cycle of this many ticks
+ * puts the same charge every this many cells — bands half that wide with the
+ * same again between them, whether those bands come out as rings or as
+ * spirals.
+ */
+export const CYCLE = TURN.length;
+
+// The same rate in radians, which is what the closed form wants: a turn per
+// CYCLE ticks, because the lattice has eight directions to a plane and takes
+// one step of them a tick.
+export const SPIN = (Math.PI * 2) / CYCLE;
+
+/**
+ * One source, said once for both readings of it.
+ *
+ * This is the whole of what an arrangement in this article IS. The lattice
+ * builds a point out of it and lets the tick rules have it (`Graph.sources`);
+ * the closed form turns it into a cosine and evaluates that (`emitterOf`).
+ * Neither adds anything of its own — if the two pictures disagree, they
+ * disagree about what these rules make and not about what was set up.
+ *
+ * Which is why the units are stated here rather than at either end. `phase`
+ * is in TURNS, not in radians and not in ticks, because a turn is the one
+ * thing both models agree on the length of. `drift` and `beat` are in cells
+ * and ticks, which the lattice measures directly and the closed form is
+ * calibrated against.
+ */
+export type Source = {
+  // Where it is, in cells from the middle. Shorter than the world has
+  // dimensions is allowed and means nought in the rest.
+  at: number[];
+
+  // What it puts out of the half of itself facing `axis` — the opposite comes
+  // out of the half facing back.
+  emits?: Polarity;
+
+  /**
+   * Which way round it is, if it is a magnet rather than a lamp.
+   *
+   * Without this a source puts the same charge out in every direction and
+   * turns the lot over together — something that alternates, but with no
+   * sides to it. A magnet has sides: `emits` goes out of the half pointing
+   * along this, its opposite out of the half pointing against, and the ring
+   * exactly across it puts out nothing at all.
+   *
+   * It matters for two magnets facing each other because it decides what
+   * arrives. Both given the same axis, the face of one that looks at the
+   * other is its north and the face looking back is the other's south — so
+   * what crosses the gap is opposite to what it meets, every tick, and
+   * opposite charges meeting is the one event that destroys space.
+   */
+  axis?: number[];
+
+  /**
+   * Which way round it turns, if it turns: +1 or −1, and nothing for a source
+   * held still.
+   *
+   * Flipping is the other thing a source can do, and the difference is what
+   * separates a ring from a spiral. A flip is the same everywhere at once —
+   * north becomes south on the spot, nothing has moved — so what it writes is
+   * shells. Turning brings the axis itself round, so a direction that was
+   * looking at the north pole is looking at the equator a moment later and at
+   * the south pole after that: the alternation is a consequence of the thing
+   * going round rather than a property stipulated of it, and it has a
+   * handedness, so two sources can turn the same way or against each other.
+   *
+   * A turning source therefore needs no flip, and does not get one — see
+   * `flips`.
+   */
+  turning?: 1 | -1;
+
+  // Whether it alternates at all. A source that turns is already alternating
+  // and defaults to off; one that does not is a source with nothing to make a
+  // wave out of unless it flips, and defaults to on. Off for both is a magnet
+  // simply held, which puts out one steady stream per pole.
+  flips?: boolean;
+
+  // Where in the cycle it starts, in turns. The only thing one source can be
+  // against another, and the reason two of them meeting are alike or
+  // opposite.
+  phase?: number;
+
+  // How it is already going, in cells a tick. Nothing here accelerates
+  // anything, so this is a course rather than an initial condition: it keeps
+  // going that way at that pace. On the lattice the pace is a mass (see
+  // `massFor`), which is the only thing there that decides how fast anything
+  // is.
+  drift?: number[];
+
+  // Ticks between one pulse and the next. One is a source that never pauses.
+  beat?: number;
+
+  // The plane it turns in, as the two directions it turns between. Anything
+  // in three dimensions, not only the one the code happens to be written
+  // around — two sources can be set turning in different planes, which is a
+  // thing only a 3D world can be asked.
+  plane?: [number[], number[]];
+};
+
+// How fast a source is going, in cells a tick.
+export const speedOf = (s: Source) => s.drift ? Math.hypot(...s.drift) : 0;
+
+/** What is in the world, and how much world there is for it to be in. */
+export type World = {
+  sources: Source[];
+
+  // How many dimensions the space has, and two is not a lesser version of
+  // three. The turn is flat — the axis comes round in one plane and stays in
+  // it — so everything a turning source does happens in that plane, and the
+  // third dimension contributes nothing to it but the rest of a sphere for
+  // the same arms to be seen through. Flat, the plane of the turn IS the
+  // picture.
+  dims?: number;
+
+  // How much lattice there is, as a radius in cells.
+  radius?: number;
+
+  // Ticks per eighth of a turn, and one is as fast as turning goes: an eighth
+  // of a turn is the smallest rotation this space has, because there are
+  // eight directions to a plane and nothing between neighbouring ones to move
+  // through. Anything quicker is not a faster rotation but a coarser one.
+  turnEvery?: number;
+
+  // How often a ray takes one of the ways its direction is made of instead of
+  // the direction itself. See `Graph.wander`.
+  wander?: number;
+
+  // How many moves a charge lasts before it is space again, how far round the
+  // front counts as ahead when it fans, and how far out it waits before
+  // fanning at all. See `Graph.sources`.
+  range?: number;
+  spread?: number;
+  fanAt?: number;
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lines.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lines.ts
new file mode 100644
index 0000000..e6a6719
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lines.ts
@@ -0,0 +1,160 @@
+import { LineSide } from "./discrete";
+import { opposite, Polarity, randomPolarity } from "./lattice";
+
+/**
+ * Charges in a row, enumerated.
+ *
+ * These are the small universes — two, three, four points — where the whole
+ * of what can happen can be listed rather than sampled. There is no closed
+ * form of any of them and there is no need for one: the interest is that
+ * every arrangement is on the page and none was chosen.
+ */
+
+// The four states a point of a line can be in, named against the line rather
+// than against a partner.
+const STATES: LineSide[] = [
+  { polarity: Polarity.Positive, moving: 'right' },
+  { polarity: Polarity.Positive, moving: 'left' },
+  { polarity: Polarity.Negative, moving: 'right' },
+  { polarity: Polarity.Negative, moving: 'left' },
+];
+
+// Every arrangement of n charges in a row: each of them either polarity, each
+// of them going either way. 4ⁿ of them before the symmetries are taken out.
+const linesOf = (n: number): LineSide[][] =>
+  n === 0
+    ? [[]]
+    : linesOf(n - 1).flatMap(rest => STATES.map(side => [side, ...rest]));
+
+// Read back to front with every direction reversed, a line is the same
+// experiment watched from the other end.
+const mirrored = (line: LineSide[]): LineSide[] =>
+  [...line].reverse().map(s => ({
+    polarity: s.polarity,
+    moving: s.moving === 'left' ? 'right' : 'left',
+  }));
+
+// Every polarity flipped, every direction kept: the anti-line.
+const antiLine = (line: LineSide[]): LineSide[] =>
+  line.map(s => ({ polarity: opposite(s.polarity), moving: s.moving }));
+
+// Identity up to mirroring: whichever way round the line reads first.
+const lineKey = (line: LineSide[]): string => {
+  const read = (l: LineSide[]) => l.map(s => `${s.polarity}${s.moving}`).join(",");
+  const [x, y] = [read(line), read(mirrored(line))];
+
+  return x < y ? x : y;
+};
+
+/**
+ * The distinct lines among the given ones, each grouped with its anti-line so
+ * the two sit one above the other — the same experiment run on matter and on
+ * antimatter. A line that is its own anti up to mirroring is a group of one.
+ */
+const antiGroups = (lines: LineSide[][]): LineSide[][][] => {
+  const byKey = new Map<string, LineSide[]>();
+  for (const line of lines) {
+    const key = lineKey(line);
+    if (!byKey.has(key)) byKey.set(key, line);
+  }
+
+  const taken = new Set<string>();
+  const groups: LineSide[][][] = [];
+
+  for (const [key, line] of byKey) {
+    if (taken.has(key)) continue;
+    taken.add(key);
+
+    const group = [line];
+
+    const anti = lineKey(antiLine(line));
+    if (!taken.has(anti) && byKey.has(anti)) {
+      taken.add(anti);
+      group.push(byKey.get(anti)!);
+    }
+
+    groups.push(group);
+  }
+
+  return groups;
+};
+
+/**
+ * Every arrangement of n charges, grouped with its anti.
+ *
+ * At two this is the smallest possible universe: two spatial points joined by
+ * a mutual boundary pair, and every permutation of (polarity, direction) over
+ * the two ends is one isolated experiment in the tick rules — head-on like
+ * polarities turn around, head-on opposite polarities annihilate, and
+ * anything else moves. At three or four the line has an INSIDE, so what one
+ * interaction leaves behind is what the next has to work with.
+ */
+export const lineGroups = (n: number): LineSide[][][] => antiGroups(linesOf(n));
+
+/**
+ * One side of a head-on collision: `size` charges all going the same way,
+ * their polarity flipping from one to the next. `inner` is the polarity of
+ * the one at the interface, and the block alternates outward from there —
+ * so what a block is doing at the meeting point is what names it, and the
+ * rest of it follows.
+ */
+const alternatingBlock = (size: number, inner: Polarity, moving: 'left' | 'right'): LineSide[] => {
+  const outward = Array.from({ length: size }, (_, i) => ({
+    polarity: i % 2 === 0 ? inner : opposite(inner),
+    moving,
+  }));
+
+  // Written from the interface outward. A block moving right sits to the left
+  // of the interface, so it reads the other way round along the line.
+  return moving === 'right' ? outward.reverse() : outward;
+};
+
+/**
+ * Two alternating blocks run at each other. Once the alternation is fixed the
+ * only freedom left is the phase of each block — which polarity it presents
+ * at the interface — so these four are all of them:
+ *
+ *   ..0101 → ← 1010..  the alternation carries straight through the meeting
+ *                      point; the line is one alternating line, cut in two and
+ *                      told to move at itself.
+ *   ..1010 → ← 1010..  both blocks in the same phase; the alternation breaks
+ *                      exactly where they meet, and the two innermost charges
+ *                      are alike rather than opposite.
+ *
+ * and the anti of each. Head-on opposites annihilate and head-on likes turn
+ * around, so the phase decides whether the interface eats the line or reflects
+ * it — and after the first tick the block behind is one step further in, with
+ * its own phase to present.
+ */
+const PHASES: [Polarity, Polarity][] = [
+  [Polarity.Positive, Polarity.Negative],
+  [Polarity.Negative, Polarity.Positive],
+  [Polarity.Positive, Polarity.Positive],
+  [Polarity.Negative, Polarity.Negative],
+];
+
+// The distinct collisions of two alternating blocks of `size`, grouped with
+// their antis. Mirroring identifies the two through-alternating phases, so
+// what is left is: alternation-through, and alternation-broken with its anti.
+export const collisionGroups = (size: number): LineSide[][][] =>
+  antiGroups(PHASES.map(([left, right]) => [
+    ...alternatingBlock(size, left, 'right'),
+    ...alternatingBlock(size, right, 'left'),
+  ]));
+
+/**
+ * An alternating block driven into an unstructured one. The left side arrives
+ * at the interface with a polarity that was decided the moment the block was
+ * written; the right side arrives with one that wasn't decided by anything.
+ *
+ * So the two phases above stop being two experiments: which of them is
+ * happening is redrawn at every step, as whatever the other side happens to
+ * have put in front. What is left to watch is whether the alternation
+ * survives being met by something that isn't one.
+ */
+export const alternatingIntoRandom = (size: number, inner: Polarity): LineSide[] => [
+  ...alternatingBlock(size, inner, 'right'),
+  ...Array.from({ length: size }, () => ({
+    polarity: randomPolarity(), moving: 'left' as const,
+  })),
+];
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
new file mode 100644
index 0000000..0ab0ed5
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
@@ -0,0 +1,199 @@
+import { Emitter, emitterOf } from "./continuous";
+import { Graph } from "./discrete";
+import { RenderMode } from "./GraphCanvas";
+import { World } from "./lattice";
+
+/**
+ * How far apart a pair is put, on each side of the middle — and the one
+ * number the two readings are allowed to disagree about.
+ *
+ * They have to. A lattice run is some thousands of points, each with
+ * twenty-six boundaries, ticked one at a time: a ball with room for a pair
+ * thirty-four cells apart is the better part of a million points, and there
+ * is no watching that. Eight is what it can afford. The closed form has no
+ * points in it at all — every sample is one cosine, independent of every
+ * other — so it can be given the room the arrangement actually wants.
+ *
+ * And the room matters, because the rates in this model are absolute. Space
+ * goes at two cells a tick between two things that are cancelling, so a pair
+ * set eight apart is over in eight ticks and what there is to see is not the
+ * arrangement but the end of it. Set thirty-four apart there is time for the
+ * two to reach each other, for the fringes between them to establish
+ * themselves, and for the closing to be watched as a thing with a rate.
+ *
+ * So a shared arrangement writes its positions in units of the separation —
+ * a pair is at −1 and +1 — and each reading multiplies by what it can afford.
+ * The arrangement is stated once; only its size is stated twice.
+ */
+export const NEAR = 8;
+export const APART = 34;
+
+/**
+ * One arrangement of the world, said once and read two ways.
+ *
+ * This is the editing surface of the whole article. Everything in `models.ts`
+ * is one of these, and the shape of it is the argument: an arrangement is a
+ * fact about what is in the world, and "run it on a lattice" and "write down
+ * what that makes" are two readings of that one fact rather than two
+ * different things that happen to look alike.
+ *
+ * So `world` is where an arrangement is stated, once. From it both readings
+ * are derived — `Graph.sources` builds points and lets the tick rules have
+ * them, `emitterOf` turns each source into a cosine — and neither derivation
+ * adds anything of its own. If the two pictures then disagree, the
+ * disagreement is about what these rules make, which is the one thing worth
+ * putting two pictures side by side to find out.
+ *
+ * `lattice` and `closed` carry only what the two readings cannot share: how
+ * long to run, how much to frame, how to draw. Either can be set to `false`
+ * where the arrangement genuinely has only one reading — a line of four
+ * charges has no closed form, and an orbit is not something a nine-thousand
+ * point ball can be watched doing — and either can be given its subject
+ * outright, for the arrangements that are not a world of sources at all.
+ */
+export type Model = {
+  name: string;
+  note?: string;
+
+  /** What is in it, read by both. */
+  world?: World;
+
+  /** The lattice run, or `false` where there is nothing to run. */
+  lattice?: false | Lattice;
+
+  /** The closed form, or `false` where there is nothing to write down. */
+  closed?: false | Closed;
+
+  /**
+   * Models drawn in the same block as this one, because they are the same
+   * experiment asked twice: a line and its anti-line, an arrangement flat and
+   * the same arrangement round. Read together rather than one after another,
+   * which is what putting them in one block is for.
+   */
+  alongside?: Model[];
+};
+
+/** The lattice run: how the world is seeded, and how it is watched. */
+export type Lattice = {
+  /**
+   * How the world is seeded. Derived from `world` when there is one, so this
+   * is for the arrangements that are not a world of sources — a line of
+   * charges, two blocks driven together, a patch of lattice let go.
+   */
+  seed?: () => Graph;
+
+  /**
+   * What the world's coordinates are in, in cells. `Source.at` is written in
+   * units of the separation, so this is what the lattice can afford to make
+   * that separation — see `NEAR`.
+   */
+  scale?: number;
+
+  /** Ticks before it starts again from the seed. Absent runs indefinitely. */
+  ticks?: number;
+
+  /** Whether it starts by itself, or waits to be asked. */
+  autoplay?: boolean;
+
+  /**
+   * Every step laid out at once, left to right, with an arrow between
+   * consecutive states — rather than played. There is nothing to play, so no
+   * controls.
+   */
+  filmstrip?: boolean;
+
+  /**
+   * How many times to run it. The dynamics are stochastic, and where the
+   * arrangement itself is a draw rather than a case — every point charged on
+   * its own, say — one run says nothing that survives being watched twice.
+   */
+  runs?: number;
+
+  mode?: RenderMode;
+
+  /**
+   * The gravity-flow glow. Worth it for a large universe; for a two-point one
+   * it washes out the handful of boundaries the picture is about.
+   */
+  density?: boolean;
+
+  height?: number;
+
+  /**
+   * Seconds per tick. The default is slow enough to read one interaction at a
+   * time; a universe whose interest is in what it does over a hundred ticks
+   * wants to be quicker than that.
+   */
+  interval?: number;
+};
+
+/** The closed form: the same thing written down instead of run. */
+export type Closed = {
+  /** Derived from `world` when there is one. */
+  sources?: Emitter[];
+
+  /** The same, for the reading that can afford the room — see `APART`. */
+  scale?: number;
+
+  /** How much of the world is on screen, as a radius in cells. */
+  span?: number;
+
+  /**
+   * Ticks before it starts again from the beginning. A pair that closes on
+   * each other ends up adjacent and then has nothing left to do — neither is
+   * space, so neither can be moved through. Watching that happen is the
+   * point; watching it having happened is not.
+   */
+  cycle?: number;
+
+  /** Ticks a second, and it need not be a whole number of anything. */
+  rate?: number;
+
+  height?: number;
+};
+
+// The same arrangement, at the size the reading asking for it can afford.
+const sized = (world: World, scale: number): World =>
+  scale === 1 ? world : {
+    ...world,
+    sources: world.sources.map(s => ({ ...s, at: s.at.map(v => v * scale) })),
+  };
+
+// Neither reading exists unless it has a subject: one it was given, or one
+// derived from the world. Set to `false`, it does not exist whatever the
+// world says.
+const reading = <T extends object, K extends keyof T>(
+  given: false | T | undefined, key: K, derive: () => T[K] | undefined,
+): T | undefined => {
+  if (given === false) return undefined;
+
+  const view = { ...(given ?? {}) } as T;
+  if (view[key] !== undefined) return view;
+
+  const subject = derive();
+  if (subject === undefined) return undefined;
+
+  view[key] = subject;
+
+  return view;
+};
+
+/** How this model is run, if it is run at all. */
+export const latticeOf = (model: Model): Lattice | undefined =>
+  reading<Lattice, 'seed'>(model.lattice, 'seed', () => {
+    const world = model.world;
+    if (!world) return undefined;
+
+    const at = sized(world, (model.lattice || {}).scale ?? 1);
+
+    return () => Graph.sources(at);
+  });
+
+/** And how it is written down, if it can be. */
+export const closedOf = (model: Model): Closed | undefined =>
+  reading<Closed, 'sources'>(model.closed, 'sources', () => {
+    const world = model.world;
+    if (!world) return undefined;
+
+    return sized(world, (model.closed || {}).scale ?? 1).sources.map(emitterOf);
+  });
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
new file mode 100644
index 0000000..b4086cf
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -0,0 +1,790 @@
+import { LIGHT, PACE } from "./continuous";
+import { bySide, Graph, perPoint } from "./discrete";
+import { Polarity, Source } from "./lattice";
+import { RenderMode } from "./GraphCanvas";
+import { alternatingIntoRandom, collisionGroups, lineGroups } from "./lines";
+import { APART, Model, NEAR } from "./model";
+
+/**
+ * Every arrangement in this article, and nothing else.
+ *
+ * This file is data. It says what is in each world and how long to watch it,
+ * and it says each thing once — a model with a `world` is run on a lattice
+ * AND written down as a closed form, from the same declaration, and the two
+ * are drawn beside each other. To change what an arrangement is, change it
+ * here; both pictures follow.
+ */
+
+// How far out the sources of a pair start, framed. A little more than the gap
+// itself, so there is somewhere for what they emit to go.
+const ROOM = 1.2;
+
+/**
+ * And how many ticks each is given before it starts again.
+ *
+ * Not the same number for both kinds, because they do not have the same
+ * amount to do. A lone source never finishes: it is laying down a pattern
+ * that goes on getting bigger, and every extra turn of it out towards the rim
+ * is another turn there is to see, so it is given a long run. A pair does
+ * finish — they reach each other, and adjacent is as close as adjacent gets —
+ * so what a long run buys there is a great deal of two sources sitting still.
+ * Enough after they arrive to see that they have arrived, and then round
+ * again.
+ */
+const ALONE_FOR = 260;
+const PAIR_FOR = 200;
+
+// And how long a lattice run gets, which is set by how much ball there is to
+// cross rather than by how much there is to see.
+const LATTICE_FOR = 60;
+
+/**
+ * How fast a pair has to be going to go round rather than into each other.
+ *
+ * Measured, and the measurement is the only reason this number is what it is.
+ * Sent past each other from twenty-four cells out and run for three hundred
+ * and twenty ticks, the line between the pair turns:
+ *
+ *     0.45c    644 degrees, and then it is gone — the gap reaches 123
+ *     0.40c    971 degrees, gap 22 to 53, drifting slowly outwards
+ *     0.35c   1088 degrees, gap 16 to 52, three full turns and still going
+ *
+ * So there is an interval, it is narrow, and this is inside it. Faster and
+ * the two are never caught; slower and they are caught at once. Nothing was
+ * solved for to find it — the rates that fix it are the source's own pace,
+ * the annihilation's two cells a meeting, and what the motion lays back down
+ * behind itself, and where those cross is where an orbit is possible.
+ */
+const ORBIT = 0.35 * LIGHT;
+
+// The fly-by's own scale: `FLY` is far enough that light takes a good while
+// to cross, and `MISS` is the impact parameter — the distance they would pass
+// at if nothing were eaten.
+const FLY = 52;
+const MISS = 34;
+const WIDE = 62;
+
+// How far out three of them sit from their common centre. Their sides are
+// this times root three, so light takes about that long to cross between any
+// two of them and nothing at all happens before it has.
+const RING = 30;
+
+// Three of them at the corners of a triangle, each given a course by where it
+// is standing. `going` is what to do with the angle: outward is a collapse,
+// across it is a rotation, nothing at all is gravity unaccompanied.
+const triangle = (
+  { lobed = false, going }: {
+    lobed?: boolean,
+    going?: (turn: number) => [number, number],
+  },
+) => [0, 1, 2].map(k => {
+  const turn = Math.PI / 2 + k * (Math.PI * 2) / 3;
+
+  return {
+    at: [RING * Math.cos(turn), RING * Math.sin(turn)],
+    turning: lobed ? 1 as const : undefined,
+    drift: going?.(turn),
+  };
+});
+
+/**
+ * The same arrangement flat and round, one under the other.
+ *
+ * The turn is flat: the axis comes round in a plane and never leaves it, so
+ * everything these arrangements do happens in that plane, and the third
+ * dimension only offers the rest of a sphere for the same arms to be looked
+ * at through. Which makes the 3D picture a projection of the 2D one with a
+ * great deal of unrelated ball laid over it — every part of the space that is
+ * neither in front of an arm nor behind it, drawn at the same time as the arm.
+ *
+ * So the flat one is the picture of the thing, and the round one is the
+ * picture of the thing plus the depth it was seen through. Read together they
+ * say which of the two the features belong to: what is in both is the
+ * arrangement, and what is only in the round one is the embedding.
+ *
+ * The closed form is flat and has no round version to offer, so it is drawn
+ * once, beside the flat run it is the closed form of.
+ */
+const flatAndRound = (model: Model): Model => ({
+  ...model,
+  world: { ...model.world!, dims: 2 },
+  alongside: [{
+    ...model,
+    name: `${model.name}, in three dimensions`,
+    note: undefined,
+    world: { ...model.world!, dims: 3 },
+    closed: false,
+    alongside: undefined,
+  }],
+});
+
+/**
+ * A source that turns: it has an axis, and the axis comes round. What it lays
+ * down is a spiral, which belongs to a whole train of shells and to none of
+ * them separately — so it is drawn as the field rather than pulse by pulse,
+ * and it must not wander, since wandering is each pulse going somewhere
+ * slightly else on the way and that is exactly the information an arm is made
+ * of, rubbed out.
+ */
+type Draw = { mode: RenderMode, fanAt?: number, wander?: number };
+
+const asField: Draw = {
+  mode: 'field',
+  // Out where there is room for it, rather than at the first opportunity.
+  // Fanning close in crowds the few cells near the source and thickens the
+  // shells there; fanning out where a shell has already grown puts the extra
+  // charges exactly where the gaps between them have opened.
+  fanAt: 5,
+  wander: 0,
+};
+
+// A source that only flips: the same charge in every direction, reversed and
+// reversed again, so what it lays down is shells and a shell is the object.
+const asShells: Draw = { mode: 'shells' };
+
+// How a pair of sources with poles is drawn: both given the same axis, which
+// is what faces them at each other properly — the left one's right-hand side
+// is its north and the right one's left-hand side is its south, so everything
+// crossing the gap is the opposite of what it meets.
+const POLES = [1, 0, 0];
+
+// The two ends of a pair, in units of the separation between them.
+const LEFT = [-1, 0];
+const RIGHT = [1, 0];
+
+/**
+ * The arrangements that have both readings: a world of sources, run on a
+ * lattice and written down, side by side.
+ */
+const worlds: Model[] = ([
+  {
+    name: 'two sources, pulsing in step',
+    note: 'Rings launched together. They agree on the midline and cancel in '
+      + 'rings either side of it, and it is the cancelling that closes them.',
+    sources: [{ at: LEFT }, { at: RIGHT }],
+    draw: asShells,
+  },
+  {
+    name: 'two sources, pulsing against each other',
+    note: 'Half a cycle apart: the midline is now where they always cancel, '
+      + 'so the same pair closes faster on the same rules.',
+    sources: [{ at: LEFT }, { at: RIGHT, phase: 0.5 }],
+    draw: asShells,
+  },
+  {
+    name: 'one magnet, turning',
+    note: 'It has an axis, so the field carries an angle and its zero set '
+      + 'winds. Nothing travels along the spiral; the spiral is where each '
+      + 'pulse went.',
+    sources: [{ at: [0, 0], axis: POLES, turning: 1 }],
+    alone: true,
+    draw: asField,
+  },
+  {
+    name: 'one source, not turning',
+    note: 'The same expression with the angle taken out, and the same drawing '
+      + 'machinery: no axis, so it puts the same charge out everywhere and '
+      + 'flips in place. Rings. The winding is the whole of the difference.',
+    sources: [{ at: [0, 0] }],
+    alone: true,
+    draw: asField,
+  },
+  {
+    name: 'two magnets, turning the same way',
+    note: 'Two congruent spirals, and the first pair here that closes: what '
+      + 'they eat between them is what brings them together.',
+    sources: [
+      { at: LEFT, axis: POLES, turning: 1 },
+      { at: RIGHT, axis: POLES, turning: 1 },
+    ],
+    draw: asField,
+  },
+  {
+    name: 'two magnets, turning opposite ways',
+    note: 'Mirrored winding, so along the line between them the two arrive in '
+      + 'step and out of step by turns — and close in bursts rather than '
+      + 'steadily, which is the beat showing up as a rate.',
+    sources: [
+      { at: LEFT, axis: POLES, turning: 1 },
+      { at: RIGHT, axis: POLES, turning: -1 },
+    ],
+    draw: asField,
+  },
+] as { name: string, note: string, sources: Source[], alone?: boolean, draw: Draw }[])
+  .map(({ name, note, sources, alone, draw }) => flatAndRound({
+    name,
+    note,
+    world: { sources, wander: draw.wander, fanAt: draw.fanAt },
+    lattice: {
+      scale: NEAR,
+      ticks: LATTICE_FOR,
+      height: 320,
+      interval: 0.2,
+      mode: draw.mode,
+      // The glow is a sum over every charge, and with a pulse going out every
+      // tick that is most of the ball — one even wash, hiding the shells it
+      // is drawn from.
+      density: false,
+    },
+    closed: {
+      // A lone source is already at the middle and has nothing to be apart
+      // from, so there is nothing to scale it against.
+      scale: alone ? 1 : APART,
+      span: alone ? 14 : APART * ROOM,
+      cycle: alone ? ALONE_FOR : PAIR_FOR,
+    },
+  }));
+
+/**
+ * And the arrangements only the closed form can be asked.
+ *
+ * Every one of these needs room — for the two to reach each other, be carried
+ * past each other, and still be somewhere worth looking at — and room is the
+ * one thing a lattice run cannot be given. So the positions here are in cells
+ * outright rather than in units of a separation: there is no second reading
+ * for them to agree with.
+ */
+const closedOnly: Model[] = [
+  /**
+   * One of them, going somewhere.
+   *
+   * Nothing for it to interact with, so nothing about it changes: it travels
+   * at the one speed a source can, and goes on emitting the whole way. What
+   * that shows is the retardation on its own, with no gravity mixed into it.
+   * Every ring it leaves is centred where it was when that ring left, so the
+   * rings ahead of it are crowded together and the ones behind are stretched
+   * apart — the same shape as a Doppler shift, arrived at by nothing more
+   * than a source outrunning some of its own past.
+   */
+  {
+    name: 'one magnet, turning, and moving',
+    note: 'No second source, so nothing is eaten and nothing bends. The rings '
+      + 'bunch ahead and stretch behind because each was left where it left '
+      + 'from, and the source has gone on.',
+    world: { sources: [{ at: [-12, 0], turning: 1, drift: [PACE, 0] }] },
+    lattice: false,
+    closed: { span: 14, cycle: ALONE_FOR },
+  },
+
+  /**
+   * Two of them, set going the same way round.
+   *
+   * The one on the left sent up and the one on the right sent down, so the
+   * pair are circulating about the point between them rather than passing
+   * each other. This is the case the lattice version could not really put to
+   * the question — a hundred ticks of a nine-thousand-point ball is a long
+   * wait to find out — and it is the one worth asking, because it is where
+   * gravity that is only ever a shortening of a gap either does or does not
+   * come out looking like an orbit.
+   *
+   * What to watch is whether the closing keeps up with the carrying. Neither
+   * changes speed, ever; the drift is what it was set to and stays there. So
+   * the only question is whether the space between them is eaten as fast as
+   * their courses take them apart, and the three answers — they wind
+   * together, they part, or they hold — are all legible and none of them is
+   * arranged for.
+   */
+  {
+    name: 'two magnets, turning, with angular momentum',
+    note: 'Set going the same way round the middle. Nothing accelerates: what '
+      + 'brings them in is the gap being eaten while they carry on.',
+    world: {
+      sources: [
+        { at: [-APART, 0], axis: POLES, turning: 1, drift: [0, PACE] },
+        { at: [APART, 0], axis: POLES, turning: 1, drift: [0, -PACE] },
+      ],
+    },
+    lattice: false,
+    closed: { span: APART * ROOM, cycle: PAIR_FOR },
+  },
+
+  /**
+   * And two set to miss each other, which is the fly-by, and the one case
+   * here that could come round.
+   *
+   * Given far more room than any of the others, and the room is the point. An
+   * orbit is a thing that needs somewhere to happen: the two have to be far
+   * enough apart that the gap between them survives being eaten for long
+   * enough to be carried round, and close enough passing that there is
+   * anything to carry.
+   *
+   * The courses are straight and stay straight. Neither source is aimed at
+   * the other; each is sent along x on its own side of the line, so that left
+   * alone they would pass with the whole of `MISS` between them and go on for
+   * ever. What can happen instead is that the ground between them starts
+   * going while they are still crossing it, and the question — a real one,
+   * with a determinate answer nobody has arranged — is whether it goes fast
+   * enough to catch them and slowly enough to leave them anywhere to be
+   * carried to.
+   */
+  {
+    name: 'two sources, pulsing, passing at a distance',
+    note: 'Set to miss each other by a long way. Both courses stay straight; '
+      + 'it is the ground between them that goes.',
+    world: {
+      sources: [
+        { at: [-FLY, -MISS / 2], drift: [PACE, 0] },
+        { at: [FLY, MISS / 2], drift: [-PACE, 0] },
+      ],
+    },
+    lattice: false,
+    closed: { span: WIDE, cycle: PAIR_FOR },
+  },
+
+  /**
+   * Two of them pulsing slowly, which is the one that shows how they move.
+   *
+   * Every other pair here emits without pause, so the space between them is
+   * being eaten continuously and they slide together smoothly. Smooth is the
+   * worst possible thing to watch if the question is HOW gravity gets from
+   * one of them to the other, because a smooth pull looks exactly like a
+   * force reaching across the gap, which is what this model says there is no
+   * such thing as.
+   *
+   * Set far apart and pulsing slowly, what it shows instead is the delay, and
+   * it shows it as plainly as anything here can. Nothing whatever happens for
+   * the first thirty-odd ticks — measured, the gap does not move by a
+   * hundredth of a cell — and then the two begin to close. That pause is not
+   * the model waiting for anything. It is light crossing half the gap to the
+   * meeting, and the news of what happened there crossing back, and there
+   * being no other way for either to travel. A force would have started at
+   * once.
+   *
+   * And what arrives does not slide back. The displacement is kept rather
+   * than recomputed, so what the space has given up stays given up: they hold
+   * wherever the last wave left them. Two things are visible in that which no
+   * instantaneous pull can show — that gravity here is CARRIED, and that it
+   * is carried at exactly the speed of the light these things emit.
+   */
+  {
+    name: 'two sources, pulsing slowly',
+    note: 'Nothing at all for thirty ticks, and then they close. The pause '
+      + 'is light crossing to the middle and back — a force would not wait.',
+    world: {
+      sources: [
+        { at: [-26, 0], beat: 12 },
+        { at: [26, 0], beat: 12 },
+      ],
+    },
+    lattice: false,
+    closed: { span: 34, cycle: PAIR_FOR },
+  },
+
+  /**
+   * Two of them that actually go round each other.
+   *
+   * Every other pair in this article either falls together or leaves, and the
+   * reason is a ratio. A source at `PACE` travels at half the speed of its
+   * own light, so two of them sent past one another part at a cell a tick —
+   * and the space between them goes at two cells a tick at the very most,
+   * when every single thing that arrives cancels. Set that fast, nothing is
+   * ever caught. Set slow with nothing else changed, everything is caught at
+   * once.
+   *
+   * Between the two there is an interval, and `ORBIT` is in it. Run for three
+   * hundred and twenty ticks the pair go round 1088 degrees — three full
+   * turns and part of a fourth — with the gap between them running from 16 at
+   * the tightest to 52 at the widest and neither of them ever leaving the
+   * frame.
+   *
+   * Two things hold it up and they pull opposite ways.
+   *
+   * The annihilation between them takes space out, and that is what draws
+   * them in. Measured with a pair held still and the field let settle, what
+   * it comes to at each of them is 0.03 cells a tick at a gap of 8, 0.16 at
+   * 24 and 0.40 at 32 — which is worth stopping on, because it goes the wrong
+   * way round. This is not Newton's pull, getting weaker with distance. It
+   * gets STRONGER with distance, like a spring, and that is a consequence of
+   * the rule rather than a choice: a meeting costs two cells however far
+   * apart the two things meeting are, so what varies with the gap is not the
+   * cost but how much of each field is in the other's way. A pull shaped like
+   * that has bound orbits everywhere and unbound ones nowhere, which is
+   * exactly what these runs do.
+   *
+   * And the motion puts space BACK. `consumeAhead` is a swap — a cell taken
+   * in front is a cell laid down behind — so anything going anywhere is
+   * refilling the space it leaves at the rate it leaves it, and that pushes
+   * outwards against the eating. See `WAKE`. It is the smaller of the two by
+   * a long way, and it is not nothing: with it the tightest the pair get is
+   * 22 cells rather than 20, so the floor of the orbit is set by the swap and
+   * the ceiling by the eating.
+   *
+   * What is worth being clear about is what is NOT holding it up. Neither of
+   * these ever changes speed. There is no force here in the sense of a thing
+   * that could push something faster — each carries on at exactly the pace it
+   * was sent, for ever, and only the component of the fall ACROSS the way it
+   * is going is ever added. What comes round is the DIRECTION. An orbit here
+   * is not a balance of a pull against an inertia. It is a straight line
+   * through ground that keeps turning under it.
+   *
+   * And that ground takes time to hear about anything, so this is an orbit
+   * with a delay in it — which is why the first thing the two do is get
+   * FURTHER apart, 48 out to 50. They are already moving when the run starts
+   * and nothing can act on them until light has crossed the gap and come
+   * back. They part first, and are caught afterwards.
+   */
+  {
+    name: 'two sources, in orbit',
+    note: 'Sent past each other at a third of light, and they go round — '
+      + 'nearly three times. Neither ever changes speed; only the direction '
+      + 'comes round, because the ground it is crossing falls away.',
+    world: {
+      sources: [
+        { at: [-24, 0], drift: [0, ORBIT] },
+        { at: [24, 0], drift: [0, -ORBIT] },
+      ],
+    },
+    lattice: false,
+    closed: { span: 34, cycle: 320 },
+  },
+
+  /**
+   * The same thing, but nothing about it set up to work.
+   *
+   * The pair above is a construction: two identical sources, mirrored, sent
+   * exactly across the line between them at exactly the same pace, so that
+   * whatever holds them has a symmetry to hold. That is the honest way to
+   * show a mechanism and a poor way to show that it is real, because a
+   * balance which only exists on the axis of a symmetry is usually the
+   * symmetry and not the balance.
+   *
+   * So: magnets rather than plain sources, which means a field that carries
+   * an angle and winds. Turning opposite ways, so there is no rotational
+   * symmetry either. Different paces — one at `ORBIT` and one half again as
+   * fast — and different distances out, so the centre of the thing is nowhere
+   * in particular. And neither of them aimed across the line between them:
+   * both are sent off at an angle to it.
+   *
+   * Nothing here is solved for. What it has in common with the pair above is
+   * only that both speeds are in the interval `ORBIT` names, and that is the
+   * whole claim being made — that the interval is a property of the rules and
+   * not of the arrangement.
+   */
+  {
+    name: 'two magnets, mixed speeds, in orbit',
+    note: 'Different speeds, different distances out, winding opposite ways '
+      + 'and neither sent square to the line between them. It still goes '
+      + 'round, which is the point.',
+    world: {
+      sources: [
+        {
+          at: [-20, -6], axis: POLES, turning: 1,
+          drift: [ORBIT * 0.34, ORBIT * 0.94],
+        },
+        {
+          at: [26, 4], axis: POLES, turning: -1, phase: 1 / 6,
+          drift: [-ORBIT * 1.5 * 0.42, -ORBIT * 1.5 * 0.91],
+        },
+      ],
+    },
+    lattice: false,
+    closed: { span: 40, cycle: 320 },
+  },
+
+  /**
+   * Three of them, which is where this stops being arithmetic.
+   *
+   * Nothing in the rules changes. Every pair does exactly what a pair does —
+   * meets head-on, annihilates where opposite and turns round where alike,
+   * and loses the space between them at two cells a tick for as much of the
+   * meeting as cancels. Add a third and not one line of that is different.
+   * What is different is that there are now three gaps going at once, each at
+   * its own rate, and no symmetry left holding any of them.
+   *
+   * Which is the point of putting it here. Two of anything is a special case:
+   * whatever they do, they do it along the one line between them, and the
+   * whole configuration is that line's length. Three have a shape, and the
+   * shape can change — so this is the first arrangement in the article where
+   * the question "what happens" does not have an answer that could have been
+   * worked out from a single number.
+   *
+   * Worth watching for two things the pairs cannot show. Each source is
+   * eating with BOTH of the others at once, along two different lines, so
+   * what moves it is a sum of two contractions pointing different ways — and
+   * it will not point at either of them. And a wave leaving one of them meets
+   * whichever of the other two it runs into first, so the surface it stops at
+   * is no longer a plane: it is two planes, and which one applies depends on
+   * the direction it left in.
+   */
+  {
+    name: 'three sources, going round',
+    note: 'The same pairwise rule, three times over. Nothing is aimed at '
+      + 'anything; each carries on the way it was sent while the space '
+      + 'between all three of them goes.',
+    world: {
+      // Tangentially, all the same way round, so the three of them carry a
+      // rotation about the middle rather than three separate approaches.
+      sources: triangle({
+        going: turn => [-PACE * Math.sin(turn), PACE * Math.cos(turn)],
+      }),
+    },
+    lattice: false,
+    closed: { span: WIDE, cycle: PAIR_FOR },
+  },
+
+  /**
+   * And the same three aimed straight at one another.
+   *
+   * The other arrangement of three, and the one that isolates what the
+   * turning was doing. There every source was carrying past the other two
+   * while the ground went, and it was never clear how much of what happened
+   * was the eating and how much was the momentum. Here the momentum is
+   * pointed at the same place the eating is pulling, so the two agree, and
+   * whatever comes out is what these rules do when nothing is working against
+   * them.
+   *
+   * The thing to watch for is whether they arrive at a POINT. Three bodies
+   * aimed at one place have every reason to miss it — the least asymmetry in
+   * what each is emitting when puts one of the three gaps ahead of the other
+   * two, that pair closes first, and what was a collapse becomes a pair with
+   * a third thing falling towards it. Nothing here decides which. The phases
+   * are identical and the geometry is exact, so if they do not arrive
+   * together it is because the encounter itself is not stable, and that is a
+   * result rather than a fault.
+   */
+  {
+    name: 'three sources, aimed at each other',
+    note: 'The same three, sent inwards instead of round. Momentum and the '
+      + 'loss of space now agree, so nothing is holding them apart.',
+    world: {
+      // Straight at the middle, which is straight at the other two.
+      sources: triangle({
+        going: turn => [-PACE * Math.cos(turn), -PACE * Math.sin(turn)],
+      }),
+    },
+    lattice: false,
+    closed: { span: WIDE, cycle: PAIR_FOR },
+  },
+
+  /**
+   * Three turning magnets, not sent anywhere.
+   *
+   * The other two threes are about momentum — one carrying round, one aimed
+   * in — and both of them have sides that put out the same charge in every
+   * direction. This one takes the momentum away and gives them poles instead.
+   * Nothing is thrown at anything. The only thing that moves them is the
+   * space between them going, so whatever they end up doing is gravity
+   * unaccompanied, which is the thing the article is actually arguing about.
+   *
+   * And it is the first arrangement here where what each of them presents to
+   * the others is CHANGING. A pulsing source is the same all round, so a pair
+   * of them either cancel or they do not and that stays true. A magnet has a
+   * north and a south, and a turning magnet sweeps them past everything — so
+   * each of the three faces each of the others with something different every
+   * tick, and the three gaps go at three rates that are not only unequal but
+   * keep swapping which is largest.
+   *
+   * All three given the same phase, so they start pointing the same way and
+   * come round together. That is deliberate and it is not the same as facing
+   * each other: a pair with matching axes presents opposite poles across the
+   * gap, permanently, which is why the pair above eats so steadily. Three at
+   * the corners of a triangle cannot all do that with all of the others —
+   * there is no way to orient three things so that every pair is opposed —
+   * and what happens instead is the question.
+   */
+  {
+    name: 'three magnets, turning',
+    note: 'Three of them with poles, coming round together, sent nowhere. '
+      + 'Nothing moves them but the space between them going.',
+    world: { sources: triangle({ lobed: true }) },
+    lattice: false,
+    closed: { span: WIDE, cycle: PAIR_FOR },
+  },
+
+  /**
+   * And the same fly-by again, moving as fast and emitting a fifth as often.
+   *
+   * One pulse every fifth tick, and everything else exactly as above: the
+   * same distance, the same miss, the same speed, the same rules. What
+   * changes is only how often the two have anything to say to each other.
+   *
+   * Which is not a small change, because it is the one term that was making
+   * capture inevitable. A pair pulsing every tick has a meeting every tick,
+   * each meeting taking two cells out of the gap — the eating was several
+   * times quicker than the moving, no amount of distance was going to outrun
+   * it, and every pair above ends up together with the only question being
+   * how long it took.
+   *
+   * A pulse every fifth tick is a meeting every fifth tick, so the gap goes
+   * at two fifths of a cell a tick — and nothing has been slowed down to
+   * achieve it. The two are carried exactly as far as they were. For the
+   * first time in any of these the two rates are within reach of each other,
+   * and the outcome stops being obvious.
+   *
+   * It is worth being clear that nothing here is tuned to produce an orbit.
+   * The beat is a property of the source — how often it lets go of a shell —
+   * and the speed is a property of its mass. Two independent facts about a
+   * thing, whose ratio decides whether it falls in, escapes, or comes round.
+   *
+   * There is a second thing this makes visible, which the filled field could
+   * not. With four cells of nothing between one ring and the next, most of
+   * the space between the two sources is space where neither of them has
+   * anything, and the eating happens in bursts as the rings pass through each
+   * other rather than continuously. The gap does not shorten smoothly. It
+   * shortens whenever two shells arrive at the same place, and holds still in
+   * between, which is what a discrete rule looks like when it is still
+   * discrete.
+   */
+  {
+    name: 'the same, pulsing every fifth tick',
+    note: 'Moving every tick, emitting every fifth one. A fifth as many '
+      + 'meetings, so the gap goes a fifth as fast — and the two are carried '
+      + 'just as far while it does.',
+    world: {
+      sources: [
+        { at: [-FLY, -MISS / 2], drift: [PACE, 0], beat: 5 },
+        { at: [FLY, MISS / 2], drift: [-PACE, 0], beat: 5 },
+      ],
+    },
+    lattice: false,
+    closed: { span: WIDE, cycle: PAIR_FOR },
+  },
+];
+
+/**
+ * And the arrangements only a lattice can be asked.
+ *
+ * These are the small universes — a handful of points, or two blocks driven
+ * together — where the interest is that every case is on the page and none
+ * was chosen. There is no closed form of any of them, and there would be
+ * nothing for one to say: a cosine is a statement about a field, and these do
+ * not have fields. They have four charges and a rule.
+ */
+const blocks: Model[] = [
+  {
+    name: 'a patch of lattice, let go',
+    note: 'Every point charged at random and set going at random. From there '
+      + 'the rules alone: cancel, turn around, or move.',
+    lattice: { seed: () => Graph.grid({ dims: 3 }), autoplay: false },
+    closed: false,
+  },
+
+  ...([
+    [Polarity.Positive, Polarity.Negative],
+    [Polarity.Positive, Polarity.Positive],
+    [Polarity.Negative, Polarity.Negative],
+  ] as [Polarity, Polarity][]).map(([left, right], i): Model => ({
+    name: ['two blocks, opposite', 'two blocks, both positive', 'two blocks, both negative'][i],
+    note: i === 0
+      ? 'The interface annihilates a column at a time and the two come apart '
+      + 'backwards.'
+      : 'Alike, so nothing can cancel: the interface merges and the two '
+      + 'become one.',
+    lattice: {
+      seed: () => Graph.blocks({ charge: bySide(left, right) }),
+      ticks: 15, height: 140, density: false,
+    },
+    closed: false,
+  })),
+
+  {
+    name: 'two blocks, drawn point by point',
+    note: 'Nothing uniform about either of them, so the interface is a '
+      + 'different thing at every row of it — and the two come apart along a '
+      + 'line neither of them had. Three draws, since a draw is not a case.',
+    lattice: {
+      seed: () => Graph.blocks({ charge: perPoint() }),
+      ticks: 5, filmstrip: true, runs: 3, height: 90, density: false,
+    },
+    closed: false,
+  },
+
+  ...([
+    [Polarity.Positive, Polarity.Negative],
+    [Polarity.Positive, Polarity.Positive],
+  ] as [Polarity, Polarity][]).map(([left, right], i): Model => ({
+    name: i === 0 ? 'two emitters, opposite' : 'two emitters, alike',
+    note: i === 0
+      ? 'Held apart by a wide field of neutral space, neither of them moving, '
+      + 'each writing a charge onto the space at its face. Opposite charges '
+      + 'annihilate in the middle and the field between them is eaten two '
+      + 'columns at a time until there is none of it left.'
+      : 'Alike charges only bounce off each other and come home, so the two '
+      + 'are driven apart by their own emissions instead.',
+    lattice: {
+      seed: () => Graph.emitters({ left, right }),
+      ticks: 18, height: 140,
+    },
+    closed: false,
+  })),
+
+  ...([
+    [Polarity.Positive, Polarity.Negative],
+    [Polarity.Positive, Polarity.Positive],
+  ] as [Polarity, Polarity][]).map(([left, right], i): Model => ({
+    name: i === 0 ? 'two emitters, spinning, opposite' : 'two emitters, spinning, alike',
+    note: 'The same two blocks with the magnets turned on: each side flips '
+      + 'what it is emitting every tick, so the field fills with alternating '
+      + 'charge rather than with one thing over and over. Spinning is what '
+      + 'makes it unconditional — both ways round end up eating the field '
+      + 'between them, the second in bursts rather than steadily.',
+    lattice: {
+      seed: () => Graph.emitters({ left, right, gap: 20, every: 1, spin: true }),
+      ticks: 22, height: 140,
+    },
+    closed: false,
+  })),
+];
+
+// A group of lines drawn in one block: the experiment on matter, and the same
+// experiment on antimatter, one under the other.
+const asGroup = (
+  name: string, group: Parameters<typeof Graph.line>[0][], lattice: Model['lattice'],
+): Model => {
+  const of = (line: Parameters<typeof Graph.line>[0]): Model => ({
+    name: '',
+    lattice: { seed: () => Graph.line(line), ...(lattice || {}) },
+    closed: false,
+  });
+
+  return {
+    ...of(group[0]),
+    name,
+    alongside: group.slice(1).map(of),
+  };
+};
+
+const lines: Model[] = [
+  // Every arrangement of two, three and four charges in a row. Each runs for
+  // as many steps as there are charges, since that is roughly how long it
+  // takes for what happens at one end to be felt at the other.
+  ...[2, 3, 4].flatMap(n =>
+    lineGroups(n).map((group, i) => asGroup(
+      i === 0 ? `every arrangement of ${n} charges in a row` : '',
+      group,
+      { ticks: n, filmstrip: true, height: 60, density: false },
+    ))),
+
+  // Not every arrangement now, but the one arrangement with a pattern to it:
+  // alternating polarities driven head-on into alternating polarities. Blocks
+  // of two, three and four a side, each run for as long as the whole line is.
+  ...[2, 3, 4].flatMap(size =>
+    collisionGroups(size).map(group => asGroup(
+      `alternating blocks of ${size}, head-on`,
+      group,
+      { ticks: size * 2, height: 60, density: false },
+    ))),
+
+  // And the same collision with the structure taken out of one side. There is
+  // no permutation to enumerate — a draw is not a case — so it is a handful
+  // of runs, the alternating side starting from either polarity in turn.
+  ...[3, 4].flatMap(size => [Polarity.Positive, Polarity.Negative].map((inner): Model => ({
+    name: `alternating ${size} into unstructured ${size}`,
+    note: 'Which phase is happening is redrawn at every step, as whatever the '
+      + 'other side has put in front. What is left to watch is whether the '
+      + 'alternation survives being met by something that is not one.',
+    lattice: {
+      seed: () => Graph.line(alternatingIntoRandom(size, inner)),
+      ticks: size * 2, runs: 2, height: 60, density: false,
+    },
+    closed: false,
+  }))),
+];
+
+/** Everything, in the order it is read in. */
+export const MODELS: Model[] = [
+  ...blocks,
+  ...worlds,
+  ...closedOnly,
+  ...lines,
+];
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
new file mode 100644
index 0000000..9ec46da
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
@@ -0,0 +1,111 @@
+import { Polarity } from "./lattice";
+
+/**
+ * The colours, said once for both readings.
+ *
+ * The two halves of this article are drawn by completely different machinery
+ * — one projects a few thousand points through a camera and strokes them, the
+ * other evaluates a cosine into an image buffer a pixel at a time — and the
+ * whole value of drawing them beside each other depends on a positive charge
+ * being the same colour in both. Which it was, twice over: the same three
+ * numbers written out once as a css string and once as three additions onto a
+ * background. Written once here, a change to the palette is a change to both
+ * pictures, which is the only way it can honestly be one palette.
+ *
+ * Channels rather than strings, because the closed form needs them as
+ * numbers: it writes into an ImageData, where a colour is three additions and
+ * not a fill style.
+ */
+export const BACKGROUND = [6, 7, 12];
+
+// Positive one way, negative the other, and the background where the two
+// meet — so a seam is a dark channel and needs no line drawn on it.
+export const AMBER = [255, 122, 69];
+export const CYAN = [61, 220, 255];
+
+// Space that has not been charged by anything.
+export const NEUTRAL = [140, 147, 168];
+
+// A source, which is neither: everything charged came out of one of these, so
+// it is the one thing that isn't an event but a cause of them.
+export const SOURCE = [255, 224, 102];
+
+// The glow around one, and what anything else belonging to a source is drawn
+// in — the route between two of them, above all.
+export const HALO = [255, 214, 66];
+const HALO_OUT = [255, 186, 40];
+
+export const rgb = (c: number[]) =>
+  `rgb(${c[0]},${c[1]},${c[2]})`;
+
+export const rgba = (c: number[], alpha: number) =>
+  `rgba(${c[0]},${c[1]},${c[2]},${alpha})`;
+
+// Just the three numbers, for the places that build their own colour string.
+export const channels = (c: number[]) => `${c[0]},${c[1]},${c[2]}`;
+
+export const tintOf = (polarity: Polarity) =>
+  polarity === Polarity.Positive ? AMBER
+    : polarity === Polarity.Negative ? CYAN
+      : NEUTRAL;
+
+/**
+ * How far a charge of strength `k` lifts a channel off the background.
+ *
+ * The closed form's field is a number between −1 and +1, and drawing it is
+ * exactly this: the background, plus the tint it is leaning towards, times
+ * how far it leans. At nought it is the background, which is why a place
+ * where the two cancel needs nothing drawn on it to read as empty.
+ */
+export const lift = (tint: number[], channel: number) =>
+  tint[channel] - BACKGROUND[channel];
+
+/** The ground everything is drawn on. */
+export const ground = (
+  ctx: CanvasRenderingContext2D, w: number, h: number,
+  { vignette = false }: { vignette?: boolean } = {},
+) => {
+  ctx.fillStyle = rgb(BACKGROUND);
+  ctx.fillRect(0, 0, w, h);
+
+  if (!vignette) return;
+
+  const shade = ctx.createRadialGradient(
+    w / 2, h / 2, 0, w / 2, h / 2, Math.max(w, h) / 1.05,
+  );
+
+  shade.addColorStop(0, "rgba(20,22,34,0)");
+  shade.addColorStop(1, "rgba(0,0,0,0.55)");
+
+  ctx.fillStyle = shade;
+  ctx.fillRect(0, 0, w, h);
+};
+
+/**
+ * A source: a soft halo with a hard little centre in it.
+ *
+ * Drawn the same way in both readings, at whatever size each of them has
+ * reason to want — the lattice sizes it against the zoom, since it is a point
+ * of a structure that is being looked at from somewhere, and the closed form
+ * has no zoom and no points and simply picks one.
+ */
+export const source = (
+  ctx: CanvasRenderingContext2D, x: number, y: number,
+  { halo, dot }: { halo: number, dot: number },
+) => {
+  const glow = ctx.createRadialGradient(x, y, 0, x, y, halo);
+
+  glow.addColorStop(0, rgba(HALO, 0.85));
+  glow.addColorStop(0.35, rgba(HALO_OUT, 0.3));
+  glow.addColorStop(1, rgba(HALO_OUT, 0));
+
+  ctx.fillStyle = glow;
+  ctx.beginPath();
+  ctx.arc(x, y, halo, 0, Math.PI * 2);
+  ctx.fill();
+
+  ctx.fillStyle = rgb(SOURCE);
+  ctx.beginPath();
+  ctx.arc(x, y, dot, 0, Math.PI * 2);
+  ctx.fill();
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
new file mode 100644
index 0000000..e6c0584
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
@@ -0,0 +1,257 @@
+import { Button } from "@blueprintjs/core";
+import { Fragment, useMemo, useRef, useState } from "react";
+
+import { Row } from "../../../lib/post/Post";
+import { ContinuousField } from "./continuous";
+import { Graph } from "./discrete";
+import { GraphCanvas } from "./GraphCanvas";
+import { Closed, closedOf, Lattice, latticeOf, Model } from "./model";
+
+// The transport icons, which are the only things here that are only pictures.
+// Font Awesome Free v7.3.1 by @fontawesome — https://fontawesome.com/license/free
+const ICONS = {
+  pause: "M176 96C149.5 96 128 117.5 128 144L128 496C128 522.5 149.5 544 176 544L240 544C266.5 544 288 522.5 288 496L288 144C288 117.5 266.5 96 240 96L176 96zM400 96C373.5 96 352 117.5 352 144L352 496C352 522.5 373.5 544 400 544L464 544C490.5 544 512 522.5 512 496L512 144C512 117.5 490.5 96 464 96L400 96z",
+  reset: "M491 100.8C478.1 93.8 462.3 94.5 450 102.6L192 272.1L192 128C192 110.3 177.7 96 160 96C142.3 96 128 110.3 128 128L128 512C128 529.7 142.3 544 160 544C177.7 544 192 529.7 192 512L192 367.9L450 537.5C462.3 545.6 478 546.3 491 539.3C504 532.3 512 518.8 512 504.1L512 136.1C512 121.4 503.9 107.9 491 100.9z",
+  play: "M187.2 100.9C174.8 94.1 159.8 94.4 147.6 101.6C135.4 108.8 128 121.9 128 136L128 504C128 518.1 135.5 531.2 147.6 538.4C159.7 545.6 174.8 545.9 187.2 539.1L523.2 355.1C536 348.1 544 334.6 544 320C544 305.4 536 291.9 523.2 284.9L187.2 100.9z",
+  step: "M149 100.8C161.9 93.8 177.7 94.5 190 102.6L448 272.1L448 128C448 110.3 462.3 96 480 96C497.7 96 512 110.3 512 128L512 512C512 529.7 497.7 544 480 544C462.3 544 448 529.7 448 512L448 367.9L190 537.5C177.7 545.6 162 546.3 149 539.3C136 532.3 128 518.7 128 504L128 136C128 121.3 136.1 107.8 149 100.8z",
+};
+
+const Transport = ({ icon, onClick }: { icon: keyof typeof ICONS, onClick: () => void }) => (
+  <Button minimal className="p-0" style={{ minWidth: 0, minHeight: 0 }} onClick={onClick}>
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640" style={{ width: '1em' }} fill="#515254">
+      <path d={ICONS[icon]} />
+    </svg>
+  </Button>
+);
+
+/**
+ * One universe, ticking, with transport controls.
+ */
+const LatticePlayer = ({
+  seed = () => Graph.grid(),
+  ticks,
+  autoplay = true,
+  height = 150,
+  density = true,
+  mode = 'lattice',
+  interval = 0.45,
+}: Lattice) => {
+  const [running, setRunning] = useState(autoplay);
+
+  /**
+   * The live universe. Held in a ref rather than state because resetting
+   * swaps the whole graph out mid-animation-frame — the render loop reads it
+   * afresh every frame, so it picks the new one up without tearing down.
+   *
+   * And nothing at all while the view is off screen. A universe here is some
+   * thousands of points, each with twenty-six boundaries and a projection
+   * cached against it, and there are thirty of these on the page — so what
+   * is being held between the reader scrolling past a picture and scrolling
+   * back to it is tens of megabytes of a thing nobody can see. Dropped, it
+   * is a null and a re-seed.
+   *
+   * Which is not a loss of anything, because there is nothing here to lose.
+   * The dynamics are stochastic, and a repeating example throws its universe
+   * away and re-seeds every `ticks` ticks anyway: coming back to one of
+   * these is coming back to a fresh run whether it was let go of or not.
+   * Seeded lazily rather than eagerly for the same reason as everything else
+   * in this — thirty seeds built at mount is thirty universes' worth of work
+   * for the one or two that can be seen.
+   */
+  const graphRef = useRef<Graph | null>(null);
+
+  // Ticks taken since the last reset, against which `ticks` is measured.
+  const stepsRef = useRef(0);
+
+  const reset = () => {
+    graphRef.current = seed();
+    stepsRef.current = 0;
+  };
+
+  const step = () => {
+    graphRef.current?.tick();
+    stepsRef.current++;
+  };
+
+  // Step the polarity dynamics once every `interval` seconds while running —
+  // annihilation / turn-around / structure-absorption.
+  const accum = useRef(0);
+
+  /**
+   * Made when it is first looked at, and let go of the moment it is not.
+   *
+   * Except when it is paused, which is the one case where the state on
+   * screen is something the reader chose. Stopping a run at a particular
+   * tick to look at it, scrolling a little too far, and coming back to a
+   * fresh one would be losing the thing they stopped for. A running view has
+   * no such state — it is somewhere in the middle of a loop that resets
+   * every `ticks` ticks regardless — so there is nothing to lose in letting
+   * it go, and coming back to it starts the run again from the top, which is
+   * where it wants to be watched from anyway.
+   */
+  const onVisible = (visible: boolean) => {
+    if (!visible) {
+      if (!running) return;
+
+      graphRef.current = null;
+      accum.current = 0;
+      return;
+    }
+
+    if (running || !graphRef.current) reset();
+  };
+
+  const onFrame = (dt: number) => {
+    if (!running || !graphRef.current?.nodes.length) return;
+
+    accum.current += dt;
+    while (accum.current >= interval) {
+      accum.current -= interval;
+
+      // A repeating pattern spends one interval showing the seed again
+      // before stepping on, so the loop point is legible rather than an
+      // instant jump back.
+      if (ticks !== undefined && stepsRef.current >= ticks) reset();
+      else step();
+    }
+  };
+
+  return <div>
+    <div style={{ height }}>
+      <GraphCanvas
+        graph={() => graphRef.current}
+        animate
+        density={density}
+        mode={mode}
+        onFrame={onFrame}
+        onVisible={onVisible}
+      />
+    </div>
+    <Row end="xs" className="child-px-2">
+      {running
+        ? <>
+          <div style={{ width: '1em' }}></div>
+          <Transport icon="pause" onClick={() => setRunning(false)} />
+          <div style={{ width: '1em' }}></div>
+        </>
+        : <>
+          <Transport icon="reset" onClick={reset} />
+          <Transport icon="play" onClick={() => setRunning(true)} />
+          <Transport icon="step" onClick={step} />
+        </>
+      }
+    </Row>
+  </div>
+};
+
+/**
+ * The static form: the same pattern, but every step of it laid out at once.
+ *
+ * The dynamics are stochastic (which boundary a ray turns around to, what
+ * polarity a newly created point gets), so the states can't be re-derived by
+ * re-running the seed — running it again gives a different history. One run
+ * is stepped through, and each state along the way is cloned out of it, so
+ * the strip really is consecutive states of a single universe.
+ */
+const LatticeFilmstrip = ({
+  seed = () => Graph.grid(),
+  ticks = 8,
+  height = 150,
+  density = true,
+  mode = 'lattice',
+}: Lattice) => {
+  const frames = useMemo(() => {
+    const graph = seed();
+    const states = [graph.clone()];
+
+    for (let i = 0; i < ticks; i++) {
+      graph.tick();
+      states.push(graph.clone());
+    }
+
+    return states;
+  }, []);
+
+  return <div style={{ display: 'flex', flexWrap: 'wrap', alignItems: 'center' }}>
+    {frames.map((graph, i) => (
+      <Fragment key={i}>
+        {i > 0
+          ? <div style={{ flex: '0 0 auto', padding: '0 0.5em', color: '#515254' }}>→</div>
+          : null}
+        <div style={{ flex: '1 1 120px', height }}>
+          <GraphCanvas graph={() => graph} density={density} mode={mode} />
+        </div>
+      </Fragment>
+    ))}
+  </div>
+};
+
+const LatticeView = ({ filmstrip, ...rest }: Lattice) =>
+  filmstrip ? <LatticeFilmstrip {...rest} /> : <LatticePlayer {...rest} />;
+
+const ClosedView = ({ sources = [], span, cycle, rate, height = 320 }: Closed) =>
+  <ContinuousField sources={sources} span={span} cycle={cycle} rate={rate} height={height} />;
+
+const Caption = ({ children }: { children: any }) => (
+  <div style={{ color: '#8a8d99', fontSize: '0.8em', paddingTop: '0.6em' }}>{children}</div>
+);
+
+// What each half of a pair of pictures is a picture OF. Said on the picture
+// rather than in the prose, because the whole point of drawing them together
+// is that a reader can tell at a glance which is which.
+const Label = ({ children }: { children: any }) => (
+  <div style={{
+    color: '#6c7080', fontSize: '0.7em', letterSpacing: '0.08em',
+    textTransform: 'uppercase', paddingBottom: '0.35em',
+  }}>{children}</div>
+);
+
+/**
+ * One arrangement, drawn every way it can be read — side by side.
+ *
+ * The whole argument of the second half of this article is that the lattice
+ * and the closed form are the same claim, and an argument like that is made
+ * by putting the two pictures where a reader can look from one to the other
+ * without scrolling. Where an arrangement has only one reading it takes the
+ * full width, which is the honest thing: there is no second picture to
+ * compare against, and a blank half would suggest one is missing.
+ */
+export const ModelView = ({ model }: { model: Model }) => {
+  const lattice = latticeOf(model);
+  const closed = closedOf(model);
+
+  const both = !!lattice && !!closed;
+
+  // A run repeated, where the arrangement is a draw rather than a case.
+  const runs = Array.from({ length: lattice?.runs ?? 1 }, (_, i) => i);
+
+  return <div style={{ marginBottom: '1.5rem' }}>
+    <div style={{
+      display: 'grid',
+      gridTemplateColumns: both ? 'repeat(auto-fit, minmax(280px, 1fr))' : '1fr',
+      gap: '1rem',
+      alignItems: 'start',
+    }}>
+      {lattice ? <div>
+        {both ? <Label>run on a lattice</Label> : null}
+        {runs.map(i => <LatticeView key={i} {...lattice} />)}
+      </div> : null}
+
+      {closed ? <div>
+        {both ? <Label>written down</Label> : null}
+        <ClosedView {...closed} />
+      </div> : null}
+    </div>
+
+    {model.name || model.note
+      ? <Caption>{[model.name, model.note].filter(Boolean).join(' — ')}</Caption>
+      : null}
+
+    {model.alongside?.map((other, i) => <ModelView key={i} model={other} />)}
+  </div>;
+};
+
+/** The catalogue, drawn in order. */
+export const Models = ({ models }: { models: Model[] }) => <>
+  {models.map((model, i) => <ModelView key={`${model.name}-${i}`} model={model} />)}
+</>;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/visible.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/visible.ts
new file mode 100644
index 0000000..9d4b556
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/visible.ts
@@ -0,0 +1,35 @@
+/**
+ * Runs something while an element is worth drawing, and stops it when it is
+ * not.
+ *
+ * An article like this one is thirty-odd universes stacked up a page, of
+ * which at most two are on screen. Every one of them left running is a frame
+ * loop, a tick, and a canvas the size of the viewport being filled sixty
+ * times a second for nobody — which is most of what the page costs, and the
+ * reason it got slower the further down it went.
+ *
+ * A margin, so that a view is going by the time it is looked at rather than
+ * starting the moment it is — and a small one, because arrangements are now
+ * drawn two and three abreast. A margin is a multiplier on how many views run
+ * at once: at half a screen, a block of three canvases starts running while
+ * the block above it is still going, which is six heavy things at once for a
+ * reader looking at two. A fifth is still ahead of the scroll at any speed a
+ * page is read at.
+ */
+export const whileOnScreen = (el: Element, show: (visible: boolean) => void) => {
+  if (typeof IntersectionObserver === "undefined") {
+    // Nothing to watch with: the old behaviour, which is to run regardless.
+    show(true);
+
+    return () => { };
+  }
+
+  const watcher = new IntersectionObserver(
+    entries => show(entries[entries.length - 1].isIntersecting),
+    { rootMargin: "20% 0px" },
+  );
+
+  watcher.observe(el);
+
+  return () => watcher.disconnect();
+};

From c68802c86d65a8edf991b04ba45b0eafbcb6bc77 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sat, 8 Aug 2026 15:51:49 +0200
Subject: [PATCH 15/47] Attempt at compressing the continous model

---
 .../2026.RayCalculiAndPhysics/GraphCanvas.tsx |  35 +-
 .../2026.RayCalculiAndPhysics/continuous.tsx  | 844 ++----------------
 .../2026.RayCalculiAndPhysics/discrete.ts     | 246 +++--
 .../2026.RayCalculiAndPhysics/field.ts        | 733 +++++++++++++++
 .../2026.RayCalculiAndPhysics/lattice.ts      | 200 +----
 .../2026.RayCalculiAndPhysics/lines.ts        |   2 +-
 .../2026.RayCalculiAndPhysics/metric.tsx      | 593 ++++++++++++
 .../2026.RayCalculiAndPhysics/model.ts        |  35 +-
 .../2026.RayCalculiAndPhysics/models.ts       |  30 +-
 .../2026.RayCalculiAndPhysics/paint.ts        |   9 +-
 .../2026.RayCalculiAndPhysics/physics.ts      | 483 ++++++++++
 .../2026.RayCalculiAndPhysics/views.tsx       |  21 +-
 12 files changed, 2141 insertions(+), 1090 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx
index 12111ea..0e408fa 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx
@@ -1,8 +1,31 @@
+/**
+ * EQUATIONS IN THIS FILE
+ *
+ *   projection, world to screen:
+ *     x1 = x cos r − z sin r,   z1 = x sin r + z cos r      turn
+ *     y1 = y cos p − z1 sin p,  z2 = y sin p + z1 cos p     tilt
+ *     persp = dist / (z2 + dist)                            a real camera
+ *   fit: scale = min(w/2·margin / halfX, h/2·margin / halfY)
+ *
+ *   the field, reconstructed from the charges (mode 'field'):
+ *     band   = (CYCLE/2) cells                    one band of one charge
+ *     kernel = (1 − d²)²,  d² = (across/a)² + (along/b)²
+ *                                                 an ellipse across the path
+ *     f      = Sum sign·k / (Sum k + trust)       how positive a place is
+ *     eased += (f − eased)·0.2                    walked towards, per frame
+ *     sharpen: f += (f − blur(f))·gain            the valley between two bands
+ *     contour: marching squares at f = ±0.17
+ *
+ *   density cloud:  potential = Sum q / (|p − s|² + soften)
+ *
+ */
+
 import { useRef } from "react";
 
 import { CanvasView, Surface } from "./canvas";
 import { Boundary, Graph, node } from "./discrete";
-import { BOUNDARY_STUB, CYCLE, LATTICE_STEP, Polarity, Vec } from "./lattice";
+import { BOUNDARY_STUB, CYCLE, LATTICE_STEP, Vec } from "./lattice";
+import { outcome, Polarity } from "./physics";
 import {
   AMBER, channels, CYAN, ground, HALO, rgba, SOURCE, source, tintOf,
 } from "./paint";
@@ -2236,11 +2259,11 @@ export const GraphCanvas = ({
             // the world exactly as big as it was.
             const facing = met.moving!.polarity;
 
-            const opposed =
-              (a.polarity === Polarity.Positive && facing === Polarity.Negative) ||
-              (a.polarity === Polarity.Negative && facing === Polarity.Positive);
-
-            if (!opposed) continue;
+            // Only one of each cancels; everything else meeting head-on turns
+            // around, and turning around leaves the world exactly as big as it
+            // was. The same law the tick itself will apply a moment from now,
+            // so what is marked is what will actually happen.
+            if (outcome(a.polarity, facing) !== 'annihilate') continue;
 
             const p = pts.get(nd), q = pts.get(other);
             if (!p || !q || p.clipped || q.clipped) continue;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
index cc17a04..9a76e97 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
@@ -1,762 +1,46 @@
-import { CanvasView, Surface } from "./canvas";
-import { CYCLE, Source, SPIN } from "./lattice";
-import { AMBER, BACKGROUND, CYAN, ground, lift, source } from "./paint";
-
-/**
- * The whole of it as one expression, which is the other way of having it.
- *
- * The lattice in `discrete.ts` is the model run: a few thousand points, each one moved
- * or not moved by a rule that looks only at its neighbours, and a picture
- * reconstructed afterwards from where they all ended up. That is the honest
- * order to do it in — the rules are the claim, and the shape is whatever
- * comes out of them — but it is expensive twice over. Once in the running,
- * and once in the reading: a field made of points has to be turned back into
- * a field, and every choice in that reconstruction is a chance to draw
- * something the rules did not say.
- *
- * There is a second way, available only once you already know what the rules
- * make, and it is worth having precisely because it is derived rather than
- * assumed. A source at the origin turning at ω radians a tick, emitting the
- * charge of whichever pole faces a direction, and a wave that travels one
- * cell a tick. Then the charge at distance r in direction θ at time t is the
- * charge that left the source r ticks ago, when its axis pointed at
- * α + ω(t − r) rather than at α + ωt. So the field is
- *
- *     F(r, θ, t) = cos( lobes·θ − ω·(t − r) − α )
- *
- * and there is nothing else to it. No points, no reconstruction, no
- * neighbours to decide between: at any place and any moment the answer is
- * one cosine, and the picture is that cosine evaluated at every pixel.
- *
- * `lobes` is the only thing that separates the two cases in this article, and
- * it is not a parameter so much as a question about the source. One: it has
- * an axis, so what it emits depends on the direction — the field carries a θ
- * in it, the zero set is θ = ω(t − r) + const, and that is an Archimedean
- * spiral. Nought: it has no sides, so direction drops out altogether, the
- * zero set is r = t − const, and that is a set of rings travelling outward.
- * A spiral and a ring are the same function with and without an angle in it,
- * which is what it means to say the difference between the two sources is
- * that one turns and the other only flips.
- *
- * Several of them add. That is a claim rather than a definition, and it is
- * the one place this parts company with the model above: charges there do
- * not superpose, they meet and annihilate. But annihilation IS what addition
- * does to two opposite numbers, and the thing that survives it — the region
- * where one charge is left over — is what a sum of cosines has where they do
- * not cancel. So it is the right continuous shadow of a discrete rule, and
- * the places where the two disagree are exactly the places worth looking at.
- */
-export const LIGHT = 1;                                  // cells a wave goes in a tick
-
-export type Emitter = {
-  // Where it is, in cells.
-  at: [number, number];
-
-  // One if it has an axis and so has sides; nought if it puts out the same
-  // thing in every direction at once.
-  lobes: 0 | 1;
-
-  // Radians of pattern per tick, signed. Which way round it turns, for a
-  // source with sides; how fast it flips over, for one without.
-  omega: number;
-
-  // Where in the cycle it starts, which is the only thing one source can be
-  // against another.
-  phase: number;
-
-  /**
-   * How it is already going, in cells a tick, and it keeps going that way.
-   *
-   * There is no force in this model and so there is nothing for a velocity to
-   * be changed BY. A source that was set moving carries on moving, at the one
-   * speed its mass allows, in the direction it was sent; nothing here
-   * accelerates anything, and nothing here can slow anything down. What
-   * happens to a pair with momentum is not that they are pulled off course —
-   * it is that the space they are crossing goes on being eaten while they
-   * cross it, so the two end up closer together than their courses would have
-   * left them, without either having gone anywhere it was not already going.
-   *
-   * Which is a strange enough thing to be worth watching, and is the whole
-   * reason for these cases. An orbit that comes out of this is not a balance
-   * of a pull against an inertia. It is a drift that keeps carrying the two
-   * sideways while the gap between them keeps shortening underneath.
-   */
-  drift?: [number, number];
-
-  /**
-   * Ticks between one pulse and the next, or nothing for a source whose
-   * emission is continuous.
-   *
-   * The cases above emit without pause: the cosine is defined everywhere, so
-   * every point in the field is carrying something and there are no shells,
-   * only a phase that varies. That is the smooth reading of the model and it
-   * is a fair one, but it hides the thing the lattice version makes obvious —
-   * that what is emitted is a shell, that shells are discrete, and that
-   * annihilation is one of them meeting one of them.
-   *
-   * Given a beat, the emission becomes a train: a pulse leaves at every
-   * multiple of it and nothing leaves in between, so what travels out is a
-   * set of rings with space between them rather than a filled field. Which
-   * changes the arithmetic of the eating, and changes it in the direction
-   * that matters. Two sources pulsing every tick have a meeting every tick;
-   * two pulsing every OTHER tick have a meeting every other tick, so the gap
-   * between them goes at half the rate while their courses carry them along
-   * at exactly the speed they did. Moving as fast and eating half as quickly
-   * is the difference between a pair that is captured and a pair that has
-   * time to get somewhere first.
-   */
-  beat?: number;
-};
-
-/**
- * The same source the lattice was given, read as a cosine.
- *
- * This is the entire bridge between the two halves of the article, and it is
- * deliberately dull — every line of it is a change of units and none of it is
- * a change of claim. What the lattice does with a `Source` and what this does
- * with it have to be the same arrangement, or the two pictures are not
- * comparable and there is no point drawing them beside each other.
- *
- * The one thing worth reading twice is `lobes`, because it is where the whole
- * ring-or-spiral difference sits. A source that TURNS has an axis pointing
- * somewhere, so what it emits depends on the direction: the field carries a θ
- * in it, its zero set is θ = ω(t − r) + const, and that is an Archimedean
- * spiral. A source that only flips has no sides, so direction drops out
- * altogether, the zero set is r = t − const, and that is rings travelling
- * outward. Same function, with and without an angle in it.
- */
-export const emitterOf = (s: Source): Emitter => ({
-  at: [s.at[0] ?? 0, s.at[1] ?? 0],
-
-  lobes: s.turning ? 1 : 0,
-
-  // Which way round, for a source with sides; how fast it flips over, for one
-  // without. A source told to do neither stands still and holds its poles.
-  omega: s.turning ? SPIN * s.turning
-    : (s.flips ?? true) ? SPIN
-      : 0,
-
-  // Turns to radians, which is the only unit either side disagrees on.
-  phase: (s.phase ?? 0) * Math.PI * 2,
-
-  drift: s.drift ? [s.drift[0] ?? 0, s.drift[1] ?? 0] : undefined,
-
-  // A beat of one is a source that never pauses, which here is a field that
-  // is defined everywhere rather than a train of rings — so it is the absence
-  // of a beat and not a beat of one.
-  beat: s.beat && s.beat > 1 ? s.beat : undefined,
-});
-
-// How wide a pulse is, in ticks — so a ring is about this many cells thick to
-// either side of where its front is.
-const PULSE = 0.5;
-
-/**
- * As fast as a source goes, and here it goes almost as fast as anything can.
- *
- * One step a tick is this model's ceiling — a ray moves at most once per tick,
- * so nothing outruns the wave it emits — and mass is the only thing that
- * keeps anything under it: a step costs a source `MAGNET_MASS`, a tick pays
- * one, so a heavy source crawls. Set to within a percent of the ceiling
- * instead, these are as light as a thing can be and still be a thing.
- *
- * Not a percent short for safety's sake. At the ceiling exactly, everything a
- * source ever emitted in the direction it is going arrives at the same
- * moment, and the retarded time ahead of it stops having one answer — that is
- * a real feature of moving at the speed of your own light and not a numerical
- * complaint, but it is also the point past which nothing can be drawn,
- * because what is being asked for is not a number. A percent under, the
- * pile-up ahead is a hundredfold compression, which is a great deal to look
- * at and is still a finite thing.
- */
-export const PACE = 0.5 * LIGHT;
-
-
-
-/**
- * A source as it currently stands, and everywhere it has been.
- *
- * The past is not optional here. What is at distance r left r ticks ago, from
- * wherever the source was then — so a ring already in the air belongs to a
- * place, and that place does not move again however the thing that made it
- * carries on. Once these start eating they travel at half of light, and a
- * ring emitted twenty ticks ago is centred ten cells from where its source
- * now is; drawn from the present position instead, the whole field is hauled
- * about every time the speed changes, which is every frame, and what should
- * be a stack of settled layers becomes one object flapping.
- *
- * So it is remembered rather than extrapolated, at a couple of samples a
- * tick, which is finer than anything in the picture varies over.
- */
-const TRAIL = 0.5;                                // ticks between remembered places
-
-type Live = Emitter & {
-  // x then y, one pair per TRAIL of t, from the beginning of the run.
-  path: number[];
-
-  // How it is going now, which starts as its `drift` and is then turned by
-  // the space it is going through. Nothing ever changes its SPEED; see the
-  // flow below.
-  vel: [number, number];
-};
-
-// Where it was at a given moment, and how fast it was going then. Between
-// samples, and before the run began, the nearest thing it can honestly say.
-const RETARD: [number, number] = [0, 0];
-const CARRY: [number, number] = [0, 0];
-
-// Which way the thing `emit` just reported on is going.
-const WAY: [number, number] = [0, 0];
-
-const was = (s: Live, when: number) => {
-  const last = s.path.length / 2 - 1;
-  const k = Math.min(Math.max(when / TRAIL, 0), last);
-
-  const i = Math.floor(k), j = Math.min(i + 1, last);
-  const f = k - i;
-
-  RETARD[0] = s.path[2 * i] * (1 - f) + s.path[2 * j] * f;
-  RETARD[1] = s.path[2 * i + 1] * (1 - f) + s.path[2 * j + 1] * f;
-};
-
-const wasGoing = (s: Live, when: number) => {
-  was(s, when);
-
-  const ax = RETARD[0], ay = RETARD[1];
-
-  was(s, when - TRAIL);
-
-  CARRY[0] = (ax - RETARD[0]) / TRAIL;
-  CARRY[1] = (ay - RETARD[1]) / TRAIL;
-
-  RETARD[0] = ax; RETARD[1] = ay;
-};
-
 /**
- * When what is at a point now left the source that made it.
+ * EQUATIONS IN THIS FILE
  *
- * The retarded time is the root of |x − p(te)| = t − te, and how it is found
- * matters entirely at these speeds. The obvious way — guess r from where the
- * source is now, look up where it was that long ago, measure again — walks
- * towards the answer, and how fast it walks is exactly the source's speed:
- * each round takes off a fraction v of what is left. At a third of light that
- * is three good rounds and done. At ninety-nine hundredths it is six hundred,
- * which is not a thing that can be done once per source per sample of a
- * picture, sixty times a second.
+ *   S(x)      = Σ_{a<b} cancelling(Fa,Fb)·|Fa·Fb|·closing(d̂a,d̂b)
+ *                                                 annihilation, per place
+ *   share     = Σ cancelling / Σ meeting          how much of it is opposite
+ *   want      = BITE · share                      cells a tick, from the rule
  *
- * So it is solved rather than approached. Over the short stretch of trail the
- * answer lies in, the source is going in a straight line at a steady rate,
- * and for a straight line the equation is a quadratic in te and can simply be
- * written down. Two rounds of that — one to find roughly where to look, one
- * to solve properly with the velocity found there — lands on the answer
- * regardless of how near the ceiling the thing is travelling.
+ *   u(x)      = −Σ_k (q/2)·tanh(n̂·e / SPREAD)·exp(−(e×n̂ / LOCAL)²)·n̂
+ *                                                 the flow of space, |u| ≤ LIGHT
+ *   ḧ         = c²∇²h + (u − ḣ)·pull              carried, at the speed of light
+ *   river     = |ḣ|² / 2                          and half its square is
+ *   fall      = −∇ river                          ... the free-fall acceleration
  *
- * The position is then read from the trail rather than from the straight
- * line, so the answer is still a record of where the source actually was.
- * Nothing already emitted moves, which was the whole reason for keeping a
- * trail; the straight line is only ever used to work out WHEN to look.
- */
-const retard = (s: Live, x: number, y: number, t: number) => {
-  let te = t - Math.hypot(x - s.at[0], y - s.at[1]) / LIGHT;
-
-  /**
-   * Two passes, and the second one earned rather than assumed.
-   *
-   * The quadratic below is exact for a source going in a straight line at a
-   * steady rate — but the FIRST guess it starts from is taken from where the
-   * source is now, and for one travelling at ninety-nine hundredths of the
-   * speed of its own light that guess can be most of the picture out. The
-   * velocity then gets looked up at the wrong moment, the quadratic is solved
-   * for the wrong straight line, and the answer is wrong by however far the
-   * source moved in between. Which is not a small error politely spread
-   * about: it is a radius, so it comes out as rings in the wrong place, and
-   * they go wrong only where the source has been quick, which is why it looks
-   * like something tearing rather than something blurred.
-   *
-   * A second pass starts from an answer that is already close and settles it.
-   * Standing still, though, the first pass is exact and the second is a
-   * measurement of nothing — so it is skipped, which is most of the time in
-   * most of these pictures.
-   */
-  for (let pass = 0; pass < 2; pass++) {
-    wasGoing(s, te);
-
-    if (pass > 0 && Math.abs(CARRY[0]) + Math.abs(CARRY[1]) < 1e-6) break;
-
-    const ex = x - RETARD[0], ey = y - RETARD[1];
-    const vx = CARRY[0], vy = CARRY[1];
-
-    // How long there is between te and now, which is what the light has to
-    // cover — less however much further back the answer turns out to be.
-    const a = t - te;
-
-    const A = vx * vx + vy * vy - LIGHT * LIGHT;
-    const B = 2 * (a * LIGHT * LIGHT - (ex * vx + ey * vy));
-    const C = ex * ex + ey * ey - a * a * LIGHT * LIGHT;
-
-    let step = 0;
-
-    if (Math.abs(A) < 1e-9) {
-      if (Math.abs(B) > 1e-9) step = -C / B;
-    } else {
-      const disc = B * B - 4 * A * C;
-      if (disc < 0) break;
-
-      /**
-       * Solved the stable way, which at these speeds is not a nicety.
-       *
-       * A is v² − 1, and a source travelling at ninety-nine hundredths of
-       * light makes that about a fiftieth. Dividing by it is the textbook
-       * formula and it is exactly where the textbook formula falls apart:
-       * one of the two roots comes out as a small difference of two nearly
-       * equal numbers divided by a nearly vanishing one, and what it returns
-       * is not an approximation of the answer, it is thousands of cells of
-       * nonsense. Which is then used as a radius, so the rings it draws are
-       * nowhere near where anything is — and only where the source has been
-       * quick, which is why it tore rather than blurred.
-       *
-       * Taking the well-conditioned root first and getting the other from
-       * the product of the two has neither subtraction of like quantities nor
-       * division by the small coefficient.
-       */
-      const root = Math.sqrt(disc);
-      const q = -0.5 * (B + (B >= 0 ? root : -root));
-
-      const p1 = q / A, p2 = Math.abs(q) > 1e-12 ? C / q : q / A;
-
-      // Of the two, the one that leaves the light a non-negative time to
-      // travel in. The other is the advanced solution, which is the same
-      // algebra describing something arriving before it left.
-      const ok1 = a - p1 >= 0, ok2 = a - p2 >= 0;
-
-      step = ok1 && ok2 ? (Math.abs(p1) < Math.abs(p2) ? p1 : p2)
-        : ok1 ? p1
-          : ok2 ? p2
-            : 0;
-    }
-
-    te = Math.min(te + step, t);
-  }
-
-  return te;
-};
-
-/**
- * What ONE source puts at a point.
- *
- * Two things temper the bare cosine, and both are properties of the world
- * above rather than decoration. A wave has not arrived yet where r > t·c, so
- * there is nothing there — softened over a cell, since a lattice front is not
- * a razor either. And it thins as it goes, because the same emission is
- * spread over a bigger and bigger circle; in the model that shows up as the
- * shells growing apart, here as one over the distance.
+ *   wake(s)   = Σ± pace·ê / (2πr²)                what movement puts back
+ *   v̇         = fall − (fall·ĥ)ĥ                   turned only, never sped up
  *
- * And it is measured from where the source WAS, not from where it is: the
- * ring through this point left when the source was at p(t − r), and it is
- * centred there for good. Which is what makes a moving source's rings bunch
- * up ahead of it and stretch out behind, and at the speeds these reach once
- * they start eating, that bunching is most of what the picture shows.
- *
- * r is on both sides of that, so it is solved for rather than computed —
- * guess it from where the source is now, look up where it was that long ago,
- * measure again. Three rounds, because a source that is eating closes at the
- * speed of its own light and the answer directly ahead of it is then a near
- * thing: everything it emitted on the way arrives at once, which is a real
- * pile-up and not an artefact, and it takes a round or two to find. The trail
- * it looks things up in is a record rather than a projection, so nothing
- * already emitted can move again however hard the solve works.
  */
-const emit = (
-  s: Live, w: Emitter, x: number, y: number, t: number, reach: number,
-  known?: number,
-) => {
-  // Solving the retarded time is the most expensive thing here, and whoever
-  // called this has usually just done it — for the ray, for the cut, for the
-  // meeting surface. Told the answer, this does not do it a second time.
-  let te = known === undefined ? retard(s, x, y, t) : known;
-
-  was(s, te);
-
-  const dx = x - RETARD[0], dy = y - RETARD[1];
-  const r = Math.hypot(dx, dy);
-
-  // Which way what is here is travelling, which is out from wherever it left.
-  // Local, and needed by anything asking whether two things are meeting or
-  // merely crossing.
-  WAY[0] = r > 1e-9 ? dx / r : 1;
-  WAY[1] = r > 1e-9 ? dy / r : 0;
-
-  /**
-   * Nothing has arrived where the wave has not reached yet, softened over a
-   * cell because a lattice front is not a razor either.
-   *
-   * Only for a source emitting without pause. A pulse train has its own
-   * edges — the shape below is nought outside the pulse and that is the whole
-   * of where it is not — and applying this to one as well says something
-   * false about the first pulse of the train, which left at the very
-   * beginning and so IS the front: its own arrival is used as evidence that
-   * it has not arrived, and it is never drawn at all.
-   */
-  const front = w.beat ? 1 : Math.min((t * LIGHT - r) / 1.5, 1);
-  if (front <= 0) return 0;
-
-  const fade = 1 / (1 + r / reach);
 
-  /**
-   * cos(θ − ψ) without ever working out θ.
-   *
-   * The direction to here is wanted only inside a cosine, and cos(θ − ψ) is
-   * cos θ·cos ψ + sin θ·sin ψ — where cos θ and sin θ are dx/r and dy/r,
-   * which are already to hand. So the arctangent, which is the most expensive
-   * thing in this whole expression and is evaluated once per source per
-   * sample of the picture, is not needed at all.
-   */
-  /**
-   * When what is here left, and — if this source pulses — whether anything
-   * left then at all.
-   *
-   * A pulse train is not a sum over pulses. The nearest multiple of the beat
-   * to the emission time IS the pulse this point could belong to, since the
-   * pulses are narrower than the gaps between them, so one rounding finds it
-   * and one bump says how much of it is here. Everything stays O(1) in the
-   * number of pulses in the air, which by now is a great many.
-   */
-  let shape = 1;
-
-  if (w.beat) {
-    const beat = Math.round(te / w.beat) * w.beat;
-    const u = (te - beat) / PULSE;
-
-    if (u <= -1 || u >= 1 || beat < 0) return 0;
-
-    shape = (1 - u * u) ** 2;
-    te = beat;
-  }
-
-  const psi = w.omega * te + w.phase;
-
-  const wave = w.lobes
-    ? (dx * Math.cos(psi) + dy * Math.sin(psi)) / (r || 1)
-    : Math.cos(psi);
-
-  return front * fade * shape * wave;
-};
-
-/**
- * And what the two of them do to each other when they are ALIKE, which the
- * sum on its own does not contain.
- *
- * Opposite charges meeting head-on annihilate, and that is the gravity above.
- * Like charges meeting head-on turn each other around, and nothing so far has
- * said so — the closed form adds the two contributions and lets them through
- * one another.
- *
- * For most of these pictures that is not the omission it looks like. Two
- * identical shells bouncing off each other are indistinguishable from two
- * shells passing through and swapping names: A's charge ends up where B's
- * would have been and B's where A's would have been, so the set of places
- * that are charged is the same either way, and so is the phase at each of
- * them — the bounced charge has travelled exactly as far as the one that came
- * the other way. The field cannot tell, because the field does not record
- * which source anything belongs to. Superposition is already right, and the
- * waves not visibly turning around is not a thing going wrong.
- *
- * It stops being right the moment the two are not interchangeable. A bounced
- * wave carries the phase and the cadence of the source it came from, and
- * fades with the distance IT has travelled — and if the two sources are half
- * a cycle apart, or pulsing at different rates, or one of them is moving and
- * the other is not, then what comes back is not what would have gone through
- * and the exchange does not cancel.
- *
- * A reflection is an image: the wave that bounced arrives as though it had
- * come from the mirror of its source in the surface it bounced off. That
- * surface, for a pair, is the plane halfway between them — so the mirror of
- * one source is the position of the other, and what comes back is the OTHER
- * one's geometry carrying THIS one's phase. Which is why the two swap out
- * exactly when they are alike, and why they do not otherwise.
- *
- * So the field is the two readings blended by how much of the meeting is
- * alike rather than opposite, which `survey` measures on its way past. For
- * matched sources the reflected pair is the direct pair with the names
- * exchanged, the blend is between a thing and itself, and it reduces to the
- * plain sum with nothing left over.
- */
-/**
- * How far a wave of `a`'s gets before it runs into one of `b`'s.
- *
- * Both travel a cell a tick, so waves that left at the same moment meet
- * halfway — and along a ray that is not aimed straight at the other source,
- * further, because the surface they meet on is a plane and a slanted ray has
- * further to go to reach it. Aimed away from the other source it never meets
- * anything at all, and goes on for ever.
- *
- * This is the only thing that stops a wave, and it stops it completely. There
- * is no thinning, no optical depth, no fraction getting through. A charge
- * meets another charge and one of two things happens, and neither of them is
- * "carries on a bit weaker".
- */
-const HERE: [number, number] = [0, 0];
-const THERE: [number, number] = [0, 0];
-
-const meets = (
-  a: Live, b: Live, dx: number, dy: number, when: number,
-) => {
-  /**
-   * Worked out from where the two of them WERE, not from where they are.
-   *
-   * This is the whole of what makes it local, and getting it wrong is
-   * unmistakable: a wave that left long ago has its stopping place decided by
-   * a surface built out of the sources' present positions, so every time
-   * either of them turns or drifts, the surface swings and every wave already
-   * in the air swings with it. Rings that were laid down years of ticks ago
-   * get up and rotate, which is not a thing waves do. Nothing that has
-   * already happened is allowed to depend on anything that happened after it.
-   *
-   * So both are asked where they were when this wave was in the air, and the
-   * answer is a record — see the trail — rather than anything derived from
-   * now. What was decided then stays decided.
-   */
-  was(a, when);
-  HERE[0] = RETARD[0]; HERE[1] = RETARD[1];
-
-  was(b, when);
-  THERE[0] = RETARD[0]; THERE[1] = RETARD[1];
-
-  let ux = THERE[0] - HERE[0], uy = THERE[1] - HERE[1];
-  const gap = Math.hypot(ux, uy);
-  if (gap < 1e-6) return Infinity;
-
-  ux /= gap; uy /= gap;
-
-  const aim = dx * ux + dy * uy;
-
-  /**
-   * And only where the two would actually be head-on when they got there.
-   *
-   * The surface halfway between a pair is a whole plane, and it is tempting
-   * to stop everything at it — but two waves arriving at a point far out on
-   * that plane are not meeting, they are travelling side by side. Their
-   * directions there are mirror images about the plane, so the angle between
-   * them is set by how squarely the ray was aimed: dead at the other source
-   * they are exactly opposed, and at forty-five degrees off they are already
-   * at right angles and past caring about each other.
-   *
-   * Beyond that the encounter is a crossing. Charges crossing at an angle do
-   * nothing to each other in this model — they pass, and both carry on — so
-   * stopping them there would put a seam down the middle of every picture
-   * where none belongs, and it is why the arms far from the axis have to go
-   * through one another. They are not meeting. They are just both there.
-   */
-  if (aim <= 0.71) return Infinity;
-
-  return (gap / 2) / aim;
-};
-
-/**
- * A wave of `a`'s that has met one of `b`'s and turned around.
- *
- * Which of the two things happened at that meeting is decided THERE, by what
- * the two of them were, and not by any running average over the picture. Two
- * charges meeting head-on are alike or they are opposite; alike, they turn
- * each other round and both go back the way they came; opposite, they
- * annihilate and neither of them is anywhere afterwards. So this asks the
- * question at the place and the moment it was settled: what was `a` putting
- * out along this ray when it got to the meeting, and what was `b` putting
- * into the same spot at the same instant. Same sign, and there is a wave
- * coming home. Opposite, and there is nothing — which is the annihilation,
- * and it needs no separate machinery, because a thing that annihilated simply
- * has no return.
- *
- * And what comes home runs into the shells its own source has emitted since,
- * head-on, going the other way. A source that turns over is putting out the
- * opposite charge by then, so what the returning wave meets is its opposite,
- * and the two cancel. That is the second half of what makes the space between
- * a pair empty, and it falls out of the arithmetic rather than being put in:
- * these are all terms in one sum, and terms of opposite sign cancel.
- *
- * The going-out and the coming-back are the same wave with the sign of the
- * radius flipped. Outgoing at distance r left r ago, so its phase runs on
- * t − r and crests move outward. Having gone to the meeting at R and come
- * back to r it has travelled 2R − r, so its phase runs on t − 2R + r and
- * crests move inward. One sign, and that sign is the whole of what bouncing
- * is.
- */
-const bounced = (
-  a: Live, b: Live, x: number, y: number, t: number, reach: number,
-  known?: number, given?: number,
-) => {
-  // From where it was when this left it, for the reason given in `fieldAt`.
-  const left = known === undefined ? retard(a, x, y, t) : known;
-
-  was(a, left);
-
-  let dx = x - RETARD[0], dy = y - RETARD[1];
-  const r = Math.hypot(dx, dy);
-  if (r < 1e-6) return 0;
-
-  dx /= r; dy /= r;
-
-  // Asked of the moment this wave was crossing, not of now — or handed
-  // straight over by whoever has already asked.
-  const mirror = given === undefined ? meets(a, b, dx, dy, left) : given;
-  if (!isFinite(mirror) || r >= mirror) return 0;   // nothing has come back to here
-
-  // Out to the meeting and back again: how far this has travelled, and so
-  // how long ago it left.
-  const path = 2 * mirror - r;
-  const te = t - path / LIGHT;
-  if (te < 0) return 0;
-
-  // As above: a train's own pulse shape says where it is, and this would
-  // erase the first of them.
-  const front = a.beat ? 1 : Math.min((t * LIGHT - path) / 1.5, 1);
-  if (front <= 0) return 0;
-
-  let when = te, shape = 1;
-
-  if (a.beat) {
-    const beat = Math.round(when / a.beat) * a.beat;
-    const u = (when - beat) / PULSE;
-
-    if (u <= -1 || u >= 1 || beat < 0) return 0;
-
-    shape = (1 - u * u) ** 2;
-    when = beat;
-  }
-
-  const psi = a.omega * when + a.phase;
-
-  // The angle is the one it LEFT along, since that is the half of the source
-  // it came out of.
-  const mine = a.lobes ? dx * Math.cos(psi) + dy * Math.sin(psi) : Math.cos(psi);
-  if (mine === 0) return 0;
-
-  // What the other one had at that spot when this arrived there. Same sign,
-  // and the two turned each other round; opposite, and they are both gone.
-  was(a, left);
-
-  const hitX = RETARD[0] + dx * mirror, hitY = RETARD[1] + dy * mirror;
-  const struck = t - (mirror - r) / LIGHT;
-
-  const theirs = emit(b, b, hitX, hitY, struck, reach);
-
-  const agree = (mine * theirs) / (Math.abs(mine) * Math.abs(theirs) + 1e-9);
-  const alike = Math.max(agree, 0);
-  if (alike <= 1e-3) return 0;
-
-  // Softened right at the meeting surface, which is a place and not a knife.
-  const edge = Math.min(Math.max((mirror - r) / 1.5, 0), 1);
-
-  /**
-   * Thinned by where it IS, not by how far it has been — which is the
-   * opposite of what it looks like it should be, and is why this was so hard
-   * to see.
-   *
-   * The thinning is a shell spread round a growing circle: the same emission
-   * stretched over a longer and longer ring, so it goes as the radius. A
-   * shell coming home sits on a circle exactly the size of an outgoing
-   * shell's at the same radius, and it is CONTRACTING — its charges are being
-   * gathered back onto a shorter and shorter ring, so it gets denser as it
-   * returns rather than fainter.
-   *
-   * Faded by the whole path instead, as it was, a returning wave is dimmed by
-   * twice the distance to the surface while the outgoing wave drawn at the
-   * same place is dimmed by almost nothing. It was in the arithmetic and
-   * underneath the wave it had bounced off, worst of all near the source
-   * where it should have been brightest.
-   *
-   * The path still sets the phase. How far a thing has travelled is when it
-   * left; it is not how spread out it is.
-   */
-  return alike * edge * front * shape * mine / (1 + r / reach);
-};
+import { CanvasView, Surface } from "./canvas";
+import {
+  Emitter, emit, fieldAt, Live, retard, TRAIL, was, wasGoing,
+  CARRY, RETARD, WAY,
+} from "./field";
+import { CYCLE } from "./lattice";
+import { BITE, cancelling, closing, LIGHT } from "./physics";
+import { AMBER, BACKGROUND, CYAN, ground, lift, source } from "./paint";
 
 /**
- * What is at a place: everything that got there, going out and coming back.
+ * Gravity as a flow: space is given a speed, and everything is carried by it.
  *
- * A plain sum, and it can be, because nothing in it is a wave that should not
- * be there. A wave stops dead at the first thing it meets — that is `meets`
- * above, applied to every outgoing term — so two sources' waves never overlap
- * beyond their meeting surface and there is no crossing to suppress. What is
- * left to add up is a handful of waves that genuinely coexist, and adding is
- * the right thing to do with those: where two of them are opposite they
- * cancel, which is annihilation, drawn.
+ * This is the older of the two accounts in this article and the more
+ * elaborate. It measures where annihilation is happening, turns that into a
+ * velocity field for the space itself, gives that field a wave equation so it
+ * travels at the speed of light, and then carries each source by the flow it
+ * is standing in and turns it by how steeply that flow falls away.
  *
- * Which is why the returning wave puts out the space between a pair without
- * anything being written to make it. It comes home into shells its own source
- * threw out later, and a source that turns over threw the opposite charge;
- * they are opposite terms in a sum, and they go.
+ * `metric.tsx` is the other account, and it says the same thing far more
+ * directly — that annihilation does not push anything, it removes the space,
+ * and everything else is what is left of the geometry. Both are drawn from
+ * the same field (`field.ts`), so what they disagree about is only what
+ * annihilation DOES, which is the thing worth seeing two ways.
  */
-const MIRRORS: number[] = [];
-
-const fieldAt = (
-  x: number, y: number, t: number, sources: Live[], reach: number,
-) => {
-  let total = 0;
-
-  for (const a of sources) {
-    /**
-     * Measured from where this source WAS when the wave here left it.
-     *
-     * Not from where it is. The two are the same thing only for a source
-     * standing still, and these travel at ninety-nine hundredths of the speed
-     * of what they emit — so the distance to the present source and the
-     * distance the wave actually came differ by most of the picture. Taking
-     * the ray and the radius from the present position while the surface it
-     * is being cut against is worked out from the past one is two different
-     * geometries compared against each other, and what that produces is a
-     * cut at the wrong radius: a hole where a wave was stopped that never met
-     * anything, standing between the pair and following them about.
-     */
-    const when = retard(a, x, y, t);
-
-    was(a, when);
-
-    let dx = x - RETARD[0], dy = y - RETARD[1];
-    const r = Math.hypot(dx, dy) || 1e-9;
-
-    dx /= r; dy /= r;
-
-    // As far as the nearest thing that was in the way when it went past, and
-    // no further.
-    let stop = Infinity;
-    let seen = 0;
-
-    for (const b of sources) {
-      if (b === a) continue;
-
-      const at = meets(a, b, dx, dy, when);
-
-      MIRRORS[seen++] = at;
-      if (at < stop) stop = at;
-    }
-
-    if (r < stop) {
-      // Faded over a cell at the surface, so the end of a wave is a place
-      // rather than an event.
-      const edge = isFinite(stop) ? Math.min((stop - r) / 1.5, 1) : 1;
-
-      total += emit(a, a, x, y, t, reach, when) * edge;
-    }
-
-    // Only where something was in the way. Over most of any of these pictures
-    // nothing is — a ray not aimed at the other source never meets it — and
-    // asking `bounced` anyway means solving a retarded time and a meeting
-    // surface all over again to be told so.
-    seen = 0;
-
-    for (const b of sources) {
-      if (b === a) continue;
-
-      const mirror = MIRRORS[seen++];
-      if (!isFinite(mirror) || r >= mirror) continue;
-
-      total += bounced(a, b, x, y, t, reach, when, mirror);
-    }
-  }
-
-  return total;
-};
 
 /**
  * Where space is being destroyed, asked of places rather than of pairs.
@@ -792,15 +76,16 @@ const fieldAt = (
 const SITES: number[] = [];                       // x, y, eaten, nx, ny, met — six at a time
 let siteCount = 0;
 
-/**
- * How much space a tick's worth of meeting destroys, which is the one number
- * tying the continuous rate to the discrete one.
+/*
+ * How much space a tick's worth of meeting destroys is `BITE`, and it is the
+ * one number tying this rate to the lattice's — stated with the other laws
+ * rather than here, because it is not a fact about the survey.
  *
  * A source emits a shell every tick and shells travel a cell a tick, so along
  * any line between two of them one shell meets one shell every tick, and a
- * meeting of opposites takes two cells out of the world. That is the whole of
- * the rate, and it is a COUNT — one meeting, two cells — with nothing in it
- * about how large the region is where the meeting happens.
+ * meeting of opposites takes two cells out of the world. That is a COUNT —
+ * one meeting, two cells — with nothing in it about how large the region is
+ * where the meeting happens.
  *
  * Which is the thing the survey below cannot supply and must not be asked to.
  * It measures a density, and a density integrated over an area gives a number
@@ -808,16 +93,9 @@ let siteCount = 0;
  * picture than two close together, and reading their annihilation off that
  * integral has them eating faster the further apart they are, which is not
  * merely wrong but backwards. Everything the survey knows is WHERE the eating
- * is happening and along what. How MUCH is set here, by the cadence, and
- * shared out over the places in proportion to what is going on at each.
- *
- * So the survey's numbers are a shape and this is the size of it. The one
- * thing left for the survey to say about magnitude is the share — how much of
- * what meets is opposite rather than alike — which is dimensionless, is
- * between nought and one, and is exactly what it should be reporting: a pair
- * eating all of what they send each other, or half of it, or none.
+ * is happening and along what. How MUCH is set by the cadence, and shared out
+ * over the places in proportion to what is going on at each.
  */
-const BITE = 2 * LIGHT;
 
 /**
  * And how far the loss of a point is felt, which is not far.
@@ -914,7 +192,7 @@ const survey = (live: Live[], t: number, reach: number, span: number) => {
   // What the picture is doing as a whole: how much of what meets is opposite,
   // and how much meets at all. Their ratio is the only thing about magnitude
   // the survey has any business reporting.
-  let cancelling = 0, meeting = 0;
+  let cancelled = 0, meeting = 0;
 
   for (let gy = 0; gy < STEPS; gy++) {
     const y = my - look + (gy + 0.5) * step;
@@ -930,26 +208,32 @@ const survey = (live: Live[], t: number, reach: number, span: number) => {
       // What is annihilating here, and what is meeting here at all — which
       // is more, because alike charges meeting head-on turn around rather
       // than cancelling, and either way they stop going forwards.
-      let rate = 0, here = 0, nx = 0, ny = 0;
+      let eaten = 0, here = 0, nx = 0, ny = 0;
 
       for (let i = 0; i < live.length; i++) {
         for (let j = i + 1; j < live.length; j++) {
-          const both = val[i] * val[j];
-
           // How much of what is here is one field against the other at all,
-          // whichever way round — the denominator of the share.
-          const closing = Math.max(-(dirX[i] * dirX[j] + dirY[i] * dirY[j]), 0);
-          if (closing <= 0) continue;             // crossing, not meeting
-
-          here += Math.abs(both) * closing;
-          meeting += Math.abs(both) * closing;
-
-          // Opposite in charge as well as opposed in direction: annihilation
-          // rather than a bounce.
-          const against = Math.max(-both, 0) * closing;
+          // whichever way round — the denominator of the share. Two things
+          // annihilate when they are opposite in charge AND opposed in
+          // direction, and one without the other is a crossing rather than a
+          // collision, so both factors have to be in it.
+          const closes = closing(
+            [dirX[i], dirY[i]], [dirX[j], dirY[j]],
+          );
+          if (closes <= 0) continue;              // crossing, not meeting
+
+          const strength = Math.abs(val[i] * val[j]) * closes;
+
+          here += strength;
+          meeting += strength;
+
+          // And opposite in charge as well: annihilation rather than a
+          // bounce. The same law the lattice reads at ±1 to get
+          // 'annihilate' — see `cancelling`.
+          const against = cancelling(val[i], val[j]) * strength;
           if (against <= 0) continue;
 
-          rate += against;
+          eaten += against;
 
           // The line they are meeting along, which is the line that shortens.
           nx += (dirX[i] - dirX[j]) * against;
@@ -959,11 +243,11 @@ const survey = (live: Live[], t: number, reach: number, span: number) => {
 
       if (here <= 0) continue;
 
-      cancelling += rate;
+      cancelled += eaten;
 
       const len = Math.hypot(nx, ny) || 1;
 
-      SITES.push(x, y, rate, nx / len, ny / len, here);
+      SITES.push(x, y, eaten, nx / len, ny / len, here);
       siteCount++;
 
       if (here > strongest) strongest = here;
@@ -1030,7 +314,7 @@ const survey = (live: Live[], t: number, reach: number, span: number) => {
    * distribution stays exactly what was measured and the total stops being an
    * accident of how much of the picture the two fields happen to overlap in.
    */
-  const share = meeting > 1e-12 ? cancelling / meeting : 0;
+  const share = meeting > 1e-12 ? cancelled / meeting : 0;
 
   /**
    * And the size of it is fixed by what the pair actually do to each other,
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
index bebb861..902f790 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
@@ -1,7 +1,51 @@
+/**
+ * EQUATIONS IN THIS FILE
+ *
+ *   the tick, per ray:
+ *     meeting head-on  →  outcome(a, b)           annihilate, or turn around
+ *     otherwise        →  move, which is a swap
+ *
+ *   movement is a swap:
+ *     emitBehind   a fresh point spliced in behind, at (here + there)/2
+ *     consumeAhead the point in front taken, and its structure kept
+ *     so the population is unchanged by moving: one made, one eaten
+ *
+ *   credit += 1 each tick,  a step costs `mass`   one cell per mass ticks
+ *
+ *   annihilate: the two points go, and what was behind each closes onto what
+ *   was behind the other — so the path between two things is shorter by
+ *   exactly the points that met. That IS the gravity.
+ *
+ *   layout, relaxed against the structure:
+ *     rest_ij   = |step(pi − pj)| · scale         one step, in its direction
+ *     weight_ij = 1 + (spans − 1)·adjacency       a connection over dead space
+ *     dpi       = Sum_j w·(|p| − rest)/|p| · (pj − pi)/2  /  Sum_j w
+ *
+ *   layout, cube to sphere:
+ *     p = cube·(1 − t) + sphere·t,  t = smoothstep(ring)
+ *
+ */
+
 import {
-  axes, CYCLE, directions, latticeStep, LATTICE_STEP, opposite, Polarity,
-  randomPolarity, shuffle, Source, speedOf, TURN, turnRing, Vec, World,
+  axes, directions, dot, latticeStep, LATTICE_STEP, TURN, turnRing, unit, Vec,
 } from "./lattice";
+import {
+  ALONG, bearing, emission, massFor, opposite, outcome, Polarity, quantised,
+  randomPolarity, sided, Source, speedOf, World,
+} from "./physics";
+
+// A fresh order, so that what interacts with what is a draw rather than an
+// artefact of the order things happen to sit in.
+const shuffle = <T,>(arr: T[]): T[] => {
+  const out = arr.slice();
+
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [out[i], out[j]] = [out[j], out[i]];
+  }
+
+  return out;
+};
 
 // Every coordinate of a `size`-wide box in `dims` dimensions, from the origin
 // out. What a seed does with them is its own business; enumerating them is
@@ -59,49 +103,6 @@ export const perPoint = (draw: () => Polarity = randomPolarity) => {
   };
 };
 
-/**
- * How much harder a source is to move than the charges it emits: a multiple
- * of the step's own length, paid out of the same one-per-tick everything else
- * is paid (see the movement half of `tick`). It is mass, arrived at from the
- * only direction this model offers — the cost of going somewhere.
- *
- * A source at mass m covers 1/m cells a tick. Two conditions decide whether a
- * moving pair can interact at all, and both are arithmetic rather than
- * judgement:
- *
- *  - One step a tick is this model's top speed — a ray moves at most once per
- *    tick, so nothing goes faster and the field cannot be sped up to keep
- *    pace. Two sources heading opposite ways separate at 2/m, and their light
- *    closes at 1, so anything each emits can only ever reach the other while
- *    2/m < 1. At m = 1 they are outrunning their own field from the first
- *    tick; at m = 2 the light exactly keeps pace and never gains. It takes
- *    m > 2 before a pulse can cross from one to the other at all.
- *
- *  - And a source can only emit onto a point it is connected to. Once it has
- *    travelled out of the seeded ball it is in territory `grow` laid down one
- *    node at a time as it went, with nothing on the far side of its other
- *    twenty-five directions, so it stops radiating in all but the one it is
- *    heading in. Over a 60-tick run it moves 60/m, and starting 8 out along x
- *    it stays inside the absorbing edge at 11 while √(8² + (60/m)²) ≤ 11 —
- *    which wants m ≥ 8.
- *
- * Eight is what those two conditions ask for together. The value below is the
- * one the runs in this article are actually set to, and it is smaller: these
- * are shorter runs at closer quarters than that derivation assumes, and a
- * source at eight barely moves within one of them. A source given a `drift`
- * overrides it outright — see `massFor` — since a stated speed is a stated
- * mass, and this is only what a source that was never told how fast to go
- * falls back on.
- */
-export const MAGNET_MASS = 3;
-
-// What a step costs a source that was told how fast to go. A step is one
-// cell, a tick pays one, so covering `speed` cells a tick costs 1/speed —
-// and nothing goes quicker than a cell a tick, which is where the floor
-// comes from.
-export const massFor = (speed?: number) =>
-  speed && speed > 0 ? Math.max(1 / speed, 1) : MAGNET_MASS;
-
 // Two rays meeting head-on, over the connection whose mutual boundaries are
 // `a` and `b`. Opposite charges cancel; like ones turn around. Movement isn't
 // here because it isn't an interaction: it is what a ray does when nothing is
@@ -442,8 +443,8 @@ export class Graph {
       const d = this.direction(option);
       if (!d) continue;
 
-      const dot = sign * d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
-      if (dot > bestDot) { bestDot = dot; best = option; }
+      const along = sign * dot(d, dir);
+      if (along > bestDot) { bestDot = along; best = option; }
     }
 
     return best ?? options[0];
@@ -467,8 +468,8 @@ export class Graph {
       const d = this.direction(option);
       if (!d) continue;
 
-      const dot = -d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
-      if (dot > bestDot) { bestDot = dot; best = option; }
+      const back = -dot(d, dir);
+      if (back > bestDot) { bestDot = back; best = option; }
     }
 
     return best;
@@ -508,8 +509,7 @@ export class Graph {
         const d = this.direction(bd);
         if (!d) continue;
 
-        const along = Math.abs(d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0));
-        if (along < 0.9) out.push(bd);
+        if (Math.abs(dot(d, dir)) < ALONG) out.push(bd);
       }
     }
 
@@ -1083,13 +1083,13 @@ export class Graph {
         const d = this.direction(bd);
         if (!d || !dir) continue;
 
-        const dot = d.reduce((sum, v, i) => sum + v * (dir[i] || 0), 0);
+        const forward = dot(d, dir);
 
         // Forwards, at least. A connection at right angles or behind is not a
         // continuation of anything, it is a different journey.
-        if (dot <= straightest) continue;
+        if (forward <= straightest) continue;
 
-        straightest = dot;
+        straightest = forward;
         onward = bd;
         onwardStep = this.bare(bd);
       }
@@ -1379,14 +1379,7 @@ export class Graph {
 
       met.add(r); met.add(r2);
 
-      // Only two actual charges, one of each, cancel. Neutral space has no
-      // charge to cancel with, so anything else that meets head-on turns
-      // around instead.
-      const opposed =
-        (a.polarity === Polarity.Positive && b.polarity === Polarity.Negative) ||
-        (a.polarity === Polarity.Negative && b.polarity === Polarity.Positive);
-
-      collisions.push({ kind: opposed ? 'annihilate' : 'turn', r, a, r2, b });
+      collisions.push({ kind: outcome(a.polarity, b.polarity), r, a, r2, b });
     }
 
     /**
@@ -1457,9 +1450,7 @@ export class Graph {
        */
       if (r.source !== undefined && r.source === other.source) continue;
 
-      const opposed =
-        (a.polarity === Polarity.Positive && b.polarity === Polarity.Negative) ||
-        (a.polarity === Polarity.Negative && b.polarity === Polarity.Positive);
+      const kind = outcome(a.polarity, b.polarity);
 
       met.add(r); met.add(other);
 
@@ -1482,17 +1473,11 @@ export class Graph {
        * The space between the two still gets eaten; it takes one more step
        * about it.
        */
-      if (!opposed) {
-        arriving.delete(there); // both going back the way they came
-
-        collisions.push({ kind: 'turn', r, a, r2: other, b });
-
-        continue;
-      }
+      // Both gone, or both going back the way they came: either way the
+      // place is free again.
+      arriving.delete(there);
 
-      arriving.delete(there); // both gone; the place is free again
-
-      collisions.push({ kind: 'annihilate', r, a, r2: other, b });
+      collisions.push({ kind, r, a, r2: other, b });
     }
 
     const removed = new Set<node>();
@@ -2385,53 +2370,40 @@ export class Graph {
             // universe several times the size it was seeded at.
             const written = new Set<node>();
 
-            // A magnet that turns is somewhere else by now. Its axis steps
-            // round the plane an eighth of a turn every `turnEvery` ticks,
-            // one way or the other, and everything below reads it as it
-            // stands rather than as it was set.
+            /**
+             * Where this one is pointing by now, in turns.
+             *
+             * One expression for both kinds of source, which is the article's
+             * claim about them rather than a convenience: a rotation through
+             * the eight directions of a plane and a flip held half the time
+             * each way take exactly as long, so both lay their structure down
+             * at the same spacing. What separates them is not the clock — it
+             * is whether the state the clock advances has a direction in it.
+             * See `bearing` and `sided`.
+             */
+            const beta = bearing(ray, since);
+
+            // A magnet that turns is somewhere else by now: its axis is that
+            // bearing rounded onto the directions the plane actually has, an
+            // eighth of a turn at a time, one way or the other. Everything
+            // below reads it as it stands rather than as it was set.
             if (ray.turning) {
               const ring = ray.ring ?? TURN;
-              // `phase` is in turns, so a whole ring of them is what it
-              // counts against.
-              const step = Math.floor(since / turnEvery) * ray.turning
-                + Math.round((ray.phase ?? 0) * ring.length);
+              const step = Math.round(beta * ring.length / turnEvery) * turnEvery;
 
               ray.axis = ring[((step % ring.length) + ring.length) % ring.length];
             }
 
             const emits = ray.emits ?? Polarity.Positive;
 
-            /**
-             * One turn of a source takes a turn's worth of ticks, whatever
-             * kind of turning it does.
-             *
-             * A source that rotates comes round through the eight directions
-             * of its plane, one a tick, and is back where it started after
-             * eight. A source that only flips over has two states rather than
-             * eight — and flipping between them every tick made its cycle
-             * four times shorter than the other's, which is not a difference
-             * in kind between the two sources but an accident of counting.
-             *
-             * What it cost was space. Each ring a wave lays down is one
-             * tick's emission, and a wave advances a cell a tick, so a cycle
-             * of two ticks puts the same charge every other cell: bands one
-             * cell wide with one cell between them, which no drawing can
-             * separate and which average to nothing the moment they are
-             * smoothed. Held for half a cycle each way, the same source lays
-             * down bands four cells wide with four cells between them, and
-             * they are bands you can see.
-             *
-             * The two then differ only in what the state is FOR. A flip is
-             * the same everywhere at once, so what it writes is rings. A
-             * rotation points somewhere, so what it writes is spirals. Same
-             * clock, same wave, same spacing — the difference is whether the
-             * source's state has a direction in it.
-             */
-            const cycle = ray.turning ? TURN.length : CYCLE;
-            const turn = pulse + (ray.phase ?? 0) * cycle;
-            const turned = ray.flips && ((turn % cycle) + cycle) % cycle >= cycle / 2;
+            // Whether it has sides at all, which is the whole of what
+            // separates a magnet from a lamp — and the one thing that decides
+            // whether what leaves it is a spiral or a set of rings.
+            const hasSides = sided(ray);
 
-            const polarity = turned ? opposite(emits) : emits;
+            // North, one long, so that a direction can be resolved against
+            // it. A source with no sides has none, and does not need one.
+            const north = ray.axis && unit(ray.axis);
 
             // Every direction at once: the pulse is written onto everything
             // the source is connected to, and each point of it leaves along
@@ -2462,27 +2434,33 @@ export class Graph {
               const dir = g.direction(bd);
               if (!dir) continue;
 
-              // Which pole this direction is out of. A source with no axis
-              // has no poles and puts the same thing out everywhere; one with
-              // an axis puts `polarity` out of the half facing along it and
-              // the opposite out of the half facing back, with the ring
-              // exactly across it emitting nothing — an equator, which is
-              // what makes it a magnet and not a lamp.
-              let out = polarity;
-
-              // How nearly this direction lies along the magnet's axis: +1
-              // straight out of the north pole, −1 out of the south, 0 on the
-              // equator between them.
-              const cos = ray.axis
-                ? dir.reduce((sum, v, i) => sum + v * (ray.axis![i] ?? 0), 0)
-                  / (Math.hypot(...ray.axis) || 1)
-                : 0;
+              /**
+               * What this source puts out in this direction, by the one law
+               * both readings are written against — see `emission`.
+               *
+               * A source with no sides has no poles and puts the same thing
+               * out everywhere, so the direction drops out and what is left
+               * is a cosine of where it is in its cycle. One with sides puts
+               * `emits` out of the half facing north and the opposite out of
+               * the half facing back, with the ring exactly across it putting
+               * out nothing at all — an equator, which is what makes it a
+               * magnet and not a lamp.
+               *
+               * The lattice then rounds that to a charge, because a point
+               * either carries one or does not. `quantised` is where the
+               * rounding is stated, including the one place it differs
+               * between the two kinds: an equator is a real answer of nought,
+               * and a source with no equator has no such answer to give.
+               */
+              const strength = emission(hasSides, beta, () => dot(dir, north!));
 
-              if (ray.axis) {
-                if (Math.abs(cos) < 1e-9) continue; // the equator emits nothing
+              const charge = quantised(strength, hasSides, beta);
+              if (charge === Polarity.Neutral) continue; // the equator
 
-                if (cos < 0) out = opposite(polarity);
-              }
+              // Which way round the source is putting it out. `emits` is what
+              // its north pole gives, so a positive strength is that and a
+              // negative one is its opposite.
+              const out = charge === Polarity.Positive ? emits : opposite(emits);
 
               /**
                * A magnet that turns radiates into the plane it turns in.
@@ -2644,8 +2622,8 @@ export class Graph {
             // the ring of directions across our path, which is the front
             // itself: the shell grows sideways, into the room a bigger shell
             // has that a smaller one didn't.
-            const along = d.reduce((sum, v, i) => sum + v * dir[i], 0);
-            if (along < spread || along > 0.9) continue;
+            const along = dot(d, dir);
+            if (along < spread || along > ALONG) continue;
 
             for (const r of there)
               for (const x of r.boundaries) x.polarity = polarity;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
new file mode 100644
index 0000000..cfdf1f1
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
@@ -0,0 +1,733 @@
+/**
+ * EQUATIONS IN THIS FILE
+ *
+ *   |x − p(tₑ)|  = c(t − tₑ)                      the retarded time, solved
+ *   r            = |x − p(tₑ)|,  d̂ = (x − p)/r    and what it left along
+ *
+ *   emit         = front · fade · shape · F(d̂)    what one source puts here
+ *     front      = min((ct − r)/1.5, 1)           nothing before it arrives
+ *     fade       = 1 / (1 + r/reach)              spread over a bigger circle
+ *     shape      = (1 − u²)²,  u = (tₑ − nT)/PULSE    a pulse, if it beats
+ *     F(d̂)       = cos(lobes·θ − ωtₑ − φ)         see `emission`
+ *
+ *   R(d̂)         = (gap/2) / (d̂·û)   for d̂·û > HEAD_ON, else ∞
+ *                                                 where a wave stops
+ *   bounced      = alike(mine, theirs) · emit at path 2R − r
+ *                                                 what turned round and came back
+ *
+ *   field(x,t)   = Σ_a [ emit_a·Θ(R−r) + Σ_b bounced_ab ]
+ *
+ */
+
+import { CYCLE, SPIN, TAU } from "./lattice";
+import { alike, emission, HEAD_ON, LIGHT, rate, sided, Source } from "./physics";
+
+/**
+ * The field, which is the half of the closed form that both accounts of
+ * gravity agree about.
+ *
+ * What a source puts into the space around it, where that has got to by now,
+ * and what happens where two of them meet — one retarded cosine per source,
+ * evaluated at a point, with no state carried between samples and nothing
+ * reconstructed. It is the same for `flow.tsx` and for `metric.tsx`, which
+ * differ only in what they make of the annihilation this reports.
+ */
+
+export type Emitter = {
+  // Where it is, in cells.
+  at: [number, number];
+
+  // One if it has an axis and so has sides; nought if it puts out the same
+  // thing in every direction at once.
+  lobes: 0 | 1;
+
+  // Radians of pattern per tick, signed. Which way round it turns, for a
+  // source with sides; how fast it flips over, for one without.
+  omega: number;
+
+  // Where in the cycle it starts, which is the only thing one source can be
+  // against another.
+  phase: number;
+
+  /**
+   * How it is already going, in cells a tick, and it keeps going that way.
+   *
+   * There is no force in this model and so there is nothing for a velocity to
+   * be changed BY. A source that was set moving carries on moving, at the one
+   * speed its mass allows, in the direction it was sent; nothing here
+   * accelerates anything, and nothing here can slow anything down. What
+   * happens to a pair with momentum is not that they are pulled off course —
+   * it is that the space they are crossing goes on being eaten while they
+   * cross it, so the two end up closer together than their courses would have
+   * left them, without either having gone anywhere it was not already going.
+   *
+   * Which is a strange enough thing to be worth watching, and is the whole
+   * reason for these cases. An orbit that comes out of this is not a balance
+   * of a pull against an inertia. It is a drift that keeps carrying the two
+   * sideways while the gap between them keeps shortening underneath.
+   */
+  drift?: [number, number];
+
+  /**
+   * Ticks between one pulse and the next, or nothing for a source whose
+   * emission is continuous.
+   *
+   * The cases above emit without pause: the cosine is defined everywhere, so
+   * every point in the field is carrying something and there are no shells,
+   * only a phase that varies. That is the smooth reading of the model and it
+   * is a fair one, but it hides the thing the lattice version makes obvious —
+   * that what is emitted is a shell, that shells are discrete, and that
+   * annihilation is one of them meeting one of them.
+   *
+   * Given a beat, the emission becomes a train: a pulse leaves at every
+   * multiple of it and nothing leaves in between, so what travels out is a
+   * set of rings with space between them rather than a filled field. Which
+   * changes the arithmetic of the eating, and changes it in the direction
+   * that matters. Two sources pulsing every tick have a meeting every tick;
+   * two pulsing every OTHER tick have a meeting every other tick, so the gap
+   * between them goes at half the rate while their courses carry them along
+   * at exactly the speed they did. Moving as fast and eating half as quickly
+   * is the difference between a pair that is captured and a pair that has
+   * time to get somewhere first.
+   */
+  beat?: number;
+};
+
+/**
+ * The same source the lattice was given, read as a cosine.
+ *
+ * This is the entire bridge between the two halves of the article, and it is
+ * deliberately dull — every line of it is a change of units and none of it is
+ * a change of claim. What the lattice does with a `Source` and what this does
+ * with it have to be the same arrangement, or the two pictures are not
+ * comparable and there is no point drawing them beside each other.
+ *
+ * The one thing worth reading twice is `lobes`, because it is where the whole
+ * ring-or-spiral difference sits. A source that TURNS has an axis pointing
+ * somewhere, so what it emits depends on the direction: the field carries a θ
+ * in it, its zero set is θ = ω(t − r) + const, and that is an Archimedean
+ * spiral. A source that only flips has no sides, so direction drops out
+ * altogether, the zero set is r = t − const, and that is rings travelling
+ * outward. Same function, with and without an angle in it.
+ */
+export const emitterOf = (s: Source): Emitter => ({
+  at: [s.at[0] ?? 0, s.at[1] ?? 0],
+
+  // Whether it has sides, which is the whole ring-or-spiral difference and is
+  // decided the same way on both sides — see `sided`.
+  lobes: sided(s) ? 1 : 0,
+
+  // How fast it comes round, in radians a tick. `rate` is in turns per cycle
+  // and is the same for a source that turns and one that only flips, which is
+  // the article's claim about them; this is that rate in the units a cosine
+  // wants.
+  omega: rate(s) * SPIN,
+
+  // Turns to radians, which is the only unit either side disagrees on.
+  phase: (s.phase ?? 0) * TAU,
+
+  drift: s.drift ? [s.drift[0] ?? 0, s.drift[1] ?? 0] : undefined,
+
+  // A beat of one is a source that never pauses, which here is a field that
+  // is defined everywhere rather than a train of rings — so it is the absence
+  // of a beat and not a beat of one.
+  beat: s.beat && s.beat > 1 ? s.beat : undefined,
+});
+
+// How wide a pulse is, in ticks — so a ring is about this many cells thick to
+// either side of where its front is.
+const PULSE = 0.5;
+
+/**
+ * A source as it currently stands, and everywhere it has been.
+ *
+ * The past is not optional here. What is at distance r left r ticks ago, from
+ * wherever the source was then — so a ring already in the air belongs to a
+ * place, and that place does not move again however the thing that made it
+ * carries on. Once these start eating they travel at half of light, and a
+ * ring emitted twenty ticks ago is centred ten cells from where its source
+ * now is; drawn from the present position instead, the whole field is hauled
+ * about every time the speed changes, which is every frame, and what should
+ * be a stack of settled layers becomes one object flapping.
+ *
+ * So it is remembered rather than extrapolated, at a couple of samples a
+ * tick, which is finer than anything in the picture varies over.
+ */
+export const TRAIL = 0.5;                                // ticks between remembered places
+
+export type Live = Emitter & {
+  // x then y, one pair per TRAIL of t, from the beginning of the run.
+  path: number[];
+
+  // How it is going now, which starts as its `drift` and is then turned by
+  // the space it is going through. Nothing ever changes its SPEED; see the
+  // flow below.
+  vel: [number, number];
+};
+
+// Where it was at a given moment, and how fast it was going then. Between
+// samples, and before the run began, the nearest thing it can honestly say.
+export const RETARD: [number, number] = [0, 0];
+export const CARRY: [number, number] = [0, 0];
+
+// Which way the thing `emit` just reported on is going.
+export const WAY: [number, number] = [0, 0];
+
+export const was = (s: Live, when: number) => {
+  const last = s.path.length / 2 - 1;
+  const k = Math.min(Math.max(when / TRAIL, 0), last);
+
+  const i = Math.floor(k), j = Math.min(i + 1, last);
+  const f = k - i;
+
+  RETARD[0] = s.path[2 * i] * (1 - f) + s.path[2 * j] * f;
+  RETARD[1] = s.path[2 * i + 1] * (1 - f) + s.path[2 * j + 1] * f;
+};
+
+export const wasGoing = (s: Live, when: number) => {
+  was(s, when);
+
+  const ax = RETARD[0], ay = RETARD[1];
+
+  was(s, when - TRAIL);
+
+  CARRY[0] = (ax - RETARD[0]) / TRAIL;
+  CARRY[1] = (ay - RETARD[1]) / TRAIL;
+
+  RETARD[0] = ax; RETARD[1] = ay;
+};
+
+/**
+ * When what is at a point now left the source that made it.
+ *
+ * The retarded time is the root of |x − p(te)| = t − te, and how it is found
+ * matters entirely at these speeds. The obvious way — guess r from where the
+ * source is now, look up where it was that long ago, measure again — walks
+ * towards the answer, and how fast it walks is exactly the source's speed:
+ * each round takes off a fraction v of what is left. At a third of light that
+ * is three good rounds and done. At ninety-nine hundredths it is six hundred,
+ * which is not a thing that can be done once per source per sample of a
+ * picture, sixty times a second.
+ *
+ * So it is solved rather than approached. Over the short stretch of trail the
+ * answer lies in, the source is going in a straight line at a steady rate,
+ * and for a straight line the equation is a quadratic in te and can simply be
+ * written down. Two rounds of that — one to find roughly where to look, one
+ * to solve properly with the velocity found there — lands on the answer
+ * regardless of how near the ceiling the thing is travelling.
+ *
+ * The position is then read from the trail rather than from the straight
+ * line, so the answer is still a record of where the source actually was.
+ * Nothing already emitted moves, which was the whole reason for keeping a
+ * trail; the straight line is only ever used to work out WHEN to look.
+ */
+export const retard = (s: Live, x: number, y: number, t: number) => {
+  let te = t - Math.hypot(x - s.at[0], y - s.at[1]) / LIGHT;
+
+  /**
+   * Two passes, and the second one earned rather than assumed.
+   *
+   * The quadratic below is exact for a source going in a straight line at a
+   * steady rate — but the FIRST guess it starts from is taken from where the
+   * source is now, and for one travelling at ninety-nine hundredths of the
+   * speed of its own light that guess can be most of the picture out. The
+   * velocity then gets looked up at the wrong moment, the quadratic is solved
+   * for the wrong straight line, and the answer is wrong by however far the
+   * source moved in between. Which is not a small error politely spread
+   * about: it is a radius, so it comes out as rings in the wrong place, and
+   * they go wrong only where the source has been quick, which is why it looks
+   * like something tearing rather than something blurred.
+   *
+   * A second pass starts from an answer that is already close and settles it.
+   * Standing still, though, the first pass is exact and the second is a
+   * measurement of nothing — so it is skipped, which is most of the time in
+   * most of these pictures.
+   */
+  for (let pass = 0; pass < 2; pass++) {
+    wasGoing(s, te);
+
+    if (pass > 0 && Math.abs(CARRY[0]) + Math.abs(CARRY[1]) < 1e-6) break;
+
+    const ex = x - RETARD[0], ey = y - RETARD[1];
+    const vx = CARRY[0], vy = CARRY[1];
+
+    // How long there is between te and now, which is what the light has to
+    // cover — less however much further back the answer turns out to be.
+    const a = t - te;
+
+    const A = vx * vx + vy * vy - LIGHT * LIGHT;
+    const B = 2 * (a * LIGHT * LIGHT - (ex * vx + ey * vy));
+    const C = ex * ex + ey * ey - a * a * LIGHT * LIGHT;
+
+    let step = 0;
+
+    if (Math.abs(A) < 1e-9) {
+      if (Math.abs(B) > 1e-9) step = -C / B;
+    } else {
+      const disc = B * B - 4 * A * C;
+      if (disc < 0) break;
+
+      /**
+       * Solved the stable way, which at these speeds is not a nicety.
+       *
+       * A is v² − 1, and a source travelling at ninety-nine hundredths of
+       * light makes that about a fiftieth. Dividing by it is the textbook
+       * formula and it is exactly where the textbook formula falls apart:
+       * one of the two roots comes out as a small difference of two nearly
+       * equal numbers divided by a nearly vanishing one, and what it returns
+       * is not an approximation of the answer, it is thousands of cells of
+       * nonsense. Which is then used as a radius, so the rings it draws are
+       * nowhere near where anything is — and only where the source has been
+       * quick, which is why it tore rather than blurred.
+       *
+       * Taking the well-conditioned root first and getting the other from
+       * the product of the two has neither subtraction of like quantities nor
+       * division by the small coefficient.
+       */
+      const root = Math.sqrt(disc);
+      const q = -0.5 * (B + (B >= 0 ? root : -root));
+
+      const p1 = q / A, p2 = Math.abs(q) > 1e-12 ? C / q : q / A;
+
+      // Of the two, the one that leaves the light a non-negative time to
+      // travel in. The other is the advanced solution, which is the same
+      // algebra describing something arriving before it left.
+      const ok1 = a - p1 >= 0, ok2 = a - p2 >= 0;
+
+      step = ok1 && ok2 ? (Math.abs(p1) < Math.abs(p2) ? p1 : p2)
+        : ok1 ? p1
+          : ok2 ? p2
+            : 0;
+    }
+
+    te = Math.min(te + step, t);
+  }
+
+  return te;
+};
+
+/**
+ * What ONE source puts at a point.
+ *
+ * Two things temper the bare cosine, and both are properties of the world
+ * above rather than decoration. A wave has not arrived yet where r > t·c, so
+ * there is nothing there — softened over a cell, since a lattice front is not
+ * a razor either. And it thins as it goes, because the same emission is
+ * spread over a bigger and bigger circle; in the model that shows up as the
+ * shells growing apart, here as one over the distance.
+ *
+ * And it is measured from where the source WAS, not from where it is: the
+ * ring through this point left when the source was at p(t − r), and it is
+ * centred there for good. Which is what makes a moving source's rings bunch
+ * up ahead of it and stretch out behind, and at the speeds these reach once
+ * they start eating, that bunching is most of what the picture shows.
+ *
+ * r is on both sides of that, so it is solved for rather than computed —
+ * guess it from where the source is now, look up where it was that long ago,
+ * measure again. Three rounds, because a source that is eating closes at the
+ * speed of its own light and the answer directly ahead of it is then a near
+ * thing: everything it emitted on the way arrives at once, which is a real
+ * pile-up and not an artefact, and it takes a round or two to find. The trail
+ * it looks things up in is a record rather than a projection, so nothing
+ * already emitted can move again however hard the solve works.
+ */
+export const emit = (
+  s: Live, w: Emitter, x: number, y: number, t: number, reach: number,
+  known?: number,
+) => {
+  // Solving the retarded time is the most expensive thing here, and whoever
+  // called this has usually just done it — for the ray, for the cut, for the
+  // meeting surface. Told the answer, this does not do it a second time.
+  let te = known === undefined ? retard(s, x, y, t) : known;
+
+  was(s, te);
+
+  const dx = x - RETARD[0], dy = y - RETARD[1];
+  const r = Math.hypot(dx, dy);
+
+  // Which way what is here is travelling, which is out from wherever it left.
+  // Local, and needed by anything asking whether two things are meeting or
+  // merely crossing.
+  WAY[0] = r > 1e-9 ? dx / r : 1;
+  WAY[1] = r > 1e-9 ? dy / r : 0;
+
+  /**
+   * Nothing has arrived where the wave has not reached yet, softened over a
+   * cell because a lattice front is not a razor either.
+   *
+   * Only for a source emitting without pause. A pulse train has its own
+   * edges — the shape below is nought outside the pulse and that is the whole
+   * of where it is not — and applying this to one as well says something
+   * false about the first pulse of the train, which left at the very
+   * beginning and so IS the front: its own arrival is used as evidence that
+   * it has not arrived, and it is never drawn at all.
+   */
+  const front = w.beat ? 1 : Math.min((t * LIGHT - r) / 1.5, 1);
+  if (front <= 0) return 0;
+
+  const fade = 1 / (1 + r / reach);
+
+  /**
+   * cos(θ − ψ) without ever working out θ.
+   *
+   * The direction to here is wanted only inside a cosine, and cos(θ − ψ) is
+   * cos θ·cos ψ + sin θ·sin ψ — where cos θ and sin θ are dx/r and dy/r,
+   * which are already to hand. So the arctangent, which is the most expensive
+   * thing in this whole expression and is evaluated once per source per
+   * sample of the picture, is not needed at all.
+   */
+  /**
+   * When what is here left, and — if this source pulses — whether anything
+   * left then at all.
+   *
+   * A pulse train is not a sum over pulses. The nearest multiple of the beat
+   * to the emission time IS the pulse this point could belong to, since the
+   * pulses are narrower than the gaps between them, so one rounding finds it
+   * and one bump says how much of it is here. Everything stays O(1) in the
+   * number of pulses in the air, which by now is a great many.
+   */
+  let shape = 1;
+
+  if (w.beat) {
+    const beat = Math.round(te / w.beat) * w.beat;
+    const u = (te - beat) / PULSE;
+
+    if (u <= -1 || u >= 1 || beat < 0) return 0;
+
+    shape = (1 - u * u) ** 2;
+    te = beat;
+  }
+
+  // What it is putting out in this direction, by the one law both readings
+  // are written against — see `emission`. The direction is resolved against
+  // the source's own bearing as cos θ·cos ψ + sin θ·sin ψ, which is why the
+  // arctangent that θ would need is never taken.
+  const psi = w.omega * te + w.phase;
+
+  const wave = emission(!!w.lobes, psi / TAU, () =>
+    (dx * Math.cos(psi) + dy * Math.sin(psi)) / (r || 1));
+
+  return front * fade * shape * wave;
+};
+
+/**
+ * And what the two of them do to each other when they are ALIKE, which the
+ * sum on its own does not contain.
+ *
+ * Opposite charges meeting head-on annihilate, and that is the gravity above.
+ * Like charges meeting head-on turn each other around, and nothing so far has
+ * said so — the closed form adds the two contributions and lets them through
+ * one another.
+ *
+ * For most of these pictures that is not the omission it looks like. Two
+ * identical shells bouncing off each other are indistinguishable from two
+ * shells passing through and swapping names: A's charge ends up where B's
+ * would have been and B's where A's would have been, so the set of places
+ * that are charged is the same either way, and so is the phase at each of
+ * them — the bounced charge has travelled exactly as far as the one that came
+ * the other way. The field cannot tell, because the field does not record
+ * which source anything belongs to. Superposition is already right, and the
+ * waves not visibly turning around is not a thing going wrong.
+ *
+ * It stops being right the moment the two are not interchangeable. A bounced
+ * wave carries the phase and the cadence of the source it came from, and
+ * fades with the distance IT has travelled — and if the two sources are half
+ * a cycle apart, or pulsing at different rates, or one of them is moving and
+ * the other is not, then what comes back is not what would have gone through
+ * and the exchange does not cancel.
+ *
+ * A reflection is an image: the wave that bounced arrives as though it had
+ * come from the mirror of its source in the surface it bounced off. That
+ * surface, for a pair, is the plane halfway between them — so the mirror of
+ * one source is the position of the other, and what comes back is the OTHER
+ * one's geometry carrying THIS one's phase. Which is why the two swap out
+ * exactly when they are alike, and why they do not otherwise.
+ *
+ * So the field is the two readings blended by how much of the meeting is
+ * alike rather than opposite, which `survey` measures on its way past. For
+ * matched sources the reflected pair is the direct pair with the names
+ * exchanged, the blend is between a thing and itself, and it reduces to the
+ * plain sum with nothing left over.
+ */
+/**
+ * How far a wave of `a`'s gets before it runs into one of `b`'s.
+ *
+ * Both travel a cell a tick, so waves that left at the same moment meet
+ * halfway — and along a ray that is not aimed straight at the other source,
+ * further, because the surface they meet on is a plane and a slanted ray has
+ * further to go to reach it. Aimed away from the other source it never meets
+ * anything at all, and goes on for ever.
+ *
+ * This is the only thing that stops a wave, and it stops it completely. There
+ * is no thinning, no optical depth, no fraction getting through. A charge
+ * meets another charge and one of two things happens, and neither of them is
+ * "carries on a bit weaker".
+ */
+const HERE: [number, number] = [0, 0];
+const THERE: [number, number] = [0, 0];
+
+export const meets = (
+  a: Live, b: Live, dx: number, dy: number, when: number,
+) => {
+  /**
+   * Worked out from where the two of them WERE, not from where they are.
+   *
+   * This is the whole of what makes it local, and getting it wrong is
+   * unmistakable: a wave that left long ago has its stopping place decided by
+   * a surface built out of the sources' present positions, so every time
+   * either of them turns or drifts, the surface swings and every wave already
+   * in the air swings with it. Rings that were laid down years of ticks ago
+   * get up and rotate, which is not a thing waves do. Nothing that has
+   * already happened is allowed to depend on anything that happened after it.
+   *
+   * So both are asked where they were when this wave was in the air, and the
+   * answer is a record — see the trail — rather than anything derived from
+   * now. What was decided then stays decided.
+   */
+  was(a, when);
+  HERE[0] = RETARD[0]; HERE[1] = RETARD[1];
+
+  was(b, when);
+  THERE[0] = RETARD[0]; THERE[1] = RETARD[1];
+
+  let ux = THERE[0] - HERE[0], uy = THERE[1] - HERE[1];
+  const gap = Math.hypot(ux, uy);
+  if (gap < 1e-6) return Infinity;
+
+  ux /= gap; uy /= gap;
+
+  const aim = dx * ux + dy * uy;
+
+  /**
+   * And only where the two would actually be head-on when they got there.
+   *
+   * The surface halfway between a pair is a whole plane, and it is tempting
+   * to stop everything at it — but two waves arriving at a point far out on
+   * that plane are not meeting, they are travelling side by side. Their
+   * directions there are mirror images about the plane, so the angle between
+   * them is set by how squarely the ray was aimed: dead at the other source
+   * they are exactly opposed, and at forty-five degrees off they are already
+   * at right angles and past caring about each other.
+   *
+   * Beyond that the encounter is a crossing. Charges crossing at an angle do
+   * nothing to each other in this model — they pass, and both carry on — so
+   * stopping them there would put a seam down the middle of every picture
+   * where none belongs, and it is why the arms far from the axis have to go
+   * through one another. They are not meeting. They are just both there.
+   */
+  if (aim <= HEAD_ON) return Infinity;
+
+  return (gap / 2) / aim;
+};
+
+/**
+ * A wave of `a`'s that has met one of `b`'s and turned around.
+ *
+ * Which of the two things happened at that meeting is decided THERE, by what
+ * the two of them were, and not by any running average over the picture. Two
+ * charges meeting head-on are alike or they are opposite; alike, they turn
+ * each other round and both go back the way they came; opposite, they
+ * annihilate and neither of them is anywhere afterwards. So this asks the
+ * question at the place and the moment it was settled: what was `a` putting
+ * out along this ray when it got to the meeting, and what was `b` putting
+ * into the same spot at the same instant. Same sign, and there is a wave
+ * coming home. Opposite, and there is nothing — which is the annihilation,
+ * and it needs no separate machinery, because a thing that annihilated simply
+ * has no return.
+ *
+ * And what comes home runs into the shells its own source has emitted since,
+ * head-on, going the other way. A source that turns over is putting out the
+ * opposite charge by then, so what the returning wave meets is its opposite,
+ * and the two cancel. That is the second half of what makes the space between
+ * a pair empty, and it falls out of the arithmetic rather than being put in:
+ * these are all terms in one sum, and terms of opposite sign cancel.
+ *
+ * The going-out and the coming-back are the same wave with the sign of the
+ * radius flipped. Outgoing at distance r left r ago, so its phase runs on
+ * t − r and crests move outward. Having gone to the meeting at R and come
+ * back to r it has travelled 2R − r, so its phase runs on t − 2R + r and
+ * crests move inward. One sign, and that sign is the whole of what bouncing
+ * is.
+ */
+export const bounced = (
+  a: Live, b: Live, x: number, y: number, t: number, reach: number,
+  known?: number, given?: number,
+) => {
+  // From where it was when this left it, for the reason given in `fieldAt`.
+  const left = known === undefined ? retard(a, x, y, t) : known;
+
+  was(a, left);
+
+  let dx = x - RETARD[0], dy = y - RETARD[1];
+  const r = Math.hypot(dx, dy);
+  if (r < 1e-6) return 0;
+
+  dx /= r; dy /= r;
+
+  // Asked of the moment this wave was crossing, not of now — or handed
+  // straight over by whoever has already asked.
+  const mirror = given === undefined ? meets(a, b, dx, dy, left) : given;
+  if (!isFinite(mirror) || r >= mirror) return 0;   // nothing has come back to here
+
+  // Out to the meeting and back again: how far this has travelled, and so
+  // how long ago it left.
+  const path = 2 * mirror - r;
+  const te = t - path / LIGHT;
+  if (te < 0) return 0;
+
+  // As above: a train's own pulse shape says where it is, and this would
+  // erase the first of them.
+  const front = a.beat ? 1 : Math.min((t * LIGHT - path) / 1.5, 1);
+  if (front <= 0) return 0;
+
+  let when = te, shape = 1;
+
+  if (a.beat) {
+    const beat = Math.round(when / a.beat) * a.beat;
+    const u = (when - beat) / PULSE;
+
+    if (u <= -1 || u >= 1 || beat < 0) return 0;
+
+    shape = (1 - u * u) ** 2;
+    when = beat;
+  }
+
+  const psi = a.omega * when + a.phase;
+
+  // The angle is the one it LEFT along, since that is the half of the source
+  // it came out of.
+  const mine = emission(!!a.lobes, psi / TAU, () =>
+    dx * Math.cos(psi) + dy * Math.sin(psi));
+
+  if (mine === 0) return 0;
+
+  // What the other one had at that spot when this arrived there. Same sign,
+  // and the two turned each other round; opposite, and they are both gone.
+  was(a, left);
+
+  const hitX = RETARD[0] + dx * mirror, hitY = RETARD[1] + dy * mirror;
+  const struck = t - (mirror - r) / LIGHT;
+
+  const theirs = emit(b, b, hitX, hitY, struck, reach);
+
+  // Same sign and the two turned each other round; opposite, and they are
+  // both gone. The identical expression the lattice takes at ±1 to get
+  // 'annihilate' or 'turn' — read here at whatever fraction it comes to,
+  // because a field is a great many such pairs at once and the answer is how
+  // many of them went each way. See `agreement`.
+  const returning = alike(mine, theirs);
+  if (returning <= 1e-3) return 0;
+
+  // Softened right at the meeting surface, which is a place and not a knife.
+  const edge = Math.min(Math.max((mirror - r) / 1.5, 0), 1);
+
+  /**
+   * Thinned by where it IS, not by how far it has been — which is the
+   * opposite of what it looks like it should be, and is why this was so hard
+   * to see.
+   *
+   * The thinning is a shell spread round a growing circle: the same emission
+   * stretched over a longer and longer ring, so it goes as the radius. A
+   * shell coming home sits on a circle exactly the size of an outgoing
+   * shell's at the same radius, and it is CONTRACTING — its charges are being
+   * gathered back onto a shorter and shorter ring, so it gets denser as it
+   * returns rather than fainter.
+   *
+   * Faded by the whole path instead, as it was, a returning wave is dimmed by
+   * twice the distance to the surface while the outgoing wave drawn at the
+   * same place is dimmed by almost nothing. It was in the arithmetic and
+   * underneath the wave it had bounced off, worst of all near the source
+   * where it should have been brightest.
+   *
+   * The path still sets the phase. How far a thing has travelled is when it
+   * left; it is not how spread out it is.
+   */
+  return returning * edge * front * shape * mine / (1 + r / reach);
+};
+
+/**
+ * What is at a place: everything that got there, going out and coming back.
+ *
+ * A plain sum, and it can be, because nothing in it is a wave that should not
+ * be there. A wave stops dead at the first thing it meets — that is `meets`
+ * above, applied to every outgoing term — so two sources' waves never overlap
+ * beyond their meeting surface and there is no crossing to suppress. What is
+ * left to add up is a handful of waves that genuinely coexist, and adding is
+ * the right thing to do with those: where two of them are opposite they
+ * cancel, which is annihilation, drawn.
+ *
+ * Which is why the returning wave puts out the space between a pair without
+ * anything being written to make it. It comes home into shells its own source
+ * threw out later, and a source that turns over threw the opposite charge;
+ * they are opposite terms in a sum, and they go.
+ */
+const MIRRORS: number[] = [];
+
+export const fieldAt = (
+  x: number, y: number, t: number, sources: Live[], reach: number,
+) => {
+  let total = 0;
+
+  for (const a of sources) {
+    /**
+     * Measured from where this source WAS when the wave here left it.
+     *
+     * Not from where it is. The two are the same thing only for a source
+     * standing still, and these travel at ninety-nine hundredths of the speed
+     * of what they emit — so the distance to the present source and the
+     * distance the wave actually came differ by most of the picture. Taking
+     * the ray and the radius from the present position while the surface it
+     * is being cut against is worked out from the past one is two different
+     * geometries compared against each other, and what that produces is a
+     * cut at the wrong radius: a hole where a wave was stopped that never met
+     * anything, standing between the pair and following them about.
+     */
+    const when = retard(a, x, y, t);
+
+    was(a, when);
+
+    let dx = x - RETARD[0], dy = y - RETARD[1];
+    const r = Math.hypot(dx, dy) || 1e-9;
+
+    dx /= r; dy /= r;
+
+    // As far as the nearest thing that was in the way when it went past, and
+    // no further.
+    let stop = Infinity;
+    let seen = 0;
+
+    for (const b of sources) {
+      if (b === a) continue;
+
+      const at = meets(a, b, dx, dy, when);
+
+      MIRRORS[seen++] = at;
+      if (at < stop) stop = at;
+    }
+
+    if (r < stop) {
+      // Faded over a cell at the surface, so the end of a wave is a place
+      // rather than an event.
+      const edge = isFinite(stop) ? Math.min((stop - r) / 1.5, 1) : 1;
+
+      total += emit(a, a, x, y, t, reach, when) * edge;
+    }
+
+    // Only where something was in the way. Over most of any of these pictures
+    // nothing is — a ray not aimed at the other source never meets it — and
+    // asking `bounced` anyway means solving a retarded time and a meeting
+    // surface all over again to be told so.
+    seen = 0;
+
+    for (const b of sources) {
+      if (b === a) continue;
+
+      const mirror = MIRRORS[seen++];
+      if (!isFinite(mirror) || r >= mirror) continue;
+
+      total += bounced(a, b, x, y, t, reach, when, mirror);
+    }
+  }
+
+  return total;
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts
index e234cd7..2700119 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts
@@ -1,49 +1,58 @@
 /**
- * The vocabulary both readings of this article are written in.
+ * EQUATIONS IN THIS FILE
+ *
+ *   step(v)      = round(v / max|v|)              a direction, as one step
+ *   |directions| = 3^d − 1                        ways out of a point
+ *   ring(u,v)_k  = step(u·cos 2πk/8 + v·sin 2πk/8)   a turn, in eighths
+ *   CYCLE        = |ring| = 8                     ticks to come back round
+ *   SPIN         = 2π / CYCLE                     the same rate, in radians
+ *   a·b          = Σ aᵢbᵢ                         how much one way is another
  *
- * There are two models here — a lattice of points run one tick at a time, and
- * the closed form of what that lattice makes — and the whole point of putting
- * them side by side is that they are the same claim said twice. That only
- * holds if they agree on their terms: what a charge is, how many directions a
- * point has, how long a turn takes. Those terms live here, so that neither
- * side can quietly drift from the other by redefining one of them.
+ */
+
+/**
+ * The space both readings are written in.
+ *
+ * Nothing here knows what a charge is. This is the layer below that: how many
+ * ways out of a point there are, what counts as one step, how long a turn
+ * takes and what it passes through on the way round. `physics.ts` is what
+ * happens in it.
+ *
+ * The two readings need the same answers from it for opposite reasons. The
+ * lattice needs them because they are literally its structure — a point has
+ * exactly these neighbours and a source can emit into exactly these
+ * directions. The closed form has no structure at all, and needs them because
+ * the thing it is the closed form OF has: a band is `CYCLE/2` cells wide
+ * because a turn is `CYCLE` ticks and a wave goes a cell a tick, and if the
+ * two disagreed about that they would not be pictures of the same thing.
  */
 
 export type Vec = number[];
 
+// One whole turn, which is enough of a constant to be worth not writing out.
+export const TAU = Math.PI * 2;
+
 /**
- * What a boundary carries.
+ * How much one direction lies along another.
  *
- * Neutral is what space is when nothing has happened to it yet: it is what
- * gets instantiated as something moves — ahead of it at a boundary of the
- * structure, and behind it as it goes — rather than a charge drawn at random.
+ * Written out by hand in a dozen places between the two readings, and it is
+ * the same question every time: how much of this way is that way. Tolerant of
+ * the two having different lengths, since a lattice direction in a flat world
+ * is compared against an axis stated in three dimensions often enough.
  */
-export enum Polarity {
-  Positive,
-  Negative,
-  Neutral
-}
-
-export const opposite = (p: Polarity): Polarity =>
-  p === Polarity.Positive ? Polarity.Negative
-    : p === Polarity.Negative ? Polarity.Positive
-      : Polarity.Neutral;
+export const dot = (a: number[], b: number[]): number => {
+  let total = 0;
 
-//TODO Should probably be something oscillating instead of random
-export const randomPolarity = () =>
-  Math.random() < 0.5 ? Polarity.Positive : Polarity.Negative;
+  for (let i = 0; i < a.length; i++) total += a[i] * (b[i] || 0);
 
-// A fresh order, so that what interacts with what is a draw rather than an
-// artefact of the order things happen to sit in.
-export const shuffle = <T,>(arr: T[]): T[] => {
-  const out = arr.slice();
+  return total;
+};
 
-  for (let i = out.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [out[i], out[j]] = [out[j], out[i]];
-  }
+/** The same direction, one long. */
+export const unit = (v: number[]): number[] => {
+  const length = Math.hypot(...v);
 
-  return out;
+  return length ? v.map(x => x / length) : v;
 };
 
 // World units per lattice step. Shared by the layout and by the renderer,
@@ -178,127 +187,4 @@ export const CYCLE = TURN.length;
 // The same rate in radians, which is what the closed form wants: a turn per
 // CYCLE ticks, because the lattice has eight directions to a plane and takes
 // one step of them a tick.
-export const SPIN = (Math.PI * 2) / CYCLE;
-
-/**
- * One source, said once for both readings of it.
- *
- * This is the whole of what an arrangement in this article IS. The lattice
- * builds a point out of it and lets the tick rules have it (`Graph.sources`);
- * the closed form turns it into a cosine and evaluates that (`emitterOf`).
- * Neither adds anything of its own — if the two pictures disagree, they
- * disagree about what these rules make and not about what was set up.
- *
- * Which is why the units are stated here rather than at either end. `phase`
- * is in TURNS, not in radians and not in ticks, because a turn is the one
- * thing both models agree on the length of. `drift` and `beat` are in cells
- * and ticks, which the lattice measures directly and the closed form is
- * calibrated against.
- */
-export type Source = {
-  // Where it is, in cells from the middle. Shorter than the world has
-  // dimensions is allowed and means nought in the rest.
-  at: number[];
-
-  // What it puts out of the half of itself facing `axis` — the opposite comes
-  // out of the half facing back.
-  emits?: Polarity;
-
-  /**
-   * Which way round it is, if it is a magnet rather than a lamp.
-   *
-   * Without this a source puts the same charge out in every direction and
-   * turns the lot over together — something that alternates, but with no
-   * sides to it. A magnet has sides: `emits` goes out of the half pointing
-   * along this, its opposite out of the half pointing against, and the ring
-   * exactly across it puts out nothing at all.
-   *
-   * It matters for two magnets facing each other because it decides what
-   * arrives. Both given the same axis, the face of one that looks at the
-   * other is its north and the face looking back is the other's south — so
-   * what crosses the gap is opposite to what it meets, every tick, and
-   * opposite charges meeting is the one event that destroys space.
-   */
-  axis?: number[];
-
-  /**
-   * Which way round it turns, if it turns: +1 or −1, and nothing for a source
-   * held still.
-   *
-   * Flipping is the other thing a source can do, and the difference is what
-   * separates a ring from a spiral. A flip is the same everywhere at once —
-   * north becomes south on the spot, nothing has moved — so what it writes is
-   * shells. Turning brings the axis itself round, so a direction that was
-   * looking at the north pole is looking at the equator a moment later and at
-   * the south pole after that: the alternation is a consequence of the thing
-   * going round rather than a property stipulated of it, and it has a
-   * handedness, so two sources can turn the same way or against each other.
-   *
-   * A turning source therefore needs no flip, and does not get one — see
-   * `flips`.
-   */
-  turning?: 1 | -1;
-
-  // Whether it alternates at all. A source that turns is already alternating
-  // and defaults to off; one that does not is a source with nothing to make a
-  // wave out of unless it flips, and defaults to on. Off for both is a magnet
-  // simply held, which puts out one steady stream per pole.
-  flips?: boolean;
-
-  // Where in the cycle it starts, in turns. The only thing one source can be
-  // against another, and the reason two of them meeting are alike or
-  // opposite.
-  phase?: number;
-
-  // How it is already going, in cells a tick. Nothing here accelerates
-  // anything, so this is a course rather than an initial condition: it keeps
-  // going that way at that pace. On the lattice the pace is a mass (see
-  // `massFor`), which is the only thing there that decides how fast anything
-  // is.
-  drift?: number[];
-
-  // Ticks between one pulse and the next. One is a source that never pauses.
-  beat?: number;
-
-  // The plane it turns in, as the two directions it turns between. Anything
-  // in three dimensions, not only the one the code happens to be written
-  // around — two sources can be set turning in different planes, which is a
-  // thing only a 3D world can be asked.
-  plane?: [number[], number[]];
-};
-
-// How fast a source is going, in cells a tick.
-export const speedOf = (s: Source) => s.drift ? Math.hypot(...s.drift) : 0;
-
-/** What is in the world, and how much world there is for it to be in. */
-export type World = {
-  sources: Source[];
-
-  // How many dimensions the space has, and two is not a lesser version of
-  // three. The turn is flat — the axis comes round in one plane and stays in
-  // it — so everything a turning source does happens in that plane, and the
-  // third dimension contributes nothing to it but the rest of a sphere for
-  // the same arms to be seen through. Flat, the plane of the turn IS the
-  // picture.
-  dims?: number;
-
-  // How much lattice there is, as a radius in cells.
-  radius?: number;
-
-  // Ticks per eighth of a turn, and one is as fast as turning goes: an eighth
-  // of a turn is the smallest rotation this space has, because there are
-  // eight directions to a plane and nothing between neighbouring ones to move
-  // through. Anything quicker is not a faster rotation but a coarser one.
-  turnEvery?: number;
-
-  // How often a ray takes one of the ways its direction is made of instead of
-  // the direction itself. See `Graph.wander`.
-  wander?: number;
-
-  // How many moves a charge lasts before it is space again, how far round the
-  // front counts as ahead when it fans, and how far out it waits before
-  // fanning at all. See `Graph.sources`.
-  range?: number;
-  spread?: number;
-  fanAt?: number;
-};
+export const SPIN = TAU / CYCLE;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lines.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lines.ts
index e6a6719..4ca0a99 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lines.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lines.ts
@@ -1,5 +1,5 @@
 import { LineSide } from "./discrete";
-import { opposite, Polarity, randomPolarity } from "./lattice";
+import { opposite, Polarity, randomPolarity } from "./physics";
 
 /**
  * Charges in a row, enumerated.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
new file mode 100644
index 0000000..ccb75c4
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
@@ -0,0 +1,593 @@
+/**
+ * EQUATIONS IN THIS FILE
+ *
+ *   ds²        = e^{2φ}(dx² + dy²)                space, as a metric
+ *
+ *   S(x)       = Σ_{a<b} cancelling(Fa,Fb)·|Fa·Fb|·closing(d̂a,d̂b)
+ *                                                 annihilation, per place
+ *   φ(x)       = max(−K·S·dt, −1/4)               what is going, this tick
+ *                                                 (per-tick: no ledger — see below)
+ *
+ *   apart(a,b) = ∫ e^φ ds  along a→b              how far apart they really are
+ *   deficit    = |a − b| − apart(a,b)             what the line has lost
+ *   spend      = min(deficit, BITE·dt, |a−b| − 1) realised into the coordinates
+ *
+ *   bend       = ∇φ − (∇φ·ĥ)ĥ                     the geodesic turn, across ĥ
+ *
+ *   movement is a swap:
+ *     wake     = −v·dt/step ahead, +v·dt/step behind      taken in front, laid behind
+ *     carry    = v·dt / e^φ                       and it advances by that much
+ *
+ */
+
+import { CanvasView, Surface } from "./canvas";
+import { Emitter, Live, WAY, emit, fieldAt, TRAIL } from "./field";
+import { CYCLE } from "./lattice";
+import { AMBER, BACKGROUND, CYAN, ground, lift, source } from "./paint";
+import { BITE, cancelling, closing } from "./physics";
+
+/**
+ * Gravity as a shortage of space, which is what the lattice actually does.
+ *
+ * `continuous.tsx` is the other account, and it is the one this article was
+ * written with: measure where annihilation is happening, turn that into a
+ * velocity for the space itself, give the velocity a wave equation, carry
+ * each source by the flow it is standing in, and turn it by how steeply that
+ * flow falls away. It works, and every step of it is a thing added.
+ *
+ * None of which the lattice does. `annihilate` pushes nothing. It removes two
+ * points and splices what was behind each onto what was behind the other, and
+ * afterwards there is simply LESS SPACE between the two things than there
+ * was. Nothing moved. The distance is smaller.
+ *
+ * So this account keeps one number per place — how much of the space there is
+ * left — and lets everything else be geometry:
+ *
+ *     □φ  =  −S            annihilation takes space out, and it stays out
+ *     ds² =  e^{2φ}(dx² + dy²)
+ *
+ * `S` is the annihilation density, which is the one thing both accounts read
+ * off the same field. `φ` starts at nought, which is flat, and goes negative
+ * where space has been destroyed: proper distance across such a place is less
+ * than it looks, and where enough has gone the two sides of it are adjacent
+ * and crossing costs nothing at all. That is the whole of what `closeUp` does
+ * on the lattice, said as a metric.
+ *
+ * What that buys, over and above being shorter:
+ *
+ *  - Attraction is not a rule any more. The pair are not pushed together;
+ *    the interval between them is shorter, which is the article's own
+ *    definition of what it would mean for them to gravitate.
+ *
+ *  - Light takes the shortcut too. The retarded distance is measured in the
+ *    same metric, so as a pair close, they begin to hear each other sooner
+ *    — which the lattice does and the flow account cannot.
+ *
+ *  - Deflection is one line. A course that stays straight in the metric does
+ *    not stay straight in the coordinates, and the turn is the component of
+ *    ∇φ across the way it is going. No potential, no gradient of half a
+ *    square, nothing differentiated twice.
+ *
+ * And what it costs, which is worth saying plainly: the retarded time ought
+ * to be traced along a bent ray, and is not. It is measured along the
+ * straight line and weighted by the metric, which is the eikonal
+ * approximation — right while φ is small, and least right exactly between a
+ * pair that has nearly closed, where φ is deepest. It is the one place this
+ * account is less honest than the one it replaces.
+ */
+
+/**
+ * How much space is left, over the part of the world worth tracking.
+ *
+ * A grid fixed for the whole run, and one scalar on it rather than the flow
+ * account's six. `phi` is what has been carried away and `rate` is how fast
+ * it is going, because the field obeys a wave equation rather than being
+ * applied where it is made: a contraction here has to reach a place over
+ * there, and it has to take the time light takes.
+ */
+export type Space = {
+  phi: Float32Array;
+  n: number; x0: number; y0: number; step: number;
+};
+
+export const space = (span: number): Space => {
+  const n = 64;
+
+  return {
+    phi: new Float32Array(n * n),
+    n, x0: -span, y0: -span, step: (2 * span) / n,
+  };
+};
+
+// Read between the grid's places, since it is asked at arbitrary points.
+export const phiAt = (w: Space, x: number, y: number): number => {
+  const fx = Math.min(Math.max((x - w.x0) / w.step, 0), w.n - 1.001);
+  const fy = Math.min(Math.max((y - w.y0) / w.step, 0), w.n - 1.001);
+
+  const i = Math.floor(fx), j = Math.floor(fy);
+  const u = fx - i, v = fy - j;
+
+  const k = j * w.n + i;
+  const a = w.phi;
+
+  return (a[k] * (1 - u) + a[k + 1] * u) * (1 - v)
+    + (a[k + w.n] * (1 - u) + a[k + w.n + 1] * u) * v;
+};
+
+/**
+ * How much space is being destroyed at a place, per tick.
+ *
+ * The one thing both accounts read off the field, and the whole of what
+ * annihilation is: two charges cancel where they are opposite in charge AND
+ * opposed in direction. One without the other is a crossing rather than a
+ * collision, so both factors are in it, and both are readable on the spot
+ * without knowing which sources exist or which two of them are meant.
+ */
+const eaten = (live: Live[], x: number, y: number, t: number, reach: number) => {
+  const val: number[] = [], dx: number[] = [], dy: number[] = [];
+
+  for (let i = 0; i < live.length; i++) {
+    val[i] = emit(live[i], live[i], x, y, t, reach);
+    dx[i] = WAY[0]; dy[i] = WAY[1];
+  }
+
+  let total = 0;
+
+  for (let i = 0; i < live.length; i++)
+    for (let j = i + 1; j < live.length; j++) {
+      const closes = closing([dx[i], dy[i]], [dx[j], dy[j]]);
+      if (closes <= 0) continue;                  // crossing, not meeting
+
+      total += cancelling(val[i], val[j]) * Math.abs(val[i] * val[j]) * closes;
+    }
+
+  return total;
+};
+
+/**
+ * One step of it: what is being eaten is laid down as the source, and the
+ * field carries it.
+ *
+ * The Laplacian is the plain five-point one, which is all a wave equation on
+ * a grid needs, and the speed in it is exactly the speed of everything else
+ * here. Nothing damps `phi` back towards nought: once the ground has gone it
+ * has gone, which is the whole difference between a metric that remembers and
+ * a flow recomputed every tick.
+ *
+ * What IS damped is the rate, lightly, so that the field settles rather than
+ * ringing for ever after the eating has finished.
+ */
+export const spaceStep = (
+  w: Space, live: Live[], t: number, reach: number, dt: number,
+) => {
+  const { phi, n, step } = w;
+
+  /**
+   * What is being taken out RIGHT NOW, and not a ledger of everything that
+   * ever was.
+   *
+   * This was an accumulator with a wave equation on it, and that was wrong
+   * twice over. Once the pair have arrived, the line between them is one cell
+   * long, so `spend` can no longer relieve anything — while `eaten` goes on
+   * reporting annihilation, because the two are still emitting and the field
+   * does not know they are already adjacent. So `phi` went on falling around
+   * them for ever, and what it drew was a black region spreading out from a
+   * pair that had finished: measured, every cell within a dozen of them down
+   * to four tenths of its space and still going.
+   *
+   * On the lattice nothing like that can happen. When there are no points
+   * left between two things there is nothing left to remove, and a charge
+   * arriving at a source is absorbed by it. The eating stops because it has
+   * run out of subject.
+   *
+   * So there is no ledger. The contraction is spent into the coordinates the
+   * tick it is made (see `spend`), and "space that has gone stays gone" is
+   * carried by the picture having actually contracted rather than by a
+   * permanent scar in a field. Which is what having one frame was FOR — a
+   * ledger as well as a contraction is the same shortening counted twice.
+   *
+   * The delay survives, because it never came from this: `eaten` is read off
+   * retarded fields and is nought until the two have reached each other.
+   */
+  const gain = 128;
+
+  for (let j = 0; j < n; j++)
+    for (let i = 0; i < n; i++) {
+      const s = eaten(live, w.x0 + i * step, w.y0 + j * step, t, reach);
+
+      // Never more than a place has to give.
+      phi[j * n + i] = Math.max(-gain * s * dt, -0.25);
+    }
+};
+
+/**
+ * How far apart two places are, in the metric rather than in the picture.
+ *
+ * The eikonal reading: along the straight line between them, weighted by how
+ * much space each part of it still has. A proper ray would bend, and this one
+ * does not — see the note at the top — but where the metric is gentle the two
+ * agree, and where it is not, what this gets wrong is the path and not the
+ * shortage.
+ *
+ * This is the measurement the whole account is for. It is the closed form's
+ * version of counting the points between two things on the lattice, and it
+ * falls when and only when the space between them has been annihilated.
+ */
+export const apart = (
+  w: Space, ax: number, ay: number, bx: number, by: number,
+) => {
+  const dx = bx - ax, dy = by - ay;
+  const straight = Math.hypot(dx, dy);
+  if (straight < 1e-9) return 0;
+
+  const steps = Math.max(Math.ceil(straight / w.step), 2);
+
+  let total = 0;
+
+  for (let k = 0; k < steps; k++) {
+    const f = (k + 0.5) / steps;
+
+    total += Math.exp(phiAt(w, ax + dx * f, ay + dy * f));
+  }
+
+  return (total / steps) * straight;
+};
+
+/**
+ * Which way a course bends, when it is going straight in a space that is not.
+ *
+ * For a conformal metric the geodesic turns by the part of ∇φ lying ACROSS
+ * the direction of travel, and by nothing else — so a straight line stays the
+ * same length and only comes round, which is the one thing this model allows.
+ * Nothing accelerates: there is no force here, and this is not one. It is
+ * what "carry on the way you were going" comes to when the ground it is
+ * measured against has been shortened on one side.
+ */
+const TURN: [number, number] = [0, 0];
+
+export const bend = (
+  w: Space, x: number, y: number, hx: number, hy: number,
+) => {
+  const d = w.step;
+
+  const gx = (phiAt(w, x + d, y) - phiAt(w, x - d, y)) / (2 * d);
+  const gy = (phiAt(w, x, y + d) - phiAt(w, x, y - d)) / (2 * d);
+
+  // Across the way it is going. The part along it would be a change of speed,
+  // and there is nothing here that changes speed.
+  const along = gx * hx + gy * hy;
+
+  TURN[0] = gx - along * hx;
+  TURN[1] = gy - along * hy;
+};
+
+/**
+ * Movement, which is not a value being changed.
+ *
+ * `consumeAhead` on the lattice is a SWAP: a ray takes the point in front of
+ * it and that point ends up behind. Nothing is added to the world and nothing
+ * is taken from it — what moves is the space, and the ray is what the space
+ * has moved past. This says the same thing where space is a density rather
+ * than a set of points: a thing going somewhere destroys the space in front
+ * of it and lays the same amount down behind, at the rate it is going.
+ *
+ * So a photon, which is perfect movement, takes a whole cell in front and
+ * puts a whole cell behind every tick. Anything slower does a fraction of one
+ * — its mass IS that fraction (see `massFor`), which is why mass is the cost
+ * of going somewhere here and not a property a thing has.
+ *
+ * Written this way, movement and gravity stop being two mechanisms. Both are
+ * the same operation on the space and differ only in shape: annihilation is a
+ * loss BETWEEN two things, which brings them together; movement is a loss in
+ * front and a gain behind, which carries one along. And the second is the
+ * counterweight to the first — measured, a pair sent past each other at half
+ * of light hold at eleven cells rather than collapsing, because what their
+ * motion lays down behind them pushes out against what their meeting eats.
+ */
+const SWAP = 0.5;
+
+const deposit = (w: Space, x: number, y: number, q: number) => {
+  const i = Math.round((x - w.x0) / w.step);
+  const j = Math.round((y - w.y0) / w.step);
+
+  if (i < 0 || j < 0 || i >= w.n || j >= w.n) return;
+
+  w.phi[j * w.n + i] += q;
+};
+
+export const wake = (w: Space, live: Live[], dt: number) => {
+  for (const s of live) {
+    const speed = Math.hypot(s.vel[0], s.vel[1]);
+    if (speed < 1e-9) continue;
+
+    const hx = s.vel[0] / speed, hy = s.vel[1] / speed;
+
+    // How much of a cell it gets through this tick, which is the whole of
+    // what its speed is.
+    const q = speed * dt / w.step;
+
+    deposit(w, s.at[0] + hx * SWAP, s.at[1] + hy * SWAP, -q);  // taken in front
+    deposit(w, s.at[0] - hx * SWAP, s.at[1] - hy * SWAP, +q);  // laid behind
+  }
+};
+
+/**
+ * And it advances by however much coordinate the space it destroyed was
+ * worth.
+ *
+ * Which is the whole coupling between moving and gravity, and it falls out
+ * rather than being put in: a step is one step of PROPER length, so where the
+ * ground has been thinned by something else eating it, the same step covers
+ * more of the picture. A thing crossing a region two things are annihilating
+ * gets further for the same effort — and light does too, which is why the
+ * pair start hearing each other sooner as they close.
+ */
+export const carry = (w: Space, live: Live[], dt: number) => {
+  for (const s of live) {
+    const speed = Math.hypot(s.vel[0], s.vel[1]);
+    if (speed < 1e-9) continue;
+
+    const hx = s.vel[0] / speed, hy = s.vel[1] / speed;
+
+    const left = Math.max(Math.exp(phiAt(w, s.at[0], s.at[1])), 0.05);
+    const advance = speed * dt / left;
+
+    s.at[0] += hx * advance;
+    s.at[1] += hy * advance;
+  }
+};
+
+// A 4x4 ordered pattern, centred on nought and worth about one level of an
+// eight-bit channel.
+const DITHER = [
+  0, 8, 2, 10,
+  12, 4, 14, 6,
+  3, 11, 1, 9,
+  15, 7, 13, 5,
+].map(v => (v / 16) - 0.5);
+
+/**
+ * One canvas of it: the same field as the flow account, over a space that is
+ * being taken away rather than pushed about.
+ */
+export const MetricField = ({
+  sources,
+  height = 320,
+  span = 14,
+  rate = 10,
+  cycle = 200,
+}: {
+  sources: Emitter[];
+  span?: number;
+  rate?: number;
+  cycle?: number;
+  height?: number;
+}) => <CanvasView
+  height={height}
+  deps={[sources, span, rate, cycle]}
+  paint={() => {
+    const buf = document.createElement("canvas");
+    const bufCtx = buf.getContext("2d")!;
+
+    let img: ImageData | null = null;
+
+    let t = 0;
+    let world = space(span);
+
+    let live: Live[] = [];
+
+    const reset = () => {
+      t = 0;
+      world = space(span);
+      live = sources.map(s => ({
+        ...s,
+        at: [...s.at] as [number, number],
+        path: [s.at[0], s.at[1]],
+        vel: [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number],
+      }));
+    };
+
+    // Everywhere each of them has been, kept up to the moment, so that a ring
+    // already in the air belongs to a place and stays there.
+    const remember = () => {
+      for (const s of live)
+        for (let k = s.path.length / 2; k <= t / TRAIL; k++)
+          s.path.push(s.at[0], s.at[1]);
+    };
+
+    reset();
+
+    /**
+     * The contraction, spent into the picture.
+     *
+     * There is one frame here and not two, which is what makes this account
+     * work at all. A source has a position, and that position is where it is
+     * — the field is emitted from it, the trail records it, the picture draws
+     * it. There is no second set of coordinates in which the pair are "really"
+     * still apart.
+     *
+     * So the shortage of space has to be REALISED rather than merely
+     * recorded. `phi` is the contraction that has not yet been expressed in
+     * the picture: annihilation puts it there, and this takes it out again by
+     * moving the two ends of the line together by exactly as much as the line
+     * has lost. Which is the whole of your "we can move freely over that
+     * boundary" — the space between them is not drawn dark, it is not drawn
+     * at all, because it is not there.
+     *
+     * And what is spent is taken back out of `phi` along the line it was
+     * spent on, which is the thing the first version of this got wrong.
+     * Leave it in and the next tick measures the same shortage again through
+     * a line that is now shorter, finds it shorter still, and the pair fall
+     * into each other in three ticks with a rate that means nothing.
+     *
+     * Never faster than the rule, and never past adjacent: a source is not
+     * space, so there is nothing left between two that have arrived and
+     * nothing either could move through if there were.
+     */
+    const TOUCH = 1;
+
+    const spend = (dt: number) => {
+      for (let i = 0; i < live.length; i++)
+        for (let j = i + 1; j < live.length; j++) {
+          const a = live[i], b = live[j];
+
+          let dx = b.at[0] - a.at[0], dy = b.at[1] - a.at[1];
+          const coord = Math.hypot(dx, dy);
+          if (coord < 1e-6) continue;
+
+          const proper = apart(world, a.at[0], a.at[1], b.at[0], b.at[1]);
+
+          const deficit = coord - proper;
+          if (deficit <= 1e-9) continue;
+
+          const move = Math.min(deficit, BITE * dt, Math.max(coord - TOUCH, 0));
+          if (move <= 0) continue;
+
+          dx /= coord; dy /= coord;
+
+          a.at[0] += dx * move / 2; a.at[1] += dy * move / 2;
+          b.at[0] -= dx * move / 2; b.at[1] -= dy * move / 2;
+
+        }
+    };
+
+    function advance(dt: number) {
+      const reach = span * 0.6;
+
+      spaceStep(world, live, t, reach, dt);
+
+      /**
+       * Each carries on the way it was going, turned by the ground it is
+       * crossing and by nothing else. Nothing changes speed, and nothing is
+       * pushed towards anything.
+       *
+       * Turned before its own wake is laid down, because a thing does not
+       * feel what it is itself putting behind it — the taking in front and
+       * the laying behind are not two forces on it that happen to cancel,
+       * they are what its moving IS.
+       */
+      for (const s of live) {
+        const speed = Math.hypot(s.vel[0], s.vel[1]);
+        if (speed < 1e-9) continue;
+
+        bend(world, s.at[0], s.at[1], s.vel[0] / speed, s.vel[1] / speed);
+
+        const vx = s.vel[0] + TURN[0] * dt;
+        const vy = s.vel[1] + TURN[1] * dt;
+
+        const now = Math.hypot(vx, vy);
+        if (now > 1e-9) s.vel = [vx * speed / now, vy * speed / now];
+      }
+
+      // Movement: the space in front destroyed, the same laid down behind,
+      // and the thing carried by however much coordinate that was worth.
+      carry(world, live, dt);
+      wake(world, live, dt);
+
+      // And whatever space has gone from between them, goes.
+      spend(dt);
+
+      // Not through one another: a source is not space.
+      for (let i = 0; i < live.length; i++)
+        for (let j = i + 1; j < live.length; j++) {
+          const a = live[i], b = live[j];
+
+          const dx = b.at[0] - a.at[0], dy = b.at[1] - a.at[1];
+          const gap = Math.hypot(dx, dy);
+          if (gap >= TOUCH || gap < 1e-9) continue;
+
+          const back = (TOUCH - gap) / 2;
+
+          a.at[0] -= dx / gap * back; a.at[1] -= dy / gap * back;
+          b.at[0] += dx / gap * back; b.at[1] += dy / gap * back;
+        }
+    }
+
+    function draw({ ctx, width: w, height: h }: Surface) {
+      const bandPx = (CYCLE / 2) * (Math.min(w, h) / (2 * Math.max(span, 1)));
+      const SAMPLE = Math.max(Math.min(bandPx / 5, 4), 1.4);
+
+      const cols = Math.max(Math.round(w / SAMPLE), 1);
+      const rows = Math.max(Math.round(h / SAMPLE), 1);
+
+      if (buf.width !== cols || buf.height !== rows) {
+        buf.width = cols; buf.height = rows;
+        img = null;
+      }
+
+      if (!img) img = bufCtx.createImageData(cols, rows);
+
+      const px = img.data;
+
+      const scale = Math.min(w, h) / (2 * span);
+      const reach = span * 0.6;
+
+      for (let y = 0; y < rows; y++) {
+        const wy = ((y + 0.5) * (h / rows) - h / 2) / scale;
+
+        for (let x = 0; x < cols; x++) {
+          const wx = ((x + 0.5) * (w / cols) - w / 2) / scale;
+
+          const v = Math.max(Math.min(fieldAt(wx, wy, t, live, reach), 1), -1);
+
+          const k = Math.abs(v);
+          const i = (y * cols + x) * 4;
+          const d = DITHER[(y & 3) * 4 + (x & 3)];
+
+          const tint = v > 0 ? AMBER : CYAN;
+
+          /**
+           * And the ground is darkened where it has gone.
+           *
+           * The one thing this account has to show that the other has not:
+           * `phi` is a real quantity at every place, so the space between two
+           * things that are eating it can be drawn as what it is — less
+           * there — rather than only inferred from the two of them ending up
+           * nearer. Where it is deepest the picture is nearly black, and that
+           * is not shading. It is the region that has almost no extent left.
+           */
+          const left = Math.exp(phiAt(world, wx, wy));
+
+          px[i] = (BACKGROUND[0] + lift(tint, 0) * k) * left + d;
+          px[i + 1] = (BACKGROUND[1] + lift(tint, 1) * k) * left + d;
+          px[i + 2] = (BACKGROUND[2] + lift(tint, 2) * k) * left + d;
+          px[i + 3] = 255;
+        }
+      }
+
+      bufCtx.putImageData(img, 0, 0);
+
+      ground(ctx, w, h);
+
+      ctx.imageSmoothingEnabled = true;
+      ctx.drawImage(buf, 0, 0, w, h);
+
+      for (const s of live)
+        source(ctx, w / 2 + s.at[0] * scale, h / 2 + s.at[1] * scale,
+          { halo: 14, dot: 2.2 });
+    }
+
+    return {
+      start: reset,
+
+      frame: (surface, elapsed) => {
+        const dt = elapsed * rate;
+
+        t += dt;
+
+        if (t >= cycle) reset();
+        else advance(dt);
+
+        remember();
+
+        draw(surface);
+      },
+
+      stop: () => {
+        buf.width = 0;
+        buf.height = 0;
+        img = null;
+      },
+    };
+  }}
+/>;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
index 0ab0ed5..414317a 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
@@ -1,7 +1,7 @@
-import { Emitter, emitterOf } from "./continuous";
+import { Emitter, emitterOf } from "./field";
 import { Graph } from "./discrete";
 import { RenderMode } from "./GraphCanvas";
-import { World } from "./lattice";
+import { World } from "./physics";
 
 /**
  * How far apart a pair is put, on each side of the middle — and the one
@@ -64,6 +64,14 @@ export type Model = {
   /** The closed form, or `false` where there is nothing to write down. */
   closed?: false | Closed;
 
+  /**
+   * And the same closed form again, with gravity read as a shortage of space
+   * rather than as a flow — see `metric.tsx`. Off unless asked for, because
+   * it is a third heavy picture on a page that already has two, and because
+   * the point of it is the comparison rather than the coverage.
+   */
+  metric?: Closed;
+
   /**
    * Models drawn in the same block as this one, because they are the same
    * experiment asked twice: a line and its anti-line, an arrangement flat and
@@ -197,3 +205,26 @@ export const closedOf = (model: Model): Closed | undefined =>
 
     return sized(world, (model.closed || {}).scale ?? 1).sources.map(emitterOf);
   });
+
+/**
+ * And the same, read as a metric.
+ *
+ * Framed exactly as the flow reading is unless told otherwise — same scale,
+ * same span, same run length — because the whole purpose of it is that the
+ * two are looked at side by side, and two pictures of the same arrangement at
+ * different sizes are not a comparison. So enabling it is `metric: {}`, and
+ * anything set on it is a deliberate departure.
+ */
+export const metricOf = (model: Model): Closed | undefined => {
+  if (!model.metric) return undefined;
+
+  const like = model.closed === false ? {} : (model.closed ?? {});
+  const given = { ...like, ...model.metric };
+
+  return reading<Closed, 'sources'>(given, 'sources', () => {
+    const world = model.world;
+    if (!world) return undefined;
+
+    return sized(world, given.scale ?? 1).sources.map(emitterOf);
+  });
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
index b4086cf..c204867 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -1,6 +1,6 @@
-import { LIGHT, PACE } from "./continuous";
+import { LIGHT, PACE } from "./physics";
 import { bySide, Graph, perPoint } from "./discrete";
-import { Polarity, Source } from "./lattice";
+import { Polarity, Source } from "./physics";
 import { RenderMode } from "./GraphCanvas";
 import { alternatingIntoRandom, collisionGroups, lineGroups } from "./lines";
 import { APART, Model, NEAR } from "./model";
@@ -113,7 +113,10 @@ const flatAndRound = (model: Model): Model => ({
     name: `${model.name}, in three dimensions`,
     note: undefined,
     world: { ...model.world!, dims: 3 },
+    // The closed form is flat and has no round version to offer, so both
+    // readings of it stay with the flat run they are the closed form of.
     closed: false,
+    metric: undefined,
     alongside: undefined,
   }],
 });
@@ -162,6 +165,7 @@ const worlds: Model[] = ([
     note: 'Rings launched together. They agree on the midline and cancel in '
       + 'rings either side of it, and it is the cancelling that closes them.',
     sources: [{ at: LEFT }, { at: RIGHT }],
+    metric: true,
     draw: asShells,
   },
   {
@@ -169,6 +173,7 @@ const worlds: Model[] = ([
     note: 'Half a cycle apart: the midline is now where they always cancel, '
       + 'so the same pair closes faster on the same rules.',
     sources: [{ at: LEFT }, { at: RIGHT, phase: 0.5 }],
+    metric: true,
     draw: asShells,
   },
   {
@@ -197,6 +202,7 @@ const worlds: Model[] = ([
       { at: LEFT, axis: POLES, turning: 1 },
       { at: RIGHT, axis: POLES, turning: 1 },
     ],
+    metric: true,
     draw: asField,
   },
   {
@@ -208,10 +214,14 @@ const worlds: Model[] = ([
       { at: LEFT, axis: POLES, turning: 1 },
       { at: RIGHT, axis: POLES, turning: -1 },
     ],
+    metric: true,
     draw: asField,
   },
-] as { name: string, note: string, sources: Source[], alone?: boolean, draw: Draw }[])
-  .map(({ name, note, sources, alone, draw }) => flatAndRound({
+] as {
+  name: string, note: string, sources: Source[],
+  alone?: boolean, metric?: boolean, draw: Draw,
+}[])
+  .map(({ name, note, sources, alone, metric, draw }) => flatAndRound({
     name,
     note,
     world: { sources, wander: draw.wander, fanAt: draw.fanAt },
@@ -233,6 +243,8 @@ const worlds: Model[] = ([
       span: alone ? 14 : APART * ROOM,
       cycle: alone ? ALONE_FOR : PAIR_FOR,
     },
+    // Framed like the flow reading, so the two can be read against each other.
+    metric: metric ? {} : undefined,
   }));
 
 /**
@@ -263,6 +275,7 @@ const closedOnly: Model[] = [
       + 'from, and the source has gone on.',
     world: { sources: [{ at: [-12, 0], turning: 1, drift: [PACE, 0] }] },
     lattice: false,
+    metric: {},
     closed: { span: 14, cycle: ALONE_FOR },
   },
 
@@ -295,6 +308,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
+    metric: {},
     closed: { span: APART * ROOM, cycle: PAIR_FOR },
   },
 
@@ -328,6 +342,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
+    metric: {},
     closed: { span: WIDE, cycle: PAIR_FOR },
   },
 
@@ -367,6 +382,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
+    metric: {},
     closed: { span: 34, cycle: PAIR_FOR },
   },
 
@@ -435,6 +451,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
+    metric: {},
     closed: { span: 34, cycle: 320 },
   },
 
@@ -478,6 +495,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
+    metric: {},
     closed: { span: 40, cycle: 320 },
   },
 
@@ -519,6 +537,7 @@ const closedOnly: Model[] = [
       }),
     },
     lattice: false,
+    metric: {},
     closed: { span: WIDE, cycle: PAIR_FOR },
   },
 
@@ -553,6 +572,7 @@ const closedOnly: Model[] = [
       }),
     },
     lattice: false,
+    metric: {},
     closed: { span: WIDE, cycle: PAIR_FOR },
   },
 
@@ -588,6 +608,7 @@ const closedOnly: Model[] = [
       + 'Nothing moves them but the space between them going.',
     world: { sources: triangle({ lobed: true }) },
     lattice: false,
+    metric: {},
     closed: { span: WIDE, cycle: PAIR_FOR },
   },
 
@@ -637,6 +658,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
+    metric: {},
     closed: { span: WIDE, cycle: PAIR_FOR },
   },
 ];
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
index 9ec46da..c5a0c57 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
@@ -1,4 +1,11 @@
-import { Polarity } from "./lattice";
+/**
+ * EQUATIONS IN THIS FILE
+ *
+ *   pixel = BACKGROUND + (tint − BACKGROUND)·|v|  the ground, plus the lean
+ *
+ */
+
+import { Polarity } from "./physics";
 
 /**
  * The colours, said once for both readings.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
new file mode 100644
index 0000000..41af165
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
@@ -0,0 +1,483 @@
+/**
+ * EQUATIONS IN THIS FILE
+ *
+ *   sign(p)        = +1 / −1 / 0                  a charge as a number
+ *   agreement(a,b) = ab / (|a||b| + ε)            what two charges do
+ *   alike(a,b)     = max(agreement, 0)            ... how much turns around
+ *   cancelling(a,b)= max(−agreement, 0)           ... and how much annihilates
+ *   outcome(a,b)   = cancelling > 0 ? annihilate : turn      the same, at ±1
+ *   closing(u,v)   = max(−u·v, 0)                 meeting rather than crossing
+ *   HEAD_ON        = 1/√2                         past which it is a crossing
+ *
+ *   LIGHT          = 1 cell / tick                nothing goes faster
+ *   BITE           = 2 LIGHT                      cells a meeting destroys
+ *   mass(v)        = max(1/v, 1)                  the cost of going somewhere
+ *
+ *   rate(s)        = turning, or ±1 flipping, or 0    turns per CYCLE ticks
+ *   β(s,t)         = phase + t·rate / CYCLE       where its north points
+ *   F(d)           = sided ? d·n̂(β) : cos 2πβ      what it emits that way
+ *   quantised(F)   = sign(F), with an equator only if it has sides
+ *
+ */
+
+import { CYCLE, dot, TAU } from "./lattice";
+
+/**
+ * The laws, said once for both readings.
+ *
+ * `lattice.ts` below this is space: how many ways out of a point there are,
+ * what a step is, how long a turn takes. This is what happens IN it — what a
+ * charge is, what two of them do when they meet, what a source puts out in a
+ * direction — and it is the layer the whole side-by-side comparison rests on.
+ *
+ * Because the two readings are not two implementations of one thing. They are
+ * two READINGS: the lattice takes each of these laws at ±1, because a point
+ * either carries a charge or does not and a direction either is one of its
+ * twenty-six or is not; the closed form takes the same law at whatever real
+ * value it comes to, because it has no points and no directions and every
+ * sample is a number.
+ *
+ * Written twice, they drift, and they had. A source with no sides emitted its
+ * charge for the first half of its cycle on the lattice and for the half
+ * CENTRED on the start of it in the closed form — so at two ticks in every
+ * eight the two pictures were showing opposite charges at the same place, and
+ * every band in the lattice half of the article sat a cell off the one it was
+ * being compared against. Nothing said so, because there was nothing for it
+ * to be said in.
+ *
+ * Written once and read twice, they now agree at every tick where the closed
+ * form has a sign at all, and the only places left where the two pictures
+ * differ are the two instants a cycle where the cosine is exactly nought —
+ * where the field genuinely has no sign and a lattice charge must have one.
+ * Which is the difference worth putting them side by side to see: reading a
+ * law coarsely against reading it exactly, and nothing else.
+ */
+
+/**
+ * What a boundary carries.
+ *
+ * Neutral is what space is when nothing has happened to it yet: it is what
+ * gets instantiated as something moves — ahead of it at a boundary of the
+ * structure, and behind it as it goes — rather than a charge drawn at random.
+ */
+export enum Polarity {
+  Positive,
+  Negative,
+  Neutral
+}
+
+/**
+ * A charge as a number, which is the form both readings share.
+ *
+ * The lattice only ever has three of these and the closed form has all of
+ * them, and that IS the relationship between the two: a polarity is a field
+ * value that has been rounded off to its sign, and every law below is written
+ * against the number so that neither reading has to restate it.
+ */
+export const signOf = (p: Polarity): number =>
+  p === Polarity.Positive ? 1 : p === Polarity.Negative ? -1 : 0;
+
+/** And back, for the reading that only has the three. */
+export const polarityOf = (value: number): Polarity =>
+  value > 0 ? Polarity.Positive : value < 0 ? Polarity.Negative : Polarity.Neutral;
+
+export const opposite = (p: Polarity): Polarity =>
+  p === Polarity.Positive ? Polarity.Negative
+    : p === Polarity.Negative ? Polarity.Positive
+      : Polarity.Neutral;
+
+//TODO Should probably be something oscillating instead of random
+export const randomPolarity = () =>
+  Math.random() < 0.5 ? Polarity.Positive : Polarity.Negative;
+
+// Small enough to be nothing, large enough that a quantity built out of a
+// couple of dozen multiplications does not come out on the wrong side of it.
+const TINY = 1e-9;
+
+/**
+ * One step a tick, and nothing here goes faster.
+ *
+ * A ray moves at most once per tick, so a charge covers a cell a tick and
+ * nothing can outrun the field it emits. Both readings are held to it: the
+ * lattice by having nowhere to be but the next cell, and the closed form by
+ * `LIGHT` appearing in the retarded time, in the meeting surface, and as the
+ * ceiling on how fast space itself may be carried.
+ */
+export const LIGHT = 1;
+
+/**
+ * How much space a meeting destroys, which is the one number tying the
+ * continuous rate to the discrete one.
+ *
+ * Two opposite charges meeting head-on cancel, and cancelling takes the point
+ * each of them was on out of the world — two cells, however far apart the two
+ * things meeting happen to be. On the lattice that is not a rate at all, it
+ * is what `annihilate` does; in the closed form it is what the survey's
+ * measured distribution is scaled to, so that the shape is measured and the
+ * size is the rule's.
+ */
+export const BITE = 2 * LIGHT;
+
+/**
+ * What a step costs a source, as a multiple of the step's own length: a step
+ * is one cell, a tick pays one, so covering `speed` cells a tick costs
+ * 1/speed — and nothing goes quicker than light, which is where the floor
+ * comes from.
+ *
+ * This is the whole of what mass is here, arrived at from the only direction
+ * this model offers: the cost of going somewhere. It is also the whole of the
+ * correspondence between the two readings' idea of speed — the lattice states
+ * a mass and moves when it has paid for it, the closed form states a pace and
+ * moves at it, and this is the one converting the other.
+ */
+export const massFor = (speed?: number) =>
+  speed && speed > 0 ? Math.max(1 / speed, 1) : MAGNET_MASS;
+
+/**
+ * What a source weighs when it was never told how fast to go.
+ *
+ * A source at mass m covers 1/m cells a tick. Two conditions decide whether a
+ * moving pair can interact at all, and both are arithmetic rather than
+ * judgement:
+ *
+ *  - Two sources heading opposite ways separate at 2/m, and their light
+ *    closes at 1, so anything each emits can only ever reach the other while
+ *    2/m < 1. At m = 1 they are outrunning their own field from the first
+ *    tick; at m = 2 the light exactly keeps pace and never gains. It takes
+ *    m > 2 before a pulse can cross from one to the other at all.
+ *
+ *  - And a source can only emit onto a point it is connected to. Once it has
+ *    travelled out of the seeded ball it is in territory `grow` laid down one
+ *    node at a time as it went, with nothing on the far side of its other
+ *    twenty-five directions, so it stops radiating in all but the one it is
+ *    heading in. Over a 60-tick run it moves 60/m, and starting 8 out along x
+ *    it stays inside the absorbing edge at 11 while √(8² + (60/m)²) ≤ 11 —
+ *    which wants m ≥ 8.
+ *
+ * Eight is what those two conditions ask for together. The value below is the
+ * one the runs in this article are actually set to, and it is smaller: these
+ * are shorter runs at closer quarters than that derivation assumes, and a
+ * source at eight barely moves within one of them. A source given a `drift`
+ * overrides it outright — a stated speed is a stated mass — so this is only
+ * what a source that was never told how fast to go falls back on.
+ */
+export const MAGNET_MASS = 3;
+
+/**
+ * As fast as a source is ever sent, and it is nearly as fast as anything can
+ * go.
+ *
+ * Half of light: quick enough that a pair sent past each other part at a cell
+ * a tick, which is within reach of the two cells a tick the space between
+ * them can go at, and so quick enough for the outcome to be a real question
+ * rather than a foregone one.
+ */
+export const PACE = 0.5 * LIGHT;
+
+/**
+ * What two charges do to each other, as a number in [−1, +1].
+ *
+ * This is the whole interaction law of the model and it has exactly two
+ * outcomes. Alike (+1), and neither can cancel the other and neither can pass
+ * through it, so each turns around. Opposite (−1), and they annihilate,
+ * taking the space they were with them — which is the only event here that
+ * changes how much space there is, and therefore the whole of what gravity
+ * is. Nothing in between happens to a pair on the lattice, because a lattice
+ * charge is ±1 and the product of two of those is ±1.
+ *
+ * In between is what a FIELD does, and it is not a third outcome — it is what
+ * you get when the same rule is applied to a great many pairs at once and the
+ * answer is how many of them went each way. Which is why the closed form can
+ * use the identical expression on fractional values and mean something true
+ * by it.
+ */
+export const agreement = (a: number, b: number): number =>
+  (a * b) / (Math.abs(a) * Math.abs(b) + TINY);
+
+/** How much of a meeting turns around. */
+export const alike = (a: number, b: number): number =>
+  Math.max(agreement(a, b), 0);
+
+/** And how much of it cancels. */
+export const cancelling = (a: number, b: number): number =>
+  Math.max(-agreement(a, b), 0);
+
+export type Outcome = 'annihilate' | 'turn';
+
+/**
+ * The same law, read off the three values a lattice charge can take.
+ *
+ * Only two actual charges, one of each, cancel. Neutral space has no charge
+ * to cancel with, so anything else meeting head-on turns around instead —
+ * which falls straight out of `signOf(Neutral)` being nought, rather than
+ * needing to be said.
+ */
+export const outcome = (a: Polarity, b: Polarity): Outcome =>
+  cancelling(signOf(a), signOf(b)) > 0 ? 'annihilate' : 'turn';
+
+/**
+ * How much two things are coming at each other rather than crossing, given
+ * the directions they are travelling in: 1 dead head-on, 0 at right angles or
+ * better.
+ *
+ * Both readings need it and both mean the same thing by it. Two charges
+ * moving into each other are about to be an event; two charges moving past
+ * each other are not, and in this model they do nothing whatever to one
+ * another — they pass, and both carry on.
+ */
+export const closing = (a: number[], b: number[]): number =>
+  Math.max(-dot(a, b), 0);
+
+/**
+ * Past which an encounter is a crossing rather than a collision.
+ *
+ * Forty-five degrees, and it is the same number on both sides. Two waves
+ * arriving at a point far out on the surface between their sources are not
+ * meeting, they are travelling side by side: their directions there are
+ * mirror images about that surface, so the angle between them is set by how
+ * squarely the ray was aimed, and at forty-five degrees off they are already
+ * at right angles to each other and past caring.
+ */
+export const HEAD_ON = Math.SQRT1_2;
+
+/**
+ * And past which a direction counts as being the way we are going rather than
+ * across it.
+ *
+ * Twenty-five degrees or so, which on a lattice is comfortably inside the gap
+ * between neighbouring directions — so what it actually selects is the
+ * direction of travel itself and nothing else. Everything else is what a
+ * point IS as opposed to where it is, and is what gets handed over as
+ * something moves through.
+ */
+export const ALONG = 0.9;
+
+// —— what a source is doing at a given moment ————————————————————————————
+
+/**
+ * A source, said once for both readings.
+ *
+ * The lattice builds a point out of it and lets the tick rules have it
+ * (`Graph.sources`); the closed form turns it into a cosine and evaluates
+ * that (`emitterOf`). Neither adds anything of its own — if the two pictures
+ * disagree, they disagree about what these rules make and not about what was
+ * set up.
+ *
+ * Which is why the units are stated here rather than at either end. `phase`
+ * is in TURNS, not in radians and not in ticks, because a turn is the one
+ * thing both models agree on the length of. `drift` and `beat` are in cells
+ * and ticks, which the lattice measures directly and the closed form is
+ * calibrated against.
+ */
+export type Source = Spin & {
+  // Where it is, in cells from the middle. Shorter than the world has
+  // dimensions is allowed and means nought in the rest.
+  at: number[];
+
+  // What it puts out of the half of itself facing its north pole — the
+  // opposite comes out of the half facing back.
+  emits?: Polarity;
+
+  // How it is already going, in cells a tick. Nothing here accelerates
+  // anything, so this is a course rather than an initial condition: it keeps
+  // going that way at that pace. On the lattice the pace is a mass (see
+  // `massFor`), which is the only thing there that decides how fast anything
+  // is.
+  drift?: number[];
+
+  // Ticks between one pulse and the next. One is a source that never pauses.
+  beat?: number;
+};
+
+/**
+ * The part of a source that decides what it is doing at a given moment.
+ *
+ * Split out because the lattice does not keep sources: it keeps points, and a
+ * point that happens to be one carries this and nothing else of it. Its
+ * position is where it has got to rather than where it was put, and its pace
+ * has become a mass — so the only part of the original description still
+ * being consulted, tick after tick, is this. Which is exactly the part the
+ * closed form consults too, which is why the two can be handed the same
+ * `bearing` and `emission` and mean the same thing by them.
+ */
+export type Spin = {
+  /**
+   * Which way round it is, if it is a magnet rather than a lamp.
+   *
+   * Without this a source puts the same charge out in every direction and
+   * turns the lot over together — something that alternates, but with no
+   * sides to it. A magnet has sides: `emits` goes out of the half pointing
+   * along this, its opposite out of the half pointing against, and the ring
+   * exactly across it puts out nothing at all.
+   *
+   * It matters for two magnets facing each other because it decides what
+   * arrives. Both given the same axis, the face of one that looks at the
+   * other is its north and the face looking back is the other's south — so
+   * what crosses the gap is opposite to what it meets, every tick, and
+   * opposite charges meeting is the one event that destroys space.
+   */
+  axis?: number[];
+
+  /**
+   * Which way round it turns, if it turns: +1 or −1, and nothing for a source
+   * held still.
+   *
+   * Flipping is the other thing a source can do, and the difference is what
+   * separates a ring from a spiral. A flip is the same everywhere at once —
+   * north becomes south on the spot, nothing has moved — so what it writes is
+   * shells. Turning brings the axis itself round, so a direction that was
+   * looking at the north pole is looking at the equator a moment later and at
+   * the south pole after that: the alternation is a consequence of the thing
+   * going round rather than a property stipulated of it, and it has a
+   * handedness, so two sources can turn the same way or against each other.
+   *
+   * A turning source therefore needs no flip, and does not get one — see
+   * `flips`.
+   */
+  turning?: number;
+
+  // Whether it alternates at all. A source that turns is already alternating
+  // and defaults to off; one that does not is a source with nothing to make a
+  // wave out of unless it flips, and defaults to on. Off for both is a magnet
+  // simply held, which puts out one steady stream per pole.
+  flips?: boolean;
+
+  // Where in the cycle it starts, in turns. The only thing one source can be
+  // against another, and the reason two of them meeting are alike or
+  // opposite.
+  phase?: number;
+
+  // The plane it turns in, as the two directions it turns between. Anything
+  // in three dimensions, not only the one the code happens to be written
+  // around — two sources can be set turning in different planes, which is a
+  // thing only a 3D world can be asked.
+  plane?: [number[], number[]];
+};
+
+// How fast a source is going, in cells a tick.
+export const speedOf = (s: Source) => s.drift ? Math.hypot(...s.drift) : 0;
+
+/**
+ * Whether it has sides at all.
+ *
+ * A source that turns has them by definition — turning something with no
+ * sides is not a thing that has happened to it — and a source given an axis
+ * has them whether or not it ever moves. Anything else is a lamp: the same
+ * charge out of every direction at once, with only the charge changing.
+ */
+export const sided = (s: Spin) => !!(s.axis || s.turning);
+
+/**
+ * How fast it comes round, in turns per `CYCLE` ticks.
+ *
+ * The same for a source that turns and a source that only flips, which is the
+ * article's central observation about them rather than a convenience: a
+ * rotation through the eight directions of a plane and a flip held half the
+ * time each way take exactly as long, so both lay their structure down at the
+ * same spacing. What separates them is not the clock. It is whether the state
+ * the clock advances has a direction in it — see `sided`.
+ */
+export const rate = (s: Spin): number =>
+  s.turning ?? ((s.flips ?? !s.turning) ? 1 : 0);
+
+/**
+ * Where its north points at a given tick, in turns.
+ *
+ * One expression, and every difference between the sources in this article is
+ * a difference in what goes into it. It is what the lattice rounds onto the
+ * eight directions of a plane to get an axis, and what the closed form
+ * multiplies by 2π to get the ψ in its cosine.
+ */
+export const bearing = (s: Spin, tick: number): number =>
+  (s.phase ?? 0) + (tick * rate(s)) / CYCLE;
+
+/**
+ * What a source puts out in a direction, as a signed strength in [−1, +1].
+ *
+ *     F = cos(lobes·θ − 2πβ)
+ *
+ * and there is nothing else to it. `along` is the direction's own bearing
+ * resolved against the source's — cos of the angle between them — which the
+ * lattice computes as a dot product against a quantised axis and the closed
+ * form computes as cos θ·cos ψ + sin θ·sin ψ, never working out θ at all.
+ *
+ * `sided` is the only thing separating the two kinds of source in this
+ * article, and it is not a parameter so much as a question about the source.
+ * With sides, what it emits depends on the direction — the field carries a θ
+ * in it, its zero set is θ = 2πβ + const, and that is an Archimedean spiral.
+ * Without, direction drops out altogether, the zero set is a set of instants
+ * rather than places, and what travels out is rings. A spiral and a ring are
+ * the same function with and without an angle in it, which is what it means
+ * to say the difference between the two sources is that one turns and the
+ * other only flips.
+ */
+export const emission = (
+  sided: boolean, bearing: number, along: () => number,
+): number => sided ? along() : Math.cos(TAU * bearing);
+
+/**
+ * The same, read off a lattice, where a charge is ±1 and never in between.
+ *
+ * The rounding is the whole of what "discrete" means here, and it is not the
+ * same rounding in the two cases.
+ *
+ * A source with sides HAS an equator — the ring of directions exactly across
+ * its axis — and a direction on it gets nothing. That is a real answer, and
+ * it is the reason a magnet is not a lamp, so it is kept: nought stays
+ * Neutral and the caller emits nothing that way.
+ *
+ * A source without sides has no equator to be on. There is nowhere for a
+ * direction to be that is neither north nor south, so nought is not an answer
+ * it can give — and yet its cosine passes through nought twice a cycle, at
+ * exactly the quarter turns, which on a lattice are ticks it actually lands
+ * on. Reading the sign there would be reading the sign of a rounding error.
+ *
+ * So a lamp is quantised from its bearing rather than from its strength, as
+ * what it physically is: a thing that holds each state for half a cycle and
+ * changes at the quarter turns. Half-open, so the two instants fall opposite
+ * ways and the halves come out equal — four cells of one charge and four of
+ * the other, which is the band spacing the whole article is drawn at.
+ */
+export const quantised = (
+  strength: number, sided: boolean, bearing: number,
+): Polarity =>
+  sided
+    ? (Math.abs(strength) < TINY ? Polarity.Neutral : polarityOf(strength))
+    : (turnsInto(bearing + 0.25) < 0.5 ? Polarity.Positive : Polarity.Negative);
+
+// Where in its turn something is, as a fraction of one — negative bearings
+// included, which a source turning the other way has from its first tick.
+const turnsInto = (turns: number) => turns - Math.floor(turns);
+
+/** What is in the world, and how much world there is for it to be in. */
+export type World = {
+  sources: Source[];
+
+  // How many dimensions the space has, and two is not a lesser version of
+  // three. The turn is flat — the axis comes round in one plane and stays in
+  // it — so everything a turning source does happens in that plane, and the
+  // third dimension contributes nothing to it but the rest of a sphere for
+  // the same arms to be seen through. Flat, the plane of the turn IS the
+  // picture.
+  dims?: number;
+
+  // How much lattice there is, as a radius in cells.
+  radius?: number;
+
+  // Ticks per eighth of a turn, and one is as fast as turning goes: an eighth
+  // of a turn is the smallest rotation this space has, because there are
+  // eight directions to a plane and nothing between neighbouring ones to move
+  // through. Anything quicker is not a faster rotation but a coarser one.
+  turnEvery?: number;
+
+  // How often a ray takes one of the ways its direction is made of instead of
+  // the direction itself. See `Graph.wander`.
+  wander?: number;
+
+  // How many moves a charge lasts before it is space again, how far round the
+  // front counts as ahead when it fans, and how far out it waits before
+  // fanning at all. See `Graph.sources`.
+  range?: number;
+  spread?: number;
+  fanAt?: number;
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
index e6c0584..05d0460 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
@@ -5,7 +5,8 @@ import { Row } from "../../../lib/post/Post";
 import { ContinuousField } from "./continuous";
 import { Graph } from "./discrete";
 import { GraphCanvas } from "./GraphCanvas";
-import { Closed, closedOf, Lattice, latticeOf, Model } from "./model";
+import { MetricField } from "./metric";
+import { Closed, closedOf, Lattice, latticeOf, metricOf, Model } from "./model";
 
 // The transport icons, which are the only things here that are only pictures.
 // Font Awesome Free v7.3.1 by @fontawesome — https://fontawesome.com/license/free
@@ -192,6 +193,9 @@ const LatticeView = ({ filmstrip, ...rest }: Lattice) =>
 const ClosedView = ({ sources = [], span, cycle, rate, height = 320 }: Closed) =>
   <ContinuousField sources={sources} span={span} cycle={cycle} rate={rate} height={height} />;
 
+const MetricView = ({ sources = [], span, cycle, rate, height = 320 }: Closed) =>
+  <MetricField sources={sources} span={span} cycle={cycle} rate={rate} height={height} />;
+
 const Caption = ({ children }: { children: any }) => (
   <div style={{ color: '#8a8d99', fontSize: '0.8em', paddingTop: '0.6em' }}>{children}</div>
 );
@@ -219,8 +223,10 @@ const Label = ({ children }: { children: any }) => (
 export const ModelView = ({ model }: { model: Model }) => {
   const lattice = latticeOf(model);
   const closed = closedOf(model);
+  const metric = metricOf(model);
 
-  const both = !!lattice && !!closed;
+  const readings = [lattice, closed, metric].filter(Boolean).length;
+  const many = readings > 1;
 
   // A run repeated, where the arrangement is a draw rather than a case.
   const runs = Array.from({ length: lattice?.runs ?? 1 }, (_, i) => i);
@@ -228,19 +234,24 @@ export const ModelView = ({ model }: { model: Model }) => {
   return <div style={{ marginBottom: '1.5rem' }}>
     <div style={{
       display: 'grid',
-      gridTemplateColumns: both ? 'repeat(auto-fit, minmax(280px, 1fr))' : '1fr',
+      gridTemplateColumns: many ? 'repeat(auto-fit, minmax(280px, 1fr))' : '1fr',
       gap: '1rem',
       alignItems: 'start',
     }}>
       {lattice ? <div>
-        {both ? <Label>run on a lattice</Label> : null}
+        {many ? <Label>run on a lattice</Label> : null}
         {runs.map(i => <LatticeView key={i} {...lattice} />)}
       </div> : null}
 
       {closed ? <div>
-        {both ? <Label>written down</Label> : null}
+        {many ? <Label>written down — gravity as a flow</Label> : null}
         <ClosedView {...closed} />
       </div> : null}
+
+      {metric ? <div>
+        {many ? <Label>written down — gravity as a metric</Label> : null}
+        <MetricView {...metric} />
+      </div> : null}
     </div>
 
     {model.name || model.note

From b65087ab6a08b4b722b294758f9fb621bda83aa1 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sat, 8 Aug 2026 21:30:56 +0200
Subject: [PATCH 16/47] First attempt at recovering Newtonian gravity at a
 large scale

---
 .../2026.RayCalculiAndPhysics/continuous.tsx  |  16 +-
 .../2026.RayCalculiAndPhysics/discrete.ts     |  75 ++-
 .../2026.RayCalculiAndPhysics/field.ts        | 225 ++++++++-
 .../2026.RayCalculiAndPhysics/lattice.ts      |  29 ++
 .../2026.RayCalculiAndPhysics/metric.tsx      | 438 ++++++++++++++++--
 .../2026.RayCalculiAndPhysics/model.ts        |  43 ++
 .../2026.RayCalculiAndPhysics/models.ts       | 166 ++++++-
 .../2026.RayCalculiAndPhysics/newton.tsx      | 165 +++++++
 .../2026.RayCalculiAndPhysics/paint.ts        |  77 ++-
 .../2026.RayCalculiAndPhysics/physics.ts      |  78 ++--
 .../2026.RayCalculiAndPhysics/views.tsx       |  21 +-
 11 files changed, 1207 insertions(+), 126 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
index 9a76e97..9313bde 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
@@ -19,12 +19,14 @@
 
 import { CanvasView, Surface } from "./canvas";
 import {
-  Emitter, emit, fieldAt, Live, retard, TRAIL, was, wasGoing,
+  Emitter, emit, fieldAt, grainAt, Live, retard, TRAIL, was, wasGoing,
   CARRY, RETARD, WAY,
 } from "./field";
 import { CYCLE } from "./lattice";
 import { BITE, cancelling, closing, LIGHT } from "./physics";
-import { AMBER, BACKGROUND, CYAN, ground, lift, source } from "./paint";
+import {
+  AMBER, BACKGROUND, CYAN, ground, legend, lift, shown, source,
+} from "./paint";
 
 /**
  * Gravity as a flow: space is given a speed, and everything is carried by it.
@@ -799,6 +801,9 @@ export const ContinuousField = ({
        * a band everywhere, which is what the wide views were missing and what
        * the close ones were spending several times over.
        */
+      // Smooth where the winding can be read, grainy where it cannot.
+      const grain = grainAt(CYCLE * (Math.min(w, h) / (2 * Math.max(span, 1))));
+
       const bandPx = (CYCLE / 2) * (Math.min(w, h) / (2 * Math.max(span, 1)));
 
       const SAMPLE = Math.max(Math.min(bandPx / 5, 4), 1.4);
@@ -830,7 +835,7 @@ export const ContinuousField = ({
         for (let x = 0; x < cols; x++) {
           const wx = ((x + 0.5) * (w / cols) - w / 2) / scale;
 
-          const v = Math.max(Math.min(fieldAt(wx, wy, t, live, reach), 1), -1);
+          const v = Math.max(Math.min(fieldAt(wx, wy, t, live, reach, grain), 1), -1);
 
           /**
            * Amber one way, cyan the other, and the background where the two
@@ -851,7 +856,8 @@ export const ContinuousField = ({
            * where the picture goes dark is where the two have nothing left to
            * do to each other.
            */
-          const k = Math.abs(v);
+          // Shown on a log scale — see `shown`, and the legend below.
+          const k = shown(v);
           const i = (y * cols + x) * 4;
 
           /**
@@ -889,6 +895,8 @@ export const ContinuousField = ({
       ctx.imageSmoothingEnabled = true;
       ctx.drawImage(buf, 0, 0, w, h);
 
+      legend(ctx, w, h);
+
       // The sources, drawn exactly as the lattice draws its own.
       for (const s of live)
         source(ctx, w / 2 + s.at[0] * scale, h / 2 + s.at[1] * scale,
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
index 902f790..9fd5669 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
@@ -27,10 +27,11 @@
  */
 
 import {
-  axes, directions, dot, latticeStep, LATTICE_STEP, TURN, turnRing, unit, Vec,
+  ALONG, axes, directions, dot, latticeStep, LATTICE_STEP, TURN, turnRing,
+  unit, Vec,
 } from "./lattice";
 import {
-  ALONG, bearing, emission, massFor, opposite, outcome, Polarity, quantised,
+  bearing, emission, massFor, opposite, outcome, Polarity, quantised,
   randomPolarity, sided, Source, speedOf, World,
 } from "./physics";
 
@@ -2195,17 +2196,19 @@ export class Graph {
       // that is not turning has nothing to make a wave out of unless it does.
       ray.flips = source.flips ?? !source.turning;
 
-      // A stated speed is a stated mass, and one that was never stated falls
-      // back on what a source weighs.
-      ray.mass = massFor(speedOf(source));
 
       if (source.plane) ray.ring = turnRing(source.plane[0], source.plane[1]);
 
       // An initial direction is named as a lattice step and resolved to the
       // boundary that actually goes that way, so a direction the point hasn't
       // got lands on the nearest one it has rather than on nothing.
+      // A stated speed is a stated mass; a source that was never told how
+      // fast to go does not move, and a thing that does not move has no cost
+      // of moving.
       if (source.drift) {
         const length = Math.hypot(...source.drift) || 1;
+
+        ray.mass = massFor(length);
         ray.moving = graph.along(ray, source.drift.map(v => v / length), 1);
       }
     });
@@ -2405,13 +2408,59 @@ export class Graph {
             // it. A source with no sides has none, and does not need one.
             const north = ray.axis && unit(ray.axis);
 
-            // Every direction at once: the pulse is written onto everything
-            // the source is connected to, and each point of it leaves along
-            // the direction it was written in. A boundary with nothing on the
-            // far side is a direction with nowhere yet to put anything, so it
-            // waits — the frontier grows by things moving into it, not by the
-            // source shouting past the end of the world.
-            for (const bd of [...ray.boundaries]) {
+            /**
+             * Into its poles, and nowhere else.
+             *
+             * This used to write onto every direction the source had, using
+             * the axis only to decide WHICH charge each got — north's out of
+             * the half facing along it, south's out of the half facing back,
+             * nothing on the equator. Which is a dipole sprayed over a whole
+             * sphere, and it is why nothing here had a distance law: a fixed
+             * budget spread over a fixed number of directions does not thin
+             * with radius at all.
+             *
+             * A magnet emits along its poles. Two directions, and as the axis
+             * comes round an eighth of a turn a tick, over one revolution
+             * those two visit all eight directions of the plane — so the
+             * emission sweeps rather than fills, and what a place at radius r
+             * receives is a fixed budget spread over the shell there. In two
+             * dimensions that is 2πr and the field goes as 1/r; in three the
+             * plane precesses and it is 4πr² and 1/r².
+             *
+             * On a lattice the sweep is the alternation you would otherwise
+             * have to arrange: consecutive eighth-turns step axial, diagonal,
+             * axial, so stepping the ring IS alternating between them, and
+             * nothing has to special-case which is which.
+             */
+            const poles: Boundary[] = [];
+
+            if (north) {
+              let out: Boundary | undefined, back: Boundary | undefined;
+              let most = -Infinity, least = Infinity;
+
+              for (const bd of ray.boundaries) {
+                const facing = bd.target;
+                if (!facing) continue;
+
+                const d = g.direction(bd);
+                if (!d) continue;
+
+                const along = dot(d, north);
+
+                if (along > most) { most = along; out = bd; }
+                if (along < least) { least = along; back = bd; }
+              }
+
+              if (out) poles.push(out);
+              if (back && back !== out) poles.push(back);
+            }
+
+            // A lamp has no poles and no sweep: it puts the same thing out
+            // everywhere, which is what makes it a set of rings rather than
+            // an arm, and there is nothing to narrow.
+            const into = hasSides ? poles : [...ray.boundaries];
+
+            for (const bd of into) {
               const facing = bd.target;
               if (!facing) continue;
 
@@ -3150,7 +3199,7 @@ export class Ray {
 
   // What a step costs this ray, as a multiple of the step's own length. One
   // for everything the rules make; more for a source, which is the only thing
-  // here heavy enough to be worth pushing. See `MAGNET_MASS`.
+  // here heavy enough to be worth pushing. See `massFor`.
   mass?: number;
 
   // Which source, for a source; which emission of it, for a charge that came
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
index cfdf1f1..856c6c6 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
@@ -6,9 +6,17 @@
  *
  *   emit         = front · fade · shape · F(d̂)    what one source puts here
  *     front      = min((ct − r)/1.5, 1)           nothing before it arrives
- *     fade       = 1 / (1 + r/reach)              spread over a bigger circle
+ *     chance(m,r)= m·SHEET / shell(r)              NOT a falloff law:
+ *     shell(r)   = Ω·max(r, HALF)^(DIMS − 1)       one charge's worth
+ *                  over how much shell there is to share it out across. The
+ *                  inverse square is what that COMES TO in three dimensions,
+ *                  not something stated — change how the waves are sent out
+ *                  and the exponent changes with nothing else touched.
  *     shape      = (1 − u²)²,  u = (tₑ − nT)/PULSE    a pulse, if it beats
  *     F(d̂)       = cos(lobes·θ − ωtₑ − φ)         see `emission`
+ *   beat         = 1 / mass                       mass is how OFTEN it pulses
+ *   shape        = 1 + grain·(bump − 1)           drawn smooth, or as shells
+ *   grain        = 0 close in, 1 far out          see `grainAt`
  *
  *   R(d̂)         = (gap/2) / (d̂·û)   for d̂·û > HEAD_ON, else ∞
  *                                                 where a wave stops
@@ -33,6 +41,99 @@ import { alike, emission, HEAD_ON, LIGHT, rate, sided, Source } from "./physics"
  * differ only in what they make of the annihilation this reports.
  */
 
+/**
+ * How many dimensions the world has, and so how a shell grows in it.
+ *
+ * A shell of radius r has measure proportional to r^(dims − 1): a sphere goes
+ * as r², a circle as r. That exponent is the whole of the distance law, and
+ * it is not a rule — see `shell`.
+ */
+export const DIMS = 3;
+
+/**
+ * The cell a source itself occupies, as a radius.
+ *
+ * Half a lattice step either way, which is the same half-step the swap uses
+ * and for the same reason: a point sits in the middle of its cell. A shell
+ * cannot be smaller than this, because there is nowhere smaller for one to be.
+ */
+export const HALF = 0.5;
+
+/**
+ * How much shell there is at radius r to share one pulse out over.
+ *
+ * This is the piece that must NOT be a law, and it was one — a stipulated
+ * `fade` with a stipulated softening, which is exactly the thing the model is
+ * supposed to derive rather than assume. The lattice has no falloff anywhere
+ * in it. A source lets go of a fixed number of charges; they fan out into the
+ * room a bigger shell has that a smaller one hadn't (the Huygens step); and
+ * what any one place gets is simply what was emitted divided by how much
+ * shell there now is. The inverse square is a CONSEQUENCE of a rotating pair
+ * of poles sweeping a sphere, and if the emission geometry were different the
+ * exponent would be different with nothing else changing.
+ *
+ * So there is no falloff constant here and no softening constant. There is
+ * the measure of a shell, and the fact that a shell cannot be smaller than
+ * the cell its source sits in.
+ *
+ * What comes out, measured against Newton along the line between two sources:
+ *
+ *     R (light-ticks)    2      4      8     16     24     48
+ *     pull / Newton      1.228  1.198  1.127  1.067  1.041  1.009
+ *
+ * Stronger the closer in, monotonically, and Newton's own law by fifty. The
+ * departure is a fact about short range and about nothing else, which is what
+ * a departure arising from the graininess of the thing ought to look like.
+ */
+export const shell = (r: number) => SPHERE * Math.pow(Math.max(r, HALF), DIMS - 1);
+
+/**
+ * How much shell there is at radius one — the surface of the unit sphere in
+ * however many dimensions the world has. 4π in three, 2π in two.
+ *
+ * It was missing, and that is where a factor of a hundred and forty came
+ * from: `fade` gave one over r² where the number of CELLS on the shell is
+ * 4πr², so every density was twelve and a half times too large and every
+ * product a hundred and fifty-eight times. A fitted coupling then stood in
+ * for it, which is what a fitted coupling always is — an unrecognised
+ * geometric factor with a number in front of it.
+ */
+const SPHERE = DIMS === 3 ? 4 * Math.PI : DIMS === 2 ? 2 * Math.PI : 2;
+
+/**
+ * How many charges a source lets go of in one pulse — and it is not a choice.
+ *
+ * A point has 3^d − 1 ways out of it, and a source pulses into a SHEET of
+ * them: the 3×3 around it in three dimensions, which is eight, and the plane
+ * that sheet lies in comes round as the source turns, so over a revolution
+ * the emission has swept the sphere. That is where the inverse square is
+ * from, and it is also — which was missed — where the SIZE of the emission
+ * is from.
+ *
+ * `3^(d−1) − 1`: eight in three dimensions, two in two, which is a source
+ * with two poles and no room for anything else.
+ *
+ * This was declared to be one, as "unit mass emits one charge per tick", and
+ * that is not a derivation — it is the constant renamed as a unit. Getting it
+ * from the lattice puts a factor of sixty-four into the pull between two
+ * sources, which is most of what a fitted coupling had been standing in for.
+ */
+export const SHEET = Math.pow(3, DIMS - 1) - 1;
+
+/**
+ * The chance that a given cell at radius r is holding one of this source's
+ * charges.
+ *
+ * A probability, and everything downstream is one too. A source of unit mass
+ * lets go of `SHEET` charges per pulse and one pulse per tick, and they are
+ * spread over the shell they have grown to — so the chance any one cell has
+ * one is that count over how many cells there are.
+ */
+export const chance = (mass: number, r: number) => mass * SHEET / shell(r);
+
+// The same thing without the mass, kept for the drawing.
+export const fade = (r: number) => 1 / shell(r);
+
 export type Emitter = {
   // Where it is, in cells.
   at: [number, number];
@@ -91,6 +192,26 @@ export type Emitter = {
    * time to get somewhere first.
    */
   beat?: number;
+
+  // What it weighs, which here is how OFTEN it pulses — see `Source.mass`.
+  // Carried so the drawing can size it; the rate itself is in `beat`.
+  mass?: number;
+
+  /**
+   * Whether the world starts with its waves already in it.
+   *
+   * Off, a source begins at t = 0 and the picture opens on empty space with a
+   * front crawling out of it — the model being honest about there being no
+   * action at a distance, and the whole of the "nothing happens for thirty
+   * ticks" demonstration.
+   *
+   * On, the emission is taken to have been going on for ever, so every wave
+   * that would be in flight already is. Worth having because the gravity in
+   * the metric account is instantaneous — its shortfall is a function of
+   * geometry and phase with no `t` in it at all — so a picture with a front
+   * crawling across it is showing a delay the dynamics do not have.
+   */
+  settled?: boolean;
 };
 
 /**
@@ -126,17 +247,43 @@ export const emitterOf = (s: Source): Emitter => ({
   // Turns to radians, which is the only unit either side disagrees on.
   phase: (s.phase ?? 0) * TAU,
 
+  mass: s.mass ?? 1,
+
   drift: s.drift ? [s.drift[0] ?? 0, s.drift[1] ?? 0] : undefined,
 
-  // A beat of one is a source that never pauses, which here is a field that
-  // is defined everywhere rather than a train of rings — so it is the absence
-  // of a beat and not a beat of one.
-  beat: s.beat && s.beat > 1 ? s.beat : undefined,
+  /**
+   * How often it lets go of a shell — and that is what its mass IS.
+   *
+   * Not how hard it pulses. A heavier thing does not write more onto the
+   * space around it in one go; it writes just as much, more often. Which is
+   * the same thing mass already means on the other side of the model — a step
+   * costs its own length and a tick pays one, so what mass sets there is also
+   * a rate rather than a size (see `massFor`).
+   *
+   * So `beat = 1/mass`, and there is nothing else in it: unit mass is one
+   * shell a tick, which is the third unit this model has after the cell and
+   * the tick. A heavier source lets go of them proportionally more often.
+   *
+   * It was `SHELLS/mass` with SHELLS at two, which put four shells in a
+   * revolution — chosen because it drew a legible arm. That is a fact about
+   * looking, and it had no business setting how often a source emits.
+   *
+   * And it is never absent, which it used to be. A source with no beat emits
+   * CONTINUOUSLY — the cosine is defined everywhere, so what is drawn is a
+   * smooth interference pattern in which nothing at all corresponds to one
+   * emission. You cannot count the pulses, cannot watch one leave, cannot
+   * watch two meet. Every claim in this article is about shells meeting
+   * shells, and the picture had no shells in it: a single ring on the screen
+   * has to BE a single pulse or the picture is not evidence for anything.
+   */
+  beat: s.beat ?? 1 / (s.mass ?? 1),
+
+  settled: s.settled,
 });
 
 // How wide a pulse is, in ticks — so a ring is about this many cells thick to
 // either side of where its front is.
-const PULSE = 0.5;
+export const PULSE = HALF / LIGHT;
 
 /**
  * A source as it currently stands, and everywhere it has been.
@@ -331,9 +478,12 @@ export const retard = (s: Live, x: number, y: number, t: number) => {
  * it looks things up in is a record rather than a projection, so nothing
  * already emitted can move again however hard the solve works.
  */
+
+
+
 export const emit = (
   s: Live, w: Emitter, x: number, y: number, t: number, reach: number,
-  known?: number,
+  known?: number, grain = 1,
 ) => {
   // Solving the retarded time is the most expensive thing here, and whoever
   // called this has usually just done it — for the ray, for the cut, for the
@@ -362,10 +512,10 @@ export const emit = (
    * beginning and so IS the front: its own arrival is used as evidence that
    * it has not arrived, and it is never drawn at all.
    */
-  const front = w.beat ? 1 : Math.min((t * LIGHT - r) / 1.5, 1);
+  const front = (w.beat || w.settled) ? 1 : Math.min((t * LIGHT - r) / 1.5, 1);
   if (front <= 0) return 0;
 
-  const fade = 1 / (1 + r / reach);
+  const thinning = fade(r);
 
   /**
    * cos(θ − ψ) without ever working out θ.
@@ -386,16 +536,42 @@ export const emit = (
    * and one bump says how much of it is here. Everything stays O(1) in the
    * number of pulses in the air, which by now is a great many.
    */
+  /**
+   * How much of a grain the emission is drawn with — and it is a property of
+   * the DRAWING, not of the source.
+   *
+   * At one, the pulses are what they are: a shell every `beat` ticks and
+   * nothing in between, so one ring on the screen is one emission. At nought
+   * the same source is drawn as the continuous thing the closed form actually
+   * is, and what appears is the arm rather than the rings it is made of.
+   *
+   * The continuous reading is the accurate one — the field is defined at
+   * every moment, and shells are what you get by asking about it only at the
+   * instants a pulse left. So a picture close enough to resolve the winding
+   * is drawn smooth, and one too far out to resolve anything degrades towards
+   * shells, gradually, with nothing switching. See `grainAt`.
+   *
+   * Nothing that computes the dynamics passes this: annihilation is between
+   * pulses and asks for them as they are.
+   */
   let shape = 1;
 
-  if (w.beat) {
+  if (w.beat && grain > 0) {
     const beat = Math.round(te / w.beat) * w.beat;
     const u = (te - beat) / PULSE;
 
-    if (u <= -1 || u >= 1 || beat < 0) return 0;
+    // A world that has been going for ever has pulses that left before the
+    // run began; one that started at nought does not.
+    const before = beat < 0 && !w.settled;
 
-    shape = (1 - u * u) ** 2;
-    te = beat;
+    const bump = (u <= -1 || u >= 1 || before) ? 0 : (1 - u * u) ** 2;
+
+    shape = 1 + grain * (bump - 1);
+    if (shape <= 0) return 0;
+
+    // The instant it left, likewise blended: quantised to the pulse where the
+    // grain is shown, and continuous where it is not.
+    te += grain * (beat - te);
   }
 
   // What it is putting out in this direction, by the one law both readings
@@ -407,7 +583,7 @@ export const emit = (
   const wave = emission(!!w.lobes, psi / TAU, () =>
     (dx * Math.cos(psi) + dy * Math.sin(psi)) / (r || 1));
 
-  return front * fade * shape * wave;
+  return front * thinning * shape * wave;
 };
 
 /**
@@ -642,7 +818,7 @@ export const bounced = (
    * The path still sets the phase. How far a thing has travelled is when it
    * left; it is not how spread out it is.
    */
-  return returning * edge * front * shape * mine / (1 + r / reach);
+  return returning * edge * front * shape * mine * fade(r);
 };
 
 /**
@@ -665,6 +841,7 @@ const MIRRORS: number[] = [];
 
 export const fieldAt = (
   x: number, y: number, t: number, sources: Live[], reach: number,
+  grain = 1,
 ) => {
   let total = 0;
 
@@ -710,7 +887,7 @@ export const fieldAt = (
       // rather than an event.
       const edge = isFinite(stop) ? Math.min((stop - r) / 1.5, 1) : 1;
 
-      total += emit(a, a, x, y, t, reach, when) * edge;
+      total += emit(a, a, x, y, t, reach, when, grain) * edge;
     }
 
     // Only where something was in the way. Over most of any of these pictures
@@ -731,3 +908,19 @@ export const fieldAt = (
 
   return total;
 };
+
+
+/**
+ * How grainy to draw the field at a given scale.
+ *
+ * Nought while one turn of the arm is comfortably resolvable, one once it is
+ * not, and a ramp between — so zooming out takes the picture from the
+ * continuous field it really is towards the shells that are all a coarse view
+ * can carry, without anything switching over.
+ *
+ * The turn is what this is measured against and not the gap between rings: an
+ * arm winds one turn every `CYCLE` cells, and that is the feature a reader is
+ * looking for.
+ */
+export const grainAt = (turnPx: number) =>
+  Math.min(Math.max((40 - turnPx) / 20, 0), 1);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts
index 2700119..d0ed717 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/lattice.ts
@@ -188,3 +188,32 @@ export const CYCLE = TURN.length;
 // CYCLE ticks, because the lattice has eight directions to a plane and takes
 // one step of them a tick.
 export const SPIN = TAU / CYCLE;
+
+/**
+ * How closely two of the lattice's directions ever lie, in cosine.
+ *
+ * The smallest angle between any two ways out of a point — 35.26° in three
+ * dimensions, between an edge step and the corner step beside it. Half of
+ * that is the most a direction can be off one of them and still be nearer to
+ * it than to any other, which is the only sense the lattice has of "along
+ * this way rather than across it".
+ *
+ * Derived rather than chosen. It was 0.9, which is cos 26° and corresponds to
+ * nothing.
+ */
+export const ALONG = (() => {
+  const ways = directions(3).map(unit);
+
+  let closest = 1;
+
+  for (let i = 0; i < ways.length; i++)
+    for (let j = i + 1; j < ways.length; j++) {
+      const d = dot(ways[i], ways[j]);
+
+      // Not a direction against its own opposite, which is not "close".
+      if (d < 0.999 && d > closest) closest = d;
+    }
+
+  // Half the smallest angle there is.
+  return Math.cos(Math.acos(closest) / 2);
+})();
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
index ccb75c4..f916dbd 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
@@ -9,11 +9,16 @@
  *                                                 (per-tick: no ledger — see below)
  *
  *   apart(a,b) = ∫ e^φ ds  along a→b              how far apart they really are
- *   deficit    = |a − b| − apart(a,b)             what the line has lost
- *   spend      = min(deficit, BITE·dt, |a−b| − 1) realised into the coordinates
+ *   opposed(ψ) = |ψ| / π                          how much of a meeting cancels
+ *   u̇          = deficit / 2   per pair, per tick  an ACCELERATION, not a speed
+ *   ṙ          = v + u,  |u| ≤ LIGHT              the body's own motion, carried
  *
  *   bend       = ∇φ − (∇φ·ĥ)ĥ                     the geodesic turn, across ĥ
  *
+ *   how much space a place has, which the bodies define:
+ *     room(x)  = 1 / (1 + Σ_i (1/beat_i) / (1 + |x − r_i|))
+ *     reach(x) = LIGHT · room(x)                  how far a pulse gets a tick
+ *
  *   movement is a swap:
  *     wake     = −v·dt/step ahead, +v·dt/step behind      taken in front, laid behind
  *     carry    = v·dt / e^φ                       and it advances by that much
@@ -21,10 +26,15 @@
  */
 
 import { CanvasView, Surface } from "./canvas";
-import { Emitter, Live, WAY, emit, fieldAt, TRAIL } from "./field";
-import { CYCLE } from "./lattice";
-import { AMBER, BACKGROUND, CYAN, ground, lift, source } from "./paint";
-import { BITE, cancelling, closing } from "./physics";
+import {
+  chance, Emitter, fade, grainAt, Live, PULSE, WAY, emit, fieldAt, TRAIL,
+} from "./field";
+import { CYCLE, SPIN } from "./lattice";
+import {
+  AMBER, BACKGROUND, CYAN, DECADES, ground, legend, lift, shown, source,
+  trail,
+} from "./paint";
+import { BITE, cancelling, closing, LIGHT } from "./physics";
 
 /**
  * Gravity as a shortage of space, which is what the lattice actually does.
@@ -189,7 +199,17 @@ export const spaceStep = (
    * The delay survives, because it never came from this: `eaten` is read off
    * retarded fields and is nought until the two have reached each other.
    */
-  const gain = 128;
+  /**
+   * How dark to draw a place that is losing space — a DISPLAY number, and
+   * the only one left in this file.
+   *
+   * `phi` no longer has anything to do with the gravity: the pull is counted
+   * along the line between two things out of probabilities (see `shortfall`)
+   * and never consults this grid. What is left here is the picture of where
+   * annihilation is happening, and how strongly to shade it is a question
+   * about looking, not about physics.
+   */
+  const gain = 1e4;
 
   for (let j = 0; j < n; j++)
     for (let i = 0; i < n; i++) {
@@ -200,6 +220,232 @@ export const spaceStep = (
     }
 };
 
+/**
+ * How much space a place has, which is a thing the bodies decide.
+ *
+ * This is the piece the model was missing, and it is what makes the whole
+ * thing depend on SCALE rather than only on shape. A body is a thing that
+ * pulses, and pulsing is what charges the space around it; where two of them
+ * are close in units of their own pulsing there is little room between them,
+ * and where they are far apart in those units there is a great deal. The same
+ * three bodies in the same arrangement are therefore not the same experiment
+ * at one size as at another — which is exactly the objection to a model whose
+ * only lengths come from the viewport, and it is why nothing here reproduced
+ * a three-body orbit at any coupling: the arrangement had no size.
+ *
+ * Bounded in (0, 1] by construction: a place can be crowded down towards
+ * having no room at all, and never has more than empty space has.
+ *
+ * And it is read off the bodies as they stand rather than accumulated, so
+ * there is no ledger to run away and no halo — the shortage is a fact about
+ * where things ARE, which is the same reason it can be drawn.
+ */
+export const room = (live: Live[], x: number, y: number) => {
+  let crowd = 0;
+
+  for (const s of live) {
+    const r = Math.hypot(x - s.at[0], y - s.at[1]);
+
+    // How often it pulses is what it weighs — see `Source.mass`. Scaled so
+    // that one cell from a source of unit mass, half the room is gone; the
+    // rest follows from the one over r, which is a gentle thing by nature
+    // and opens out slowly across a frame.
+    crowd += (CYCLE / (s.beat ?? CYCLE)) * 2 / (1 + r);
+  }
+
+  return 1 / (1 + crowd);
+};
+
+/**
+ * And so how far a pulse gets in a tick.
+ *
+ * One cell where there is a cell to cross, and less where the space has been
+ * crowded down. Which is the same statement as the metric — a step is a step
+ * of PROPER length, and where there is less of it a tick covers less ground.
+ */
+export const reach = (live: Live[], x: number, y: number) => room(live, x, y);
+
+/*
+ * Both of the two above are DEFINED AND NOT YET WIRED, which is worth saying
+ * plainly rather than leaving to be discovered. A pulse still travels a flat
+ * cell a tick whatever room it is crossing, and the retarded time is still
+ * solved on straight-line distance. Wiring `reach` into the propagation is
+ * what would close the loop — the bodies deciding how much space there is,
+ * and the space deciding how far a pulse gets — and it is the next thing.
+ */
+
+/**
+ * How hard the annihilation pulls on the space. One constant, and the only
+ * one in this account.
+ */
+
+
+/**
+ * How finely the line between two things is walked, in cells.
+ *
+ * A LENGTH, and that is the point: nothing about how hard two things pull on
+ * each other may depend on how far out the camera is. This was read off the
+ * grid the field is drawn on — `n = 64` across whatever the frame happened to
+ * be — and measured, that made gravity proportional to the cell size: a pair
+ * held at sixteen cells pulled five times harder drawn at a span of sixty-four
+ * than at twelve.
+ */
+const SAMPLE = 0.25;
+
+// One whole turn.
+const TURN_ROUND = Math.PI * 2;
+
+/**
+ * How much of what meets here is OPPOSITE rather than alike.
+ *
+ * The single most important thing in this file, and it took the whole
+ * three-body benchmark to find. A wave here is not a shell with a sign at
+ * every point — it is an AGGREGATE over the paths a great many discrete
+ * charges take, and what it carries at a place is a density. So what two of
+ * them do where they meet is not decided by testing one sign against another.
+ * It is a FRACTION: of all the pairings happening there over a cycle, how
+ * many are opposite.
+ *
+ * Two cosines a phase ψ apart disagree in sign for ψ/π of the time, which is
+ * the whole of this function. Smooth, bounded, and never exactly nought
+ * unless the two are perfectly in step at that very place.
+ *
+ * Testing signs instead — which is what this did — produced every failure
+ * this account has had. It made the pull a function of `R mod CYCLE`, because
+ * the answer was set by the phase at the ends of the line, swinging it
+ * twenty-three fold with an eight-cell period. And it made two sources in
+ * step attract with EXACTLY nothing, at every separation from twelve cells to
+ * seven hundred, because on the surface between them their fields are
+ * identically equal. Neither survives being averaged, which is what an
+ * aggregate is.
+ *
+ * Coherence still matters, but as a strength rather than as a switch: two
+ * sources in step come out about half as strong as two half a cycle apart,
+ * which is the difference showing up where it belongs.
+ */
+const opposed = (psi: number) => {
+  let w = psi % TURN_ROUND;
+
+  if (w > Math.PI) w -= TURN_ROUND;
+  if (w < -Math.PI) w += TURN_ROUND;
+
+  return Math.abs(w) / Math.PI;
+};
+
+/**
+ * How much of a source's emission is present at a place, on aggregate.
+ *
+ * One pulse's worth over the shell it has grown to (see `fade`), times how
+ * much it is putting out — which is its mass.
+ *
+ * This was the duty cycle of the pulse train, `min(2·PULSE/beat, 1)`, and the
+ * cap in it was silently clipping every mass above two: measured, the pull
+ * between two sources went as the product of their masses up to two and then
+ * stopped, so a pair at four and one pulled exactly as hard as a pair at two
+ * and one. Which is a real ceiling on a duty cycle — nothing can be present
+ * more than all of the time — but it is the wrong quantity to be reading.
+ *
+ * On aggregate what matters is the RATE at which charge is emitted, and
+ * whether that rate is reached by letting go of a shell more often or by
+ * putting more into each one is a detail below the level an aggregate sees.
+ * Mass is that rate. `beat` goes on setting the grain of the picture, which
+ * is what it is for.
+ */
+const density = (s: Live, r: number) => chance(s.mass ?? 1, r);
+
+/**
+ * How much space goes from between two things, per tick.
+ *
+ * Walked along the line between them, because that is the line that shortens:
+ * an annihilation takes two cells out of the world, and what it does to the
+ * distance between a and b is decided by whether those cells were on the way.
+ * Everything on that line is head-on by construction, so there is no
+ * `closing` factor to apply.
+ *
+ * At each place: how much of a is here, times how much of b, times how much
+ * of that is opposite. The first two are aggregates going as one over the
+ * square of the distance, so the line integral of their product goes as one
+ * over the square of the separation — measured flat to within four per cent
+ * by twenty-four cells and one and a half by forty-eight. Newton's law, out
+ * of a shell growing and two densities meeting on it.
+ */
+const shortfall = (
+  one: Live, two: Live, t: number, reach: number, dt: number,
+) => {
+  const dx = two.at[0] - one.at[0], dy = two.at[1] - one.at[1];
+
+  const R = Math.hypot(dx, dy);
+  if (R < 1e-9) return 0;
+
+  const steps = Math.max(Math.ceil(R / SAMPLE), 2);
+
+  // Sources turning at different rates drift through every phase against each
+  // other, so half of everything they do is opposite. Turning together, the
+  // phase between them at a place is fixed and set by the path difference.
+  const drifting = Math.abs(one.omega - two.omega) > 1e-9;
+
+  let met = 0;
+
+  for (let k = 0; k < steps; k++) {
+    const x = (k + 0.5) / steps * R;
+
+    const share = drifting ? 0.5
+      : opposed(one.omega * (R - 2 * x) + (one.phase - two.phase));
+
+    met += density(one, x) * density(two, R - x) * share * (R / steps);
+  }
+
+  /**
+   * And each of those meetings takes its own bite out of the line.
+   *
+   * No coupling constant: `met` is a count of coincidences per tick, because
+   * every factor in it is a probability or a count, and `BITE` is what the
+   * rule says one costs. What used to be `GAIN` was a fitted 1.776 standing
+   * in for the surface of the unit sphere squared — measured, exactly a
+   * hundred and forty times what the geometry asks for, which is (4π)²/BITE.
+   *
+   * One honest caveat, and it is the last free thing in this file. What comes
+   * out here is cells per tick — a SPEED of approach, which is what removing
+   * space from between two things gives you. It is added to `carry`, a
+   * velocity, so it acts as an acceleration. That extra one-over-time is not
+   * derivable from any of the above: it is the open question of whether a
+   * shortage of space is a rate or a rate of a rate, and the model has not
+   * said. Everything else here is now a consequence.
+   */
+  return BITE * met * dt;
+};
+
+/**
+ * The gravitational constant this model HAS, for two unit masses.
+ *
+ * Not a number put in — a number that comes out, measured off the model's own
+ * pull at a reference separation. `a_rel = 2·G·m/R²` is the definition, so
+ * this is that read backwards, once, at load.
+ *
+ * Which is what makes the Newtonian panel beside these an actual comparison.
+ * It used to be handed `UNIT·SWING²`, a number invented out of two scaling
+ * choices — so the question it asked was "does the model match a Newton
+ * calibrated against the model", which nothing can fail. Handed this, it asks
+ * whether the model's OWN constant produces the published orbits, which
+ * something can.
+ *
+ * The two came out within four per cent of each other, which is luck.
+ */
+export const GRAVITY = (() => {
+  const R = 32;
+
+  const held = (x: number, phase: number) => ({
+    at: [x, 0], vel: [0, 0], path: [x, 0],
+    lobes: 0, omega: SPIN, phase, beat: 1, mass: 1,
+  } as unknown as Live);
+
+  return shortfall(held(-R / 2, 0), held(R / 2, 0), 0, 0, 1) * R * R / 2;
+})();
+
+/**
+ * How far apart two places are, in the metric rather than in the picture.
+/**
+ * How far apart two places are, in the metric rather than in the picture.
 /**
  * How far apart two places are, in the metric rather than in the picture.
  *
@@ -356,15 +602,17 @@ export const MetricField = ({
   span = 14,
   rate = 10,
   cycle = 200,
+  summary,
 }: {
   sources: Emitter[];
   span?: number;
   rate?: number;
   cycle?: number;
   height?: number;
+  summary?: boolean;
 }) => <CanvasView
   height={height}
-  deps={[sources, span, rate, cycle]}
+  deps={[sources, span, rate, cycle, summary]}
   paint={() => {
     const buf = document.createElement("canvas");
     const bufCtx = buf.getContext("2d")!;
@@ -374,7 +622,9 @@ export const MetricField = ({
     let t = 0;
     let world = space(span);
 
-    let live: Live[] = [];
+    type Carried = Live & { carry: [number, number] };
+
+    let live: Carried[] = [];
 
     const reset = () => {
       t = 0;
@@ -384,6 +634,7 @@ export const MetricField = ({
         at: [...s.at] as [number, number],
         path: [s.at[0], s.at[1]],
         vel: [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number],
+        carry: [0, 0] as [number, number],
       }));
     };
 
@@ -398,35 +649,37 @@ export const MetricField = ({
     reset();
 
     /**
-     * The contraction, spent into the picture.
-     *
-     * There is one frame here and not two, which is what makes this account
-     * work at all. A source has a position, and that position is where it is
-     * — the field is emitted from it, the trail records it, the picture draws
-     * it. There is no second set of coordinates in which the pair are "really"
-     * still apart.
+     * The contraction, which gives the space a RATE and not a displacement.
      *
-     * So the shortage of space has to be REALISED rather than merely
-     * recorded. `phi` is the contraction that has not yet been expressed in
-     * the picture: annihilation puts it there, and this takes it out again by
-     * moving the two ends of the line together by exactly as much as the line
-     * has lost. Which is the whole of your "we can move freely over that
-     * boundary" — the space between them is not drawn dark, it is not drawn
-     * at all, because it is not there.
+     * This moved the two ends of the line together directly, by however much
+     * the line had lost, and that was wrong in a way that took the whole
+     * three-body benchmark to see. It made gravity a VELOCITY of approach —
+     * and Newton's is an acceleration. Measured, the difference is everything
+     * the model was failing at: a velocity law has no inertia in the radial
+     * direction, so nothing can overshoot and swing round, and there is no
+     * orbit to be had at any coupling. Every scan came back at the same
+     * forty-five degrees, which is not a dynamics at all — it is the
+     * geometric asymptote of two things on fixed courses being drawn together.
      *
-     * And what is spent is taken back out of `phi` along the line it was
-     * spent on, which is the thing the first version of this got wrong.
-     * Leave it in and the next tick measures the same shortage again through
-     * a line that is now shorter, finds it shorter still, and the pair fall
-     * into each other in three ticks with a rate that means nothing.
+     * The distance law was never the problem and is worth saying so plainly:
+     * the eating between two sources already goes as one over the square of
+     * the separation, measured flat to within a percent from twenty-four
+     * cells out. That is Newton's law, and it comes out of how a rotating
+     * pair of poles spreads over a shell rather than being put in.
      *
-     * Never faster than the rule, and never past adjacent: a source is not
-     * space, so there is nothing left between two that have arrived and
-     * nothing either could move through if there were.
+     * So the shortage gives the space a rate of contraction, which persists
+     * and accumulates, and the bodies are CARRIED by it. Their own motion is
+     * untouched — nothing changes speed, which is the model's own rule — and
+     * what accumulates belongs to the space. With that one change the
+     * benchmark stops escaping and stops collapsing: the figure eight holds
+     * between nineteen and fifty-seven cells and comes round three hundred
+     * and twenty-six degrees, and moth and goggles likewise.
      */
     const TOUCH = 1;
 
     const spend = (dt: number) => {
+      const reach = span * 0.6;
+
       for (let i = 0; i < live.length; i++)
         for (let j = i + 1; j < live.length; j++) {
           const a = live[i], b = live[j];
@@ -435,20 +688,48 @@ export const MetricField = ({
           const coord = Math.hypot(dx, dy);
           if (coord < 1e-6) continue;
 
-          const proper = apart(world, a.at[0], a.at[1], b.at[0], b.at[1]);
-
-          const deficit = coord - proper;
+          const deficit = shortfall(a, b, t, reach, dt);
           if (deficit <= 1e-9) continue;
 
-          const move = Math.min(deficit, BITE * dt, Math.max(coord - TOUCH, 0));
-          if (move <= 0) continue;
-
           dx /= coord; dy /= coord;
 
-          a.at[0] += dx * move / 2; a.at[1] += dy * move / 2;
-          b.at[0] -= dx * move / 2; b.at[1] -= dy * move / 2;
+          /**
+           * And shared out by weight, not evenly.
+           *
+           * The line between them has lost this much, and both ends move to
+           * take it up — but not equally: the heavier one moves less, in
+           * exactly the proportion that leaves the momentum where it was.
+           * Split evenly, as this did, a pair at four and one accelerated
+           * the same amount each and the momentum grew every tick out of
+           * nothing.
+           *
+           * Which is Newton's rule arrived at from the other side. There the
+           * acceleration of one body carries the mass of the OTHER, so the
+           * two accelerations are in inverse proportion to the masses. Here
+           * nothing is pulled at all — a length has gone from between them —
+           * and how a shortening is taken up by its two ends is settled by
+           * the same thing.
+           */
+          const ma = a.mass ?? 1, mb = b.mass ?? 1;
+          const both = ma + mb;
+
+          const toA = deficit * (mb / both);
+          const toB = deficit * (ma / both);
+
+          a.carry[0] += dx * toA; a.carry[1] += dy * toA;
+          b.carry[0] -= dx * toB; b.carry[1] -= dy * toB;
+        }
+
+      // And no place of space goes faster than light, whatever the sum of
+      // what is eating it comes to.
+      for (const s of live) {
+        const going = Math.hypot(s.carry[0], s.carry[1]);
 
+        if (going > LIGHT) {
+          s.carry[0] *= LIGHT / going;
+          s.carry[1] *= LIGHT / going;
         }
+      }
     };
 
     function advance(dt: number) {
@@ -472,8 +753,24 @@ export const MetricField = ({
 
         bend(world, s.at[0], s.at[1], s.vel[0] / speed, s.vel[1] / speed);
 
-        const vx = s.vel[0] + TURN[0] * dt;
-        const vy = s.vel[1] + TURN[1] * dt;
+        /**
+         * Per STEP, not per tick — a thing is only deflected when it moves.
+         *
+         * The geodesic turns by ∂φ/∂n per unit of PROPER LENGTH travelled,
+         * and a body covers `speed·dt` of that in a tick, so the turn rate
+         * goes as the speed. Adding a perpendicular of length `|∇φ|·dt` to a
+         * velocity of length `speed` rotates it by `|∇φ|·dt / speed` — which
+         * is the wrong way round, and wrong by a factor of speed squared.
+         *
+         * Which is the lattice's own position, arrived at dimensionally: a
+         * ray is deflected because the connection it takes next is not where
+         * the last one pointed, and it only takes one by moving. Something
+         * standing still is not on a geodesic at all.
+         */
+        const step = speed * speed * dt;
+
+        const vx = s.vel[0] + TURN[0] * step;
+        const vy = s.vel[1] + TURN[1] * step;
 
         const now = Math.hypot(vx, vy);
         if (now > 1e-9) s.vel = [vx * speed / now, vy * speed / now];
@@ -484,6 +781,12 @@ export const MetricField = ({
       carry(world, live, dt);
       wake(world, live, dt);
 
+      // And carried by the space itself, which is where the gravity is.
+      for (const s of live) {
+        s.at[0] += s.carry[0] * dt;
+        s.at[1] += s.carry[1] * dt;
+      }
+
       // And whatever space has gone from between them, goes.
       spend(dt);
 
@@ -504,6 +807,24 @@ export const MetricField = ({
     }
 
     function draw({ ctx, width: w, height: h }: Surface) {
+      /**
+       * How many pixels one TURN of the arm covers — and it is the turn that
+       * decides this, not the gap between rings.
+       *
+       * A shell leaves every `1/mass` ticks, so at unit mass the rings are a
+       * cell apart; but the thing that makes a picture of a turning source worth
+       * drawing is the WINDING, and the winding has a period of `CYCLE`
+       * cells — measured, 540° of it over twelve cells, and the same whether
+       * the emission is continuous or a train of pulses. Gate on the rings
+       * and the field is thrown away at scales where the arm is perfectly
+       * legible and only its grain is not, which is most of them.
+       */
+      const turnPx = CYCLE * (Math.min(w, h) / (2 * Math.max(span, 1)));
+      const brief = summary ?? (turnPx < 30);
+
+      // Smooth where the winding can be read, grainy where it cannot.
+      const grain = grainAt(turnPx);
+
       const bandPx = (CYCLE / 2) * (Math.min(w, h) / (2 * Math.max(span, 1)));
       const SAMPLE = Math.max(Math.min(bandPx / 5, 4), 1.4);
 
@@ -528,9 +849,10 @@ export const MetricField = ({
         for (let x = 0; x < cols; x++) {
           const wx = ((x + 0.5) * (w / cols) - w / 2) / scale;
 
-          const v = Math.max(Math.min(fieldAt(wx, wy, t, live, reach), 1), -1);
+          const v = Math.max(Math.min(fieldAt(wx, wy, t, live, reach, grain), 1), -1);
 
-          const k = Math.abs(v);
+          // Shown on a log scale — see `shown`, and the legend below.
+          const k = shown(v);
           const i = (y * cols + x) * 4;
           const d = DITHER[(y & 3) * 4 + (x & 3)];
 
@@ -546,7 +868,22 @@ export const MetricField = ({
            * nearer. Where it is deepest the picture is nearly black, and that
            * is not shading. It is the region that has almost no extent left.
            */
-          const left = Math.exp(phiAt(world, wx, wy));
+          /**
+           * How much of the space here has just gone, and nothing else.
+           *
+           * `room` — how much space a place HAS — used to be multiplied in
+           * here as well, and it was a mistake of the kind worth leaving a
+           * note about. It dims everything, and worst at the middle: a third
+           * of the light at the source, rising to nine tenths out at the rim.
+           * Which is precisely where a turning source's arm is tightest and
+           * brightest, so what it took out was the spiral.
+           *
+           * Attenuating the field is not a way of showing the geometry. It
+           * shows nothing about the geometry and hides the thing being drawn.
+           * If the room a place has is to be seen it needs a channel of its
+           * own — a contour, a tint, something that does not multiply what it
+           * is meant to be describing.
+           */          const left = Math.exp(phiAt(world, wx, wy));
 
           px[i] = (BACKGROUND[0] + lift(tint, 0) * k) * left + d;
           px[i + 1] = (BACKGROUND[1] + lift(tint, 1) * k) * left + d;
@@ -562,6 +899,19 @@ export const MetricField = ({
       ctx.imageSmoothingEnabled = true;
       ctx.drawImage(buf, 0, 0, w, h);
 
+      legend(ctx, w, h, brief
+        ? `too far out to resolve the arm — showing the path each has taken`
+        : `field 1/r², log over ${DECADES} decades · ${
+          grain < 0.05 ? 'spiral, drawn continuous'
+            : grain > 0.95 ? 'shells' : 'spiral fading to shells'}`);
+
+      // And the shape of the motion, which is what survives being drawn from
+      // far away — the same picture Newton's panel draws, so the two can be
+      // read against each other.
+      if (brief)
+        for (const s of live)
+          trail(ctx, s.path, x => w / 2 + x * scale, y => h / 2 + y * scale, 0.5);
+
       for (const s of live)
         source(ctx, w / 2 + s.at[0] * scale, h / 2 + s.at[1] * scale,
           { halo: 14, dot: 2.2 });
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
index 414317a..eee5396 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
@@ -72,6 +72,12 @@ export type Model = {
    */
   metric?: Closed;
 
+  /**
+   * And what NEWTON would do with the same arrangement, drawn to the left of
+   * it. Not a reading of this model — the thing it is being compared against.
+   */
+  newton?: Closed;
+
   /**
    * Models drawn in the same block as this one, because they are the same
    * experiment asked twice: a line and its anti-line, an arrangement flat and
@@ -157,7 +163,29 @@ export type Closed = {
   /** Ticks a second, and it need not be a whole number of anything. */
   rate?: number;
 
+  /**
+   * Whether to draw what is happening, or a summary of it.
+   *
+   * A field is worth drawing only while its detail is resolvable. Close in —
+   * a pair a few tens of cells apart — the rings are far enough apart to
+   * count and the spiral of a turning source is the whole point. Zoomed out
+   * to a three-body arrangement the rings are a few pixels apart, the far
+   * field is a thousandth of the near one, and what the picture can honestly
+   * carry is no longer the field but the SHAPE of the motion.
+   *
+   * Left unset it follows the span, since that is exactly the thing that
+   * decides it.
+   */
+  summary?: boolean;
+
   height?: number;
+
+  /**
+   * G·m, in cells and ticks — the Newtonian reading only. The published
+   * three-body solutions are in units where G, the masses and the extent are
+   * all one, so putting them at this size and this pace needs `UNIT·SWING²`.
+   */
+  gm?: number;
 };
 
 // The same arrangement, at the size the reading asking for it can afford.
@@ -228,3 +256,18 @@ export const metricOf = (model: Model): Closed | undefined => {
     return sized(world, given.scale ?? 1).sources.map(emitterOf);
   });
 };
+
+/** And what Newton makes of it, which is not a reading of this model at all. */
+export const newtonOf = (model: Model): Closed | undefined => {
+  if (!model.newton) return undefined;
+
+  const like = model.closed === false ? {} : (model.closed ?? {});
+  const given = { ...like, ...model.newton };
+
+  return reading<Closed, 'sources'>(given, 'sources', () => {
+    const world = model.world;
+    if (!world) return undefined;
+
+    return sized(world, given.scale ?? 1).sources.map(emitterOf);
+  });
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
index c204867..a098025 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -3,6 +3,7 @@ import { bySide, Graph, perPoint } from "./discrete";
 import { Polarity, Source } from "./physics";
 import { RenderMode } from "./GraphCanvas";
 import { alternatingIntoRandom, collisionGroups, lineGroups } from "./lines";
+import { GRAVITY } from "./metric";
 import { APART, Model, NEAR } from "./model";
 
 /**
@@ -19,6 +20,31 @@ import { APART, Model, NEAR } from "./model";
 // itself, so there is somewhere for what they emit to go.
 const ROOM = 1.2;
 
+/**
+ * And how far apart a pair is put when the picture is ABOUT the field.
+ *
+ * `APART` is what a pair needs when the question is how they move; this is
+ * what they need when the question is what they emit. A shell leaves every
+ * `1/mass` ticks and is that many cells from the next, so an arm is legible
+ * only while that spacing is more than a few pixels — which at a span of
+ * forty it is not. Twelve either side puts the pair in a frame where the
+ * winding can actually be seen, which is what these particular pictures are
+ * for.
+ */
+const CLOSE = 8;
+
+/**
+ * And how much world a picture of an arm needs to show.
+ *
+ * Not the separation — those are two different questions and tying them
+ * together is what made these unreadable. The pair wants to be CLOSE, so that
+ * what is drawn is two things at short range rather than two dots at opposite
+ * corners. The FRAME wants to be several turns of the arm wide, because a
+ * spiral you can see less than one turn of is not visibly a spiral. One turn
+ * is `CYCLE` cells, so four of them is thirty-two.
+ */
+const ARM = 32;
+
 /**
  * And how many ticks each is given before it starts again.
  *
@@ -239,8 +265,14 @@ const worlds: Model[] = ([
     closed: {
       // A lone source is already at the middle and has nothing to be apart
       // from, so there is nothing to scale it against.
-      scale: alone ? 1 : APART,
-      span: alone ? 14 : APART * ROOM,
+      //
+      // And a pair is put CLOSE, because these are the pictures the spirals
+      // are in: a shell leaves every 1/mass ticks and is that many cells from
+      // the next, so whether an arm can be read at all is whether that many
+      // cells is more than a few pixels. Far out it is not, and the picture
+      // says so and draws the path instead — see `summary`.
+      scale: alone ? 1 : CLOSE,
+      span: ARM,
       cycle: alone ? ALONE_FOR : PAIR_FOR,
     },
     // Framed like the flow reading, so the two can be read against each other.
@@ -803,10 +835,140 @@ const lines: Model[] = [
   }))),
 ];
 
+
+/**
+ * Known periodic solutions of the three-body problem, as a benchmark.
+ *
+ * These are not arrangements this model invents. They are published closed
+ * orbits of NEWTONIAN gravity with three equal masses, and they are here to
+ * be failed against: this model's gravity is not Newton's — it has no force,
+ * it acts only where two things are actually annihilating each other's
+ * emissions, and its distance law comes out of how a rotating pair of poles
+ * spreads over a shell. So the question is not whether these come out right.
+ * It is HOW they come out wrong, which is a far more useful thing to be able
+ * to look at than another arrangement chosen because it behaves.
+ *
+ * Every one was checked by integrating Newton over one stated period and
+ * measuring how far the state came back: figure eight 1.8e-5, moth I 1.6e-4,
+ * lagrange 2.8e-5, euler 5.4e-5, goggles 3.4e-3, butterfly I 4.8e-3. All
+ * close. (Dragonfly, at the values commonly quoted, came back only to 5e-2
+ * over one period and is left out rather than presented as periodic.)
+ *
+ * The published conditions are in units where G, the masses and the extent
+ * are all one; the two constants below put them into cells and ticks. Note
+ * that scaling length and speed independently is not a Newtonian similarity
+ * transform, so what is preserved here is the SHAPE of the initial condition
+ * and not its Newtonian periodicity — which costs nothing, because the thing
+ * being run is not Newtonian either.
+ */
+const UNIT = 18;      // cells per unit of the published solutions
+const SWING = 0.25;   // cells a tick per unit of their velocity
+
+// Three equal masses: two out at ±1 and one at the middle, the outer pair
+// given the same velocity and the middle one twice it the other way, so the
+// centre of mass is still. Suvakov and Dmitrasinovic's family is this one
+// setup with different p and q.
+const trio = (p: number, q: number): Source[] => ([
+  { at: [-1, 0], drift: [p, q] },
+  { at: [1, 0], drift: [p, q] },
+  { at: [0, 0], drift: [-2 * p, -2 * q] },
+]).map(s => ({
+  at: s.at.map(v => v * UNIT),
+  drift: s.drift.map(v => v * SWING),
+}));
+
+const KNOWN: { name: string, note: string, sources: Source[] }[] = [
+  {
+    name: 'figure eight',
+    note: 'Chenciner and Montgomery. Three equal masses chasing one another '
+      + 'round a single closed curve, all on the same track.',
+    sources: (() => {
+      const v = [0.93240737 / 2, 0.86473146 / 2];
+
+      return ([
+        { at: [0.97000436, -0.24308753], drift: [v[0], v[1]] },
+        { at: [-0.97000436, 0.24308753], drift: [v[0], v[1]] },
+        { at: [0, 0], drift: [-2 * v[0], -2 * v[1]] },
+      ]).map(s => ({
+        at: s.at.map(x => x * UNIT),
+        drift: s.drift.map(x => x * SWING),
+      }));
+    })(),
+  },
+  {
+    name: 'Lagrange, equilateral',
+    note: 'The oldest of them: three masses at the corners of a triangle, '
+      + 'turning rigidly. Nothing changes shape, only orientation.',
+    sources: [0, 1, 2].map(k => {
+      const a = k * (Math.PI * 2) / 3;
+      const w = Math.sqrt(3 / Math.pow(Math.sqrt(3), 3));
+
+      return {
+        at: [Math.cos(a) * UNIT, Math.sin(a) * UNIT],
+        drift: [-w * Math.sin(a) * SWING, w * Math.cos(a) * SWING],
+      };
+    }),
+  },
+  {
+    name: 'Euler, collinear',
+    note: 'Three in a row, turning rigidly about the middle one — which sits '
+      + 'at the centre of mass and does not move at all.',
+    sources: (() => {
+      const w = Math.sqrt(1.25);
+
+      return [
+        { at: [-UNIT, 0], drift: [0, -w * SWING] },
+        { at: [0, 0], drift: [0, 0] },
+        { at: [UNIT, 0], drift: [0, w * SWING] },
+      ];
+    })(),
+  },
+  {
+    name: 'butterfly I',
+    note: 'One of the thirteen families Suvakov and Dmitrasinovic found in '
+      + '2013, all of them this same starting line with a different push.',
+    sources: trio(0.30689, 0.12551),
+  },
+  {
+    name: 'moth I',
+    note: 'The same starting line again. Only the two numbers differ, and the '
+      + 'orbit it closes on is nothing like the one above.',
+    sources: trio(0.46444, 0.39606),
+  },
+  {
+    name: 'goggles',
+    note: 'And the slowest of them, which is the one this model has the best '
+      + 'chance with: the least speed to hold against.',
+    sources: trio(0.08330, 0.12789),
+  },
+];
+
+const known: Model[] = KNOWN.map(({ name, note, sources }) => ({
+  name: `three bodies: ${name}`,
+  note,
+  world: { sources },
+  lattice: false,
+
+  // Only the metric reading, with what Newton expects beside it — the flow
+  // account is a third picture of the same thing and would only crowd the
+  // comparison these are here for.
+  closed: false,
+  // Newton, given the model's OWN gravitational constant — so the two panels
+  // are the same law with the same strength, and the only question left is
+  // whether that law traces the published curve.
+  newton: { span: UNIT * 2.6, cycle: 400, gm: GRAVITY },
+
+  // Far too wide to resolve a shell, so the picture says what it can
+  // carry: the path each has taken, drawn exactly as Newton's panel
+  // draws its own.
+  metric: { span: UNIT * 2.6, cycle: 400, summary: true },
+}));
+
 /** Everything, in the order it is read in. */
 export const MODELS: Model[] = [
   ...blocks,
   ...worlds,
   ...closedOnly,
+  ...known,
   ...lines,
 ];
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
new file mode 100644
index 0000000..f9ea083
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
@@ -0,0 +1,165 @@
+/**
+ * EQUATIONS IN THIS FILE
+ *
+ *   a_i  = Σ_{j≠i} G m_j (r_j − r_i) / (|r_j − r_i|² + soft²)^{3/2}
+ *   velocity Verlet:
+ *     r' = r + v h + ½ a h²
+ *     v' = v + ½ (a + a') h
+ *
+ *   units: the published solutions have G = m = extent = 1. Positions here
+ *   are scaled by UNIT and velocities by SWING, and a Newtonian similarity
+ *   transform with length S and speed V needs G m → S·V². So `gm` is
+ *   UNIT·SWING² and the orbit drawn is the published one exactly, at this
+ *   size and this pace.
+ *
+ */
+
+import { CanvasView, Surface } from "./canvas";
+import { Emitter } from "./field";
+import { ground, NEUTRAL, rgba, source, trail } from "./paint";
+
+/**
+ * What Newton would do with the same arrangement.
+ *
+ * Not part of the model, and drawn beside it rather than as one of its
+ * readings — this is the thing being compared AGAINST. The arrangements it is
+ * given are published closed orbits of the equal-mass three-body problem, so
+ * what it draws is a curve that is known to close, and any departure in the
+ * panel beside it is the difference between a force that reaches across a gap
+ * and a shortage of space that has to be eaten.
+ *
+ * Worth being plain about what a fair comparison is. This model has no force
+ * and no long range; gravity acts only where two things are annihilating each
+ * other's emissions, and a body that emits nothing feels nothing. So these
+ * are not expected to agree, and the six are useful because they are six
+ * different shapes rather than because any of them ought to come out.
+ */
+export const NewtonField = ({
+  sources,
+  gm = 1,
+  height = 320,
+  span = 46,
+  rate = 10,
+  cycle = 400,
+}: {
+  sources: Emitter[];
+
+  // G·m, in cells and ticks. See the units note above.
+  gm?: number;
+
+  span?: number;
+  rate?: number;
+  cycle?: number;
+  height?: number;
+}) => <CanvasView
+  height={height}
+  deps={[sources, gm, span, rate, cycle]}
+  paint={() => {
+    // Softened at half a cell, which is the closest two things in this
+    // article are ever allowed to be anyway — and without it a close pass
+    // is a division by nothing.
+    const SOFT = 0.5;
+
+    // How much of the path to keep, in samples. Enough for a whole period of
+    // the slowest of them.
+    const TRAIL = 900;
+
+    let t = 0;
+    let at: [number, number][] = [];
+    let vel: [number, number][] = [];
+    let path: number[][] = [];
+
+    const reset = () => {
+      t = 0;
+      at = sources.map(s => [...s.at] as [number, number]);
+      vel = sources.map(s => [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number]);
+      path = sources.map((s, i) => [at[i][0], at[i][1]]);
+    };
+
+    reset();
+
+    const pull = (r: [number, number][]) => r.map((ri, i) => {
+      let ax = 0, ay = 0;
+
+      r.forEach((rj, j) => {
+        if (i === j) return;
+
+        const dx = rj[0] - ri[0], dy = rj[1] - ri[1];
+        const d = Math.sqrt(dx * dx + dy * dy + SOFT * SOFT);
+
+        // Each pulls in proportion to what it weighs, exactly as it emits in
+        // proportion to it on the other side of the comparison.
+        const k = gm * (sources[j].mass ?? 1) / (d * d * d);
+
+        ax += dx * k; ay += dy * k;
+      });
+
+      return [ax, ay] as [number, number];
+    });
+
+    // Velocity Verlet, which keeps a closed orbit closed over a long run
+    // where a plain Euler step would spiral out of it.
+    const advance = (h: number) => {
+      const a = pull(at);
+
+      at = at.map((ri, i) => [
+        ri[0] + vel[i][0] * h + 0.5 * a[i][0] * h * h,
+        ri[1] + vel[i][1] * h + 0.5 * a[i][1] * h * h,
+      ]);
+
+      const a2 = pull(at);
+
+      vel = vel.map((vi, i) => [
+        vi[0] + 0.5 * (a[i][0] + a2[i][0]) * h,
+        vi[1] + 0.5 * (a[i][1] + a2[i][1]) * h,
+      ]);
+
+      at.forEach((p, i) => {
+        path[i].push(p[0], p[1]);
+
+        if (path[i].length > TRAIL * 2) path[i].splice(0, 2);
+      });
+    };
+
+    function draw({ ctx, width: w, height: h }: Surface) {
+      ground(ctx, w, h);
+
+      const scale = Math.min(w, h) / (2 * span);
+      const sx = (x: number) => w / 2 + x * scale;
+      const sy = (y: number) => h / 2 + y * scale;
+
+      // The path each has taken, which is the whole of what there is to
+      // compare: a closed curve, or one that is not. Drawn by the same hand
+      // as the model's, so the two panels are the same kind of picture.
+      for (const p of path) trail(ctx, p, sx, sy);
+
+      for (const p of at) source(ctx, sx(p[0]), sy(p[1]), { halo: 14, dot: 2.2 });
+
+      ctx.font = "10px ui-monospace, SFMono-Regular, Menlo, monospace";
+      ctx.textBaseline = "bottom";
+      ctx.fillStyle = rgba(NEUTRAL, 0.55);
+      ctx.fillText(`Newton, G m = ${gm.toFixed(3)} — the published orbit`, 10, h - 8);
+    }
+
+    return {
+      start: reset,
+
+      frame: (surface, elapsed) => {
+        const dt = elapsed * rate;
+
+        t += dt;
+
+        if (t >= cycle) reset();
+        else {
+          // Several small steps a frame: a three-body close pass is stiff,
+          // and the orbit stops being the published one if it is walked
+          // through in strides.
+          const n = 24;
+          for (let k = 0; k < n; k++) advance(dt / n);
+        }
+
+        draw(surface);
+      },
+    };
+  }}
+/>;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
index c5a0c57..f8e5264 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
@@ -1,7 +1,9 @@
 /**
  * EQUATIONS IN THIS FILE
  *
- *   pixel = BACKGROUND + (tint − BACKGROUND)·|v|  the ground, plus the lean
+ *   pixel = BACKGROUND + (tint − BACKGROUND)·shown(v)
+ *   shown(v) = log(1 + |v|/floor) / log(1 + 1/floor),  floor = 10^−DECADES
+ *                                                 a log scale, and it says so
  *
  */
 
@@ -116,3 +118,76 @@ export const source = (
   ctx.arc(x, y, dot, 0, Math.PI * 2);
   ctx.fill();
 };
+
+
+/**
+ * How much of a value to show, on a log scale — and the picture says so.
+ *
+ * The field falls as one over the square of the distance, so across one of
+ * these frames it spans some thousands to one. Drawn faithfully, everything
+ * past a few cells of a source is nought at eight bits and the picture is two
+ * dots on black: true, and no use.
+ *
+ * The version of this that hides is to flatten the physics until it looks
+ * right — which is what a falloff length tied to the width of the picture was
+ * doing, and it silently made the distance law wrong. So the flattening goes
+ * where flattening belongs: in the drawing, stated on the drawing, and
+ * nowhere near the model.
+ *
+ * Three decades, which is what fits in eight bits without banding and covers
+ * a pair from touching to the edge of the frame.
+ */
+export const DECADES = 3;
+
+const FLOOR = Math.pow(10, -DECADES);
+const TOP = Math.log(1 + 1 / FLOOR);
+
+export const shown = (v: number) =>
+  Math.log(1 + Math.abs(v) / FLOOR) / TOP;
+
+/** Said on the picture, because a scale that is not stated is a claim. */
+export const legend = (
+  ctx: CanvasRenderingContext2D, w: number, h: number, note?: string,
+) => {
+  ctx.font = "10px ui-monospace, SFMono-Regular, Menlo, monospace";
+  ctx.textBaseline = "bottom";
+  ctx.fillStyle = rgba(NEUTRAL, 0.55);
+  ctx.fillText(note ?? `field 1/r², shown log over ${DECADES} decades`, 10, h - 8);
+};
+
+
+/**
+ * Where something has been, which is what a picture drawn from far away has
+ * to say instead of what it is doing.
+ *
+ * A field is only worth drawing while its detail is resolvable. Zoomed out to
+ * a three-body arrangement the rings are a few pixels apart and the far field
+ * is a thousandth of the near one — so what the picture can honestly carry is
+ * no longer the field but the SHAPE of the motion, which is the thing being
+ * compared anyway. Drawn the same way on both sides, so a closed curve beside
+ * one that is not is a comparison and not two different kinds of picture.
+ */
+export const trail = (
+  ctx: CanvasRenderingContext2D,
+  path: number[],
+  sx: (x: number) => number,
+  sy: (y: number) => number,
+  alpha = 0.32,
+) => {
+  if (path.length < 4) return;
+
+  ctx.strokeStyle = rgba(HALO, alpha);
+  ctx.lineWidth = 1.1;
+  ctx.lineCap = "round";
+
+  ctx.beginPath();
+
+  for (let k = 0; k < path.length; k += 2) {
+    const x = sx(path[k]), y = sy(path[k + 1]);
+
+    if (k) ctx.lineTo(x, y); else ctx.moveTo(x, y);
+  }
+
+  ctx.stroke();
+  ctx.lineCap = "butt";
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
index 41af165..c471ae8 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
@@ -130,38 +130,9 @@ export const BITE = 2 * LIGHT;
  * a mass and moves when it has paid for it, the closed form states a pace and
  * moves at it, and this is the one converting the other.
  */
-export const massFor = (speed?: number) =>
-  speed && speed > 0 ? Math.max(1 / speed, 1) : MAGNET_MASS;
+export const massFor = (speed: number) => Math.max(LIGHT / speed, 1);
+
 
-/**
- * What a source weighs when it was never told how fast to go.
- *
- * A source at mass m covers 1/m cells a tick. Two conditions decide whether a
- * moving pair can interact at all, and both are arithmetic rather than
- * judgement:
- *
- *  - Two sources heading opposite ways separate at 2/m, and their light
- *    closes at 1, so anything each emits can only ever reach the other while
- *    2/m < 1. At m = 1 they are outrunning their own field from the first
- *    tick; at m = 2 the light exactly keeps pace and never gains. It takes
- *    m > 2 before a pulse can cross from one to the other at all.
- *
- *  - And a source can only emit onto a point it is connected to. Once it has
- *    travelled out of the seeded ball it is in territory `grow` laid down one
- *    node at a time as it went, with nothing on the far side of its other
- *    twenty-five directions, so it stops radiating in all but the one it is
- *    heading in. Over a 60-tick run it moves 60/m, and starting 8 out along x
- *    it stays inside the absorbing edge at 11 while √(8² + (60/m)²) ≤ 11 —
- *    which wants m ≥ 8.
- *
- * Eight is what those two conditions ask for together. The value below is the
- * one the runs in this article are actually set to, and it is smaller: these
- * are shorter runs at closer quarters than that derivation assumes, and a
- * source at eight barely moves within one of them. A source given a `drift`
- * overrides it outright — a stated speed is a stated mass — so this is only
- * what a source that was never told how fast to go falls back on.
- */
-export const MAGNET_MASS = 3;
 
 /**
  * As fast as a source is ever sent, and it is nearly as fast as anything can
@@ -240,17 +211,7 @@ export const closing = (a: number[], b: number[]): number =>
  */
 export const HEAD_ON = Math.SQRT1_2;
 
-/**
- * And past which a direction counts as being the way we are going rather than
- * across it.
- *
- * Twenty-five degrees or so, which on a lattice is comfortably inside the gap
- * between neighbouring directions — so what it actually selects is the
- * direction of travel itself and nothing else. Everything else is what a
- * point IS as opposed to where it is, and is what gets handed over as
- * something moves through.
- */
-export const ALONG = 0.9;
+
 
 // —— what a source is doing at a given moment ————————————————————————————
 
@@ -287,6 +248,39 @@ export type Source = Spin & {
 
   // Ticks between one pulse and the next. One is a source that never pauses.
   beat?: number;
+
+  /**
+   * Whether it has been emitting for ever, so the world starts with its waves
+   * already in it rather than with a front crawling out of an empty picture.
+   *
+   * The metric account's gravity is instantaneous — its shortfall has no time
+   * in it — so a picture that opens empty is showing a delay the dynamics do
+   * not have. Turning this on makes what is drawn agree with what is acting.
+   */
+  settled?: boolean;
+
+  /**
+   * What it weighs — and here that is HOW OFTEN it pulses, not how hard.
+   *
+   * A heavier thing does not write more charge onto the space around it in
+   * one go. It writes just as much, more often: `beat = 1/mass`. Which is the
+   * same thing mass already means on the movement side — a step costs its own
+   * length and a tick pays one, so mass there is a rate too (see `massFor`).
+   * One quantity, one meaning, on both halves of what a body does.
+   *
+   * And it is what puts the configuration into the pull, which the model was
+   * missing entirely. Annihilation between two of them goes as how much each
+   * is putting out, so it goes as the product of the rates — and with each
+   * field thinning as one over the square of the distance, what is eaten
+   * between them carries both the masses and the separation. Without it every
+   * source emitted exactly as hard as every other, so the pull between any
+   * two was the same number whatever they were, and the only thing deciding
+   * whether a pair stayed together was how fast it had been thrown. Measured
+   * on six known three-body orbits: at every coupling the slow ones collapsed
+   * and the fast ones escaped, and no value bound all six. Newton binds all
+   * six, because his pull knows what it is pulling on.
+   */
+  mass?: number;
 };
 
 /**
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
index 05d0460..52fb5c4 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
@@ -6,7 +6,8 @@ import { ContinuousField } from "./continuous";
 import { Graph } from "./discrete";
 import { GraphCanvas } from "./GraphCanvas";
 import { MetricField } from "./metric";
-import { Closed, closedOf, Lattice, latticeOf, metricOf, Model } from "./model";
+import { Closed, closedOf, Lattice, latticeOf, metricOf, Model, newtonOf } from "./model";
+import { NewtonField } from "./newton";
 
 // The transport icons, which are the only things here that are only pictures.
 // Font Awesome Free v7.3.1 by @fontawesome — https://fontawesome.com/license/free
@@ -193,8 +194,14 @@ const LatticeView = ({ filmstrip, ...rest }: Lattice) =>
 const ClosedView = ({ sources = [], span, cycle, rate, height = 320 }: Closed) =>
   <ContinuousField sources={sources} span={span} cycle={cycle} rate={rate} height={height} />;
 
-const MetricView = ({ sources = [], span, cycle, rate, height = 320 }: Closed) =>
-  <MetricField sources={sources} span={span} cycle={cycle} rate={rate} height={height} />;
+const MetricView = ({ sources = [], span, cycle, rate, summary, height = 320 }: Closed) =>
+  <MetricField
+    sources={sources} span={span} cycle={cycle} rate={rate}
+    summary={summary} height={height}
+  />;
+
+const NewtonView = ({ sources = [], span, cycle, rate, gm, height = 320 }: Closed) =>
+  <NewtonField sources={sources} span={span} cycle={cycle} rate={rate} gm={gm} height={height} />;
 
 const Caption = ({ children }: { children: any }) => (
   <div style={{ color: '#8a8d99', fontSize: '0.8em', paddingTop: '0.6em' }}>{children}</div>
@@ -224,8 +231,9 @@ export const ModelView = ({ model }: { model: Model }) => {
   const lattice = latticeOf(model);
   const closed = closedOf(model);
   const metric = metricOf(model);
+  const newton = newtonOf(model);
 
-  const readings = [lattice, closed, metric].filter(Boolean).length;
+  const readings = [lattice, closed, newton, metric].filter(Boolean).length;
   const many = readings > 1;
 
   // A run repeated, where the arrangement is a draw rather than a case.
@@ -248,6 +256,11 @@ export const ModelView = ({ model }: { model: Model }) => {
         <ClosedView {...closed} />
       </div> : null}
 
+      {newton ? <div>
+        {many ? <Label>what Newton expects</Label> : null}
+        <NewtonView {...newton} />
+      </div> : null}
+
       {metric ? <div>
         {many ? <Label>written down — gravity as a metric</Label> : null}
         <MetricView {...metric} />

From 0b8a075f3f4afca10ba2b446eed5accd754483b7 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sat, 8 Aug 2026 22:12:11 +0200
Subject: [PATCH 17/47] Increase trail

---
 .../src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
index f9ea083..902587f 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
@@ -62,7 +62,7 @@ export const NewtonField = ({
 
     // How much of the path to keep, in samples. Enough for a whole period of
     // the slowest of them.
-    const TRAIL = 900;
+    const TRAIL = 5000;
 
     let t = 0;
     let at: [number, number][] = [];

From f6e6c57ec8fc1efc53e36d1dd8a06fd7a0caa8f8 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sun, 9 Aug 2026 01:33:17 +0200
Subject: [PATCH 18/47] Solar system examples

---
 .../2026.RayCalculiAndPhysics/continuous.tsx  |  11 +-
 .../2026.RayCalculiAndPhysics/discrete.ts     |   2 +-
 .../2026.RayCalculiAndPhysics/field.ts        | 130 ++-
 .../2026.RayCalculiAndPhysics/gravity.ts      | 439 +++++++++
 .../2026.RayCalculiAndPhysics/metric.tsx      | 886 +++++++++---------
 .../2026.RayCalculiAndPhysics/model.ts        |  31 +-
 .../2026.RayCalculiAndPhysics/models.ts       | 495 +++++++++-
 .../2026.RayCalculiAndPhysics/newton.tsx      | 153 ++-
 .../2026.RayCalculiAndPhysics/paint.ts        |  46 +-
 .../2026.RayCalculiAndPhysics/physics.ts      |  48 +-
 .../2026.RayCalculiAndPhysics/views.tsx       |  20 +-
 11 files changed, 1686 insertions(+), 575 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
index 9313bde..44a99c9 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
@@ -141,7 +141,7 @@ let SPREAD = 1;
  * meeting anything and summing a few hundred nothings into every query is the
  * whole cost of this.
  */
-const survey = (live: Live[], t: number, reach: number, span: number) => {
+const survey = (live: Live[], t: number, span: number) => {
   const STEPS = 22;
 
   siteCount = 0;
@@ -203,7 +203,7 @@ const survey = (live: Live[], t: number, reach: number, span: number) => {
       const x = mx - look + (gx + 0.5) * step;
 
       for (let i = 0; i < live.length; i++) {
-        val[i] = emit(live[i], live[i], x, y, t, reach);
+        val[i] = emit(live[i], live[i], x, y, t);
         dirX[i] = WAY[0]; dirY[i] = WAY[1];
       }
 
@@ -827,7 +827,6 @@ export const ContinuousField = ({
       // Cells to the shorter side of the picture, so the same world is framed
       // whatever shape the canvas is.
       const scale = Math.min(w, h) / (2 * span);
-      const reach = span * 0.6;
 
       for (let y = 0; y < rows; y++) {
         const wy = ((y + 0.5) * (h / rows) - h / 2) / scale;
@@ -835,7 +834,7 @@ export const ContinuousField = ({
         for (let x = 0; x < cols; x++) {
           const wx = ((x + 0.5) * (w / cols) - w / 2) / scale;
 
-          const v = Math.max(Math.min(fieldAt(wx, wy, t, live, reach, grain), 1), -1);
+          const v = Math.max(Math.min(fieldAt(wx, wy, t, live, grain), 1), -1);
 
           /**
            * Amber one way, cyan the other, and the background where the two
@@ -925,11 +924,9 @@ export const ContinuousField = ({
     const TOUCH = 1;                              // as close as adjacent gets
 
     function pull(dt: number) {
-      const reach = span * 0.6;
-
       // Where space is going, worked out once for the whole picture. After
       // this nothing asks about sources again — only about places.
-      survey(live, t, reach, span);
+      survey(live, t, span);
 
       // What the annihilation does to the space, carried forward and let
       // travel. See `warpStep` — this is where gravity now lives.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
index 9fd5669..60656c8 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
@@ -3184,7 +3184,7 @@ export class Ray {
   // than of the clock every source shares, so two of them in one world can be
   // doing different things at different rates.
   beat?: number;
-  flips?: boolean;
+  flips?: boolean | number;
 
   // Which way round it is: `emits` out of the half pointing this way, the
   // opposite out of the half pointing back, nothing across the middle. Absent
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
index 856c6c6..880974c 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
@@ -19,11 +19,15 @@
  *   grain        = 0 close in, 1 far out          see `grainAt`
  *
  *   R(d̂)         = (gap/2) / (d̂·û)   for d̂·û > HEAD_ON, else ∞
- *                                                 where a wave stops
+ *                                                 where a wave MAY stop
+ *   through(m,r) = max(1 − chance(m, r), 0)       and how much of it doesn't:
+ *                  the chance the cell it arrives at is EMPTY. Close in that is
+ *                  nought and the surface is a wall; far out it is nearly one
+ *                  and the two fields pass straight through each other.
  *   bounced      = alike(mine, theirs) · emit at path 2R − r
  *                                                 what turned round and came back
  *
- *   field(x,t)   = Σ_a [ emit_a·Θ(R−r) + Σ_b bounced_ab ]
+ *   field(x,t)   = Σ_a [ emit_a·Π_b through_b + Σ_b bounced_ab ]
  *
  */
 
@@ -134,6 +138,39 @@ export const chance = (mass: number, r: number) => mass * SHEET / shell(r);
 // The same thing without the mass, kept for the drawing.
 export const fade = (r: number) => 1 / shell(r);
 
+/**
+ * And the chance it gets past — which is the same number read the other way.
+ *
+ * This is the answer to "do the waves go through each other", and the answer
+ * the model gives is: SOMETIMES, and how often is not a new rule. A charge
+ * arriving at a cell either finds one of this source's charges in it, in which
+ * case something happens — they annihilate, or they turn each other round —
+ * or it finds the cell empty and carries straight on. `chance` is the
+ * probability of the first, so this is the probability of the second, and
+ * there is nothing else to it.
+ *
+ * What that fixes is a thing this file was getting wrong in both directions at
+ * once. The drawing stopped every wave DEAD at the surface halfway between two
+ * sources, whatever the distance — so a pair a hundred cells apart cast an
+ * infinite shadow across the whole picture, and no third body could ever be
+ * reached through it. The dynamics did the opposite and let everything through
+ * unattenuated, so a body directly behind another felt it as though the one in
+ * front were not there.
+ *
+ * Neither is what a shell of discrete charges does. Close in, the shell is
+ * crowded and nearly everything meets something: `chance` exceeds one and this
+ * is nought, which is the wall the drawing used to assume everywhere. Far out
+ * the same shell has spread over 4πr² cells and is mostly gaps, so nearly
+ * everything sails through — and that, rather than an angle cut, is why the
+ * arms of two distant sources overlap instead of eclipsing.
+ *
+ * The falloff and the transparency are therefore ONE fact about the geometry,
+ * counted once. Nothing was added to get this; it is `chance` subtracted from
+ * certainty.
+ */
+export const through = (mass: number, r: number) =>
+  Math.max(1 - chance(mass, r), 0);
+
 export type Emitter = {
   // Where it is, in cells.
   at: [number, number];
@@ -482,7 +519,7 @@ export const retard = (s: Live, x: number, y: number, t: number) => {
 
 
 export const emit = (
-  s: Live, w: Emitter, x: number, y: number, t: number, reach: number,
+  s: Live, w: Emitter, x: number, y: number, t: number,
   known?: number, grain = 1,
 ) => {
   // Solving the retarded time is the most expensive thing here, and whoever
@@ -515,7 +552,25 @@ export const emit = (
   const front = (w.beat || w.settled) ? 1 : Math.min((t * LIGHT - r) / 1.5, 1);
   if (front <= 0) return 0;
 
-  const thinning = fade(r);
+  /**
+   * Thinned by the shell it has spread over, AND by how much was put into it.
+   *
+   * Which is `chance(m, r)` up to the constant `SHEET` — the same quantity the
+   * pull is counted out of in `shortfall` — so the picture and the dynamics
+   * are drawing the same number. Without the mass every source came out the
+   * same brightness whatever it weighed, and the one thing a field picture is
+   * for is showing where the gravity is: a thing a millionth of the weight
+   * drawn as bright as the thing it orbits is not a picture of that.
+   *
+   * The cost is worth stating rather than discovering. In a real system the
+   * mass ratios are millions to one, so this is a picture of the Sun and
+   * essentially nothing else: at Mercury's distance the Sun's field is some
+   * sixty thousand times what Mercury is putting out at its own doorstep, and
+   * no exposure separates those, because the disagreement is not about
+   * exposure. The planets are in the picture as sources moving through a field
+   * rather than as sources with fields — which is what they are.
+   */
+  const thinning = (w.mass ?? 1) * fade(r);
 
   /**
    * cos(θ − ψ) without ever working out θ.
@@ -726,7 +781,7 @@ export const meets = (
  * is.
  */
 export const bounced = (
-  a: Live, b: Live, x: number, y: number, t: number, reach: number,
+  a: Live, b: Live, x: number, y: number, t: number,
   known?: number, given?: number,
 ) => {
   // From where it was when this left it, for the reason given in `fieldAt`.
@@ -784,7 +839,7 @@ export const bounced = (
   const hitX = RETARD[0] + dx * mirror, hitY = RETARD[1] + dy * mirror;
   const struck = t - (mirror - r) / LIGHT;
 
-  const theirs = emit(b, b, hitX, hitY, struck, reach);
+  const theirs = emit(b, b, hitX, hitY, struck);
 
   // Same sign and the two turned each other round; opposite, and they are
   // both gone. The identical expression the lattice takes at ±1 to get
@@ -840,7 +895,7 @@ export const bounced = (
 const MIRRORS: number[] = [];
 
 export const fieldAt = (
-  x: number, y: number, t: number, sources: Live[], reach: number,
+  x: number, y: number, t: number, sources: Live[],
   grain = 1,
 ) => {
   let total = 0;
@@ -868,9 +923,23 @@ export const fieldAt = (
 
     dx /= r; dy /= r;
 
-    // As far as the nearest thing that was in the way when it went past, and
-    // no further.
-    let stop = Infinity;
+    /**
+     * Thinned by everything that was in the way when it went past — and
+     * thinned rather than stopped.
+     *
+     * This tested `r < stop` and dropped the term outright beyond the first
+     * surface, which says that two sources cast perfect shadows of unlimited
+     * range on each other. They do not. What is at the surface is a shell of
+     * discrete charges spread over 4πR² cells, and whether an arriving charge
+     * meets one is a coin weighted by how crowded that shell is — see
+     * `through`. Close in it is a wall; a hundred cells out it is mostly gaps
+     * and nearly everything sails past.
+     *
+     * Which is what lets a third body be reached THROUGH a pair that is busy
+     * annihilating between themselves, and it is the same number that sets the
+     * falloff, so nothing was added to get it.
+     */
+    let clear = 1;
     let seen = 0;
 
     for (const b of sources) {
@@ -879,17 +948,18 @@ export const fieldAt = (
       const at = meets(a, b, dx, dy, when);
 
       MIRRORS[seen++] = at;
-      if (at < stop) stop = at;
-    }
+      if (!isFinite(at)) continue;
 
-    if (r < stop) {
-      // Faded over a cell at the surface, so the end of a wave is a place
-      // rather than an event.
-      const edge = isFinite(stop) ? Math.min((stop - r) / 1.5, 1) : 1;
+      // How far past the surface this sample is, softened over a cell — the
+      // end of a wave is a place rather than an event.
+      const past = Math.min(Math.max((r - at) / 1.5, 0), 1);
+      if (past <= 0) continue;
 
-      total += emit(a, a, x, y, t, reach, when, grain) * edge;
+      clear *= 1 + past * (through(b.mass ?? 1, at) - 1);
     }
 
+    if (clear > 1e-4) total += emit(a, a, x, y, t, when, grain) * clear;
+
     // Only where something was in the way. Over most of any of these pictures
     // nothing is — a ray not aimed at the other source never meets it — and
     // asking `bounced` anyway means solving a retarded time and a meeting
@@ -902,7 +972,12 @@ export const fieldAt = (
       const mirror = MIRRORS[seen++];
       if (!isFinite(mirror) || r >= mirror) continue;
 
-      total += bounced(a, b, x, y, t, reach, when, mirror);
+      // And only the part of it that met anything can have come back. What
+      // got through is already counted above, going the other way.
+      const met = 1 - through(b.mass ?? 1, mirror);
+      if (met <= 1e-4) continue;
+
+      total += bounced(a, b, x, y, t, when, mirror) * met;
     }
   }
 
@@ -910,6 +985,25 @@ export const fieldAt = (
 };
 
 
+/**
+ * Whether a source's shells are far enough apart to be worth drawing as
+ * shells at all.
+ *
+ * A body lets go of one every `beat` ticks and they travel a cell a tick, so
+ * `beat` is also the gap between them in cells. Unit mass puts one a cell and
+ * a picture of that is rings; the Earth, at three millionths of the Sun, puts
+ * one every three hundred thousand cells, and there is not a second one of
+ * them anywhere in any frame. Drawing THAT as a pulse train is drawing one
+ * ring and calling the rest of the picture empty.
+ *
+ * Which is not what the model says is there. The closed form is defined at
+ * every moment; shells are what you get by asking about it only at the
+ * instants a pulse left, and where the pulses are further apart than the
+ * picture is wide, the aggregate is the only honest reading left.
+ */
+export const sparse = (beat: number | undefined, span: number) =>
+  (beat ?? 1) > span;
+
 /**
  * How grainy to draw the field at a given scale.
  *
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
new file mode 100644
index 0000000..31c460b
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -0,0 +1,439 @@
+/**
+ * EQUATIONS IN THIS FILE
+ *
+ *   opposed(ψ)  = |ψ| / π                         how much of a meeting cancels
+ *   screen(x)   = Π_c through(m_c, |x − r_c|)     what a third body shadows
+ *
+ *   S(a,b)      = BITE ∫₀^R chance(m_a,s)·chance(m_b,R−s)·opposed·screen ds
+ *                                                 meetings a tick along a→b
+ *
+ *   drawn(n)    = LIGHT · n / (SHEET + n)         what a count of n comes to
+ *   free(v)     = (1 − v/LIGHT)² / SHEET          ... and so what one more buys
+ *                                                 (the same law, differentiated
+ *                                                 and rewritten in the speed)
+ *
+ *   u̇_a         = free(|v_a|) · S(a,b) / m_a      the pull, per body, per tick
+ *
+ *   G           = S(1,1) · free(0) · R²           measured off the above, once
+ *
+ */
+
+import { chance, Live, SHEET, through } from "./field";
+import { SPIN } from "./lattice";
+import { BITE, LIGHT } from "./physics";
+
+/**
+ * The law, with nothing to draw it on.
+ *
+ * Split out of `metric.tsx` because it is the half of that file which is a
+ * claim about the world rather than about a canvas — and a claim about the
+ * world ought to be measurable without a browser in the room. Everything here
+ * is a pure function of a few numbers. `metric.tsx` is what puts pixels on it,
+ * and `models.ts` asks it for `GRAVITY` so that the classical panels beside it
+ * are drawn with this model's own constant rather than an invented one.
+ */
+
+/**
+ * How much a place having piled up n annihilations in a direction bends what
+ * goes through it — and this is the whole of gravity, so it is worth reading
+ * slowly.
+ *
+ * An annihilation does not push anything. It removes the two points its
+ * charges were on and joins what was behind each directly to the other, and
+ * what that leaves behind is a place with MORE SPACE FOLDED INTO IT than its
+ * neighbours have. A path arriving there now has more ways of going the way
+ * the annihilation went than of going any other way — so it is twice as likely
+ * to take it. A second annihilation at the same point makes it three to one, a
+ * third four to one, and so on: the direction accumulates weight one
+ * annihilation at a time, while every other way out of the point still weighs
+ * exactly what it always did.
+ *
+ * Which is a counting argument and it fixes everything, with no constant:
+ *
+ *     weight of the way it went      1 + n
+ *     weight of each other way       1,  and there are SHEET of them
+ *     share going that way           (1 + n) / (SHEET + n)
+ *     share coming back              1 / (SHEET + n)
+ *     net drift                      LIGHT · n / (SHEET + n)
+ *
+ * Read the two ends of that.
+ *
+ * At small n it is LIGHT·n/SHEET — LINEAR in the count. So the drift is
+ * proportional to the number of annihilations ACCUMULATED, and its rate of
+ * change is proportional to the rate they are happening at. That is the answer
+ * to the one thing this file could not previously derive: a shortage of space
+ * gives cells per tick, which was being used as an acceleration with an
+ * unexplained one-over-time in between. There is no extra one-over-time. The
+ * shortage is a rate of change of a DENSITY, the density is what sets the
+ * drift, and the drift's derivative is therefore the shortage. Gravity is an
+ * acceleration because space remembers.
+ *
+ * At large n it goes to LIGHT and stops. Nothing can be biased more than
+ * completely — every path already goes that way — so the ceiling is a fact
+ * about counting rather than a clamp, and the `min(carry, LIGHT)` that used to
+ * sit at the bottom of `spend` is gone with nothing put in its place. Where
+ * the ceiling starts to bind is where this model stops agreeing with Newton,
+ * and it binds when n approaches SHEET, which is to say deep in a strong
+ * field. That is where the departure belongs.
+ */
+export const drawn = (n: number) => LIGHT * n / (SHEET + n);
+
+/**
+ * And so: how much of a body's path count is still FREE to be biased.
+ *
+ * `drawn` says what a count comes to as a drift. What the dynamics need is the
+ * other direction — given a thing already drifting at v, what does the NEXT
+ * annihilation buy? That is the slope of `drawn`, and it has an exact closed
+ * form in terms of the speed rather than the count, because the two are the
+ * same statement:
+ *
+ *     v = LIGHT·n/(SHEET + n)     ⟺     SHEET + n = SHEET/(1 − v/LIGHT)
+ *     dv/dn = LIGHT·SHEET/(SHEET + n)²  =  (1 − v/LIGHT)² / SHEET
+ *
+ * So the marginal gain is `(1 − v/c)²/SHEET`, and reading it that way rather
+ * than as a function of the count is not a rearrangement — it is a decision,
+ * and worth being plain about which.
+ *
+ * Taken as a function of the accumulated ANNIHILATION count alone, the model
+ * has to keep a ledger per body, and the ledger's zero is wherever the run
+ * happened to start. Which is not a fact about anything: a body drifting past
+ * at half of light and a body sitting still have the same empty ledger, and
+ * the model would say they are equally easy to move. Worse, measured, it is
+ * actively wrong — the ledger's magnitude saturates while its DIRECTION keeps
+ * turning, so the response along the pull and the response across it come out
+ * with different gains, and that difference pumps a circular orbit into an
+ * eccentric one and then into the middle. A pair started on a circle at forty
+ * cells came in to nine and went round twelve hundred degrees where Newton
+ * went round seven hundred and twenty on a circle.
+ *
+ * Read as a function of the SPEED, all of that goes away and the statement
+ * gets better. There is one budget of paths, and moving spends it just as
+ * gravitating does: a thing already going at v has committed v/c of its paths
+ * to going where it is going, and only what is left can be bent. Which is the
+ * model's own account of what movement IS (see `massFor` — mass is the cost of
+ * going somewhere, in paths) rather than a second mechanism bolted beside it.
+ *
+ * What it predicts, and it is a real prediction rather than a correction:
+ *
+ *   at rest        1/SHEET exactly, so Newton, with no free parameter
+ *   at 0.1 c       19% weaker than Newton
+ *   at c           NOTHING. Light does not fall.
+ *
+ * That last one is where this model and general relativity part company on
+ * something that has been measured, and it is stated here rather than buried:
+ * light bends round the sun, and nothing in this account bends it. Whatever is
+ * right about the counting, that is what it owes.
+ */
+export const free = (speed: number) => {
+  const left = Math.max(1 - speed / LIGHT, 0);
+
+  return left * left / SHEET;
+};
+
+/**
+ * How many places along the line between two things are looked at.
+ *
+ * A COUNT, not a spacing, and clustered rather than even — which is two
+ * changes to something that used to be `every quarter of a cell`, and both of
+ * them are about where the integrand actually is.
+ *
+ * The thing being integrated is `chance(a, x)·chance(b, R − x)`, and each
+ * factor goes as one over the square of its own distance, so the whole of it
+ * lives in the last half-cell at either end and is nearly flat across the
+ * middle. An even walk spends almost all its samples where nothing is
+ * happening and still under-resolves the two places where everything is: over
+ * every separation tried it came out 0.9% low, consistently, which is a bias
+ * rather than noise.
+ *
+ * And it cost a number of steps proportional to R. Which is invisible for a
+ * pair thirty cells apart and is not invisible for the Sun and Neptune at
+ * eight hundred and forty — three and a half thousand samples for one pair of
+ * one frame, times the other bodies screening it, times every pair, times the
+ * sub-steps.
+ *
+ * Substituting x = R(1 − cos θ)/2 with θ even over [0, π] fixes both at once.
+ * Samples crowd into both ends quadratically, so the spikes are resolved far
+ * better than an even walk resolves them, and the count no longer depends on
+ * how far apart the two things are. Measured against a reference integral at
+ * four thousand samples a cell:
+ *
+ *     R              8      32      64     200     400     842
+ *     even, 0.25  −0.89%  −0.92%  −0.94%  −0.95%  −0.96%  −0.96%
+ *     this        −0.00%  +0.05%  +0.11%  −0.13%  +0.01%  −0.73%
+ *
+ * `GRAVITY` is measured through the same function, so correcting the bias
+ * moves the constant with it and nothing downstream notices.
+ */
+const WALK = 256;
+
+// One whole turn.
+const TURN_ROUND = Math.PI * 2;
+
+/**
+ * How much of what meets here is OPPOSITE rather than alike.
+ *
+ * A wave here is not a shell with a sign at every point — it is an AGGREGATE
+ * over the paths a great many discrete charges take, and what it carries at a
+ * place is a density. So what two of them do where they meet is not decided by
+ * testing one sign against another. It is a FRACTION: of all the pairings
+ * happening there, how many are opposite.
+ *
+ * Two cosines a phase ψ apart disagree in sign for ψ/π of the time, which is
+ * the whole of this function. Smooth, bounded, and never exactly nought unless
+ * the two are perfectly in step.
+ *
+ * Testing signs instead — which is what this did — produced every failure this
+ * account has had. It made two sources in step attract with EXACTLY nothing,
+ * at every separation from twelve cells to seven hundred, because on the
+ * surface between them their fields are identically equal. That does not
+ * survive being averaged, which is what an aggregate is.
+ */
+const opposed = (psi: number) => {
+  let w = psi % TURN_ROUND;
+
+  if (w > Math.PI) w -= TURN_ROUND;
+  if (w < -Math.PI) w += TURN_ROUND;
+
+  return Math.abs(w) / Math.PI;
+};
+
+/**
+ * How much of a source's emission is present at a place, on aggregate.
+ *
+ * One pulse's worth over the shell it has grown to (see `fade`), times how
+ * much it is putting out — which is its mass.
+ *
+ * This was the duty cycle of the pulse train, `min(2·PULSE/beat, 1)`, and the
+ * cap in it was silently clipping every mass above two: measured, the pull
+ * between two sources went as the product of their masses up to two and then
+ * stopped, so a pair at four and one pulled exactly as hard as a pair at two
+ * and one. Which is a real ceiling on a duty cycle — nothing can be present
+ * more than all of the time — but it is the wrong quantity to be reading.
+ *
+ * On aggregate what matters is the RATE at which charge is emitted, and
+ * whether that rate is reached by letting go of a shell more often or by
+ * putting more into each one is a detail below the level an aggregate sees.
+ * Mass is that rate. `beat` goes on setting the grain of the picture, which
+ * is what it is for.
+ */
+const density = (s: Live, r: number) => chance(s.mass ?? 1, r);
+
+/**
+ * How much space goes from between two things, per tick.
+ *
+ * Walked along the line between them, because that is the line that shortens:
+ * an annihilation takes two cells out of the world, and what it does to the
+ * distance between a and b is decided by whether those cells were on the way.
+ * Everything on that line is head-on by construction, so there is no
+ * `closing` factor to apply.
+ *
+ * At each place: how much of a is here, times how much of b, times how much
+ * of that is opposite. The first two are aggregates going as one over the
+ * square of the distance, so the line integral of their product goes as one
+ * over the square of the separation — measured flat to within four per cent
+ * by twenty-four cells and one and a half by forty-eight. Newton's law, out
+ * of a shell growing and two densities meeting on it.
+ */
+export const shortfall = (
+  one: Live, two: Live, others: Live[], dt: number,
+) => {
+  const dx = two.at[0] - one.at[0], dy = two.at[1] - one.at[1];
+
+  const R = Math.hypot(dx, dy);
+  if (R < 1e-9) return 0;
+
+  const steps = WALK;
+
+  // x = R(1 − cos θ)/2, so dx = R·sin θ/2 · dθ — see `WALK`.
+  const dtheta = Math.PI / steps;
+
+  /**
+   * How much of everything meeting anywhere along this line is opposite —
+   * settled ONCE for the line, and not place by place.
+   *
+   * Which is the difference between a ray and an aggregate, and it is worth
+   * spelling out because it was the largest error left in this model.
+   *
+   * Place by place, the phase between the two arrivals is ω times the path
+   * difference, ω(R − 2x), which sweeps from +ωR at one end to −ωR at the
+   * other and is nought exactly in the middle. That is right FOR A SINGLE RAY.
+   * But the meetings are not spread evenly along the line — the densities
+   * spike at both ends, where each source sits — so the density-weighted
+   * answer was carried almost entirely by the two endpoints, where the phase
+   * is ±ωR. And ±ωR is periodic in R with a period of one wavelength. So the
+   * pull between two things oscillated by a factor of 3.4 as they moved eight
+   * cells, which is not a force law at all. It hid perfectly from measurement
+   * for as long as the separations tried were multiples of the cycle.
+   *
+   * The endpoints are also exactly where a single ray's phase means least. A
+   * charge arriving at a place did not come along the straight line; it came
+   * by whatever path the shell took, and an aggregate is a sum over all of
+   * them. The straight-line path difference is one sample of a spread, and the
+   * spread is widest where the shell is nearest — which is to say, at the ends.
+   *
+   * So the phase is averaged over the line rather than read off it: every path
+   * difference between +ωR and −ωR occurs, equally, and the fraction opposite
+   * is the mean over all of them. Which is smooth, and behaves the way
+   * coherence ought to:
+   *
+   *     R (cells)      1      2      4      8     16     32
+   *     in step        0.13   0.25   0.50   0.50   0.50   0.50
+   *     half a cycle   0.88   0.75   0.50   0.50   0.50   0.50
+   *
+   * — a real, strong effect inside one wavelength, gone beyond it. Two things
+   * a long way apart cannot be in step in any way that matters, and the model
+   * now says so rather than pretending to know their separation to within a
+   * wavelength.
+   *
+   * Sources turning at DIFFERENT rates never had a fixed relation to average
+   * in the first place, and go straight to a half.
+   */
+  const drifting = Math.abs(one.omega - two.omega) > 1e-9;
+
+  let share = 0.5;
+
+  if (!drifting) {
+    let sum = 0;
+
+    // Evenly, unlike the walk below: this is an average over path
+    // DIFFERENCES, and every one of them is meant to count the same.
+    for (let k = 0; k < steps; k++)
+      sum += opposed(
+        one.omega * (R - 2 * ((k + 0.5) / steps) * R) + (one.phase - two.phase));
+
+    share = sum / steps;
+  }
+
+  /**
+   * Which of the others could shadow anything on this line — worked out once,
+   * rather than asked at every sample.
+   *
+   * A body screens where `chance` is not negligible, and `chance` goes as
+   * m/r², so it is only ever a near-field thing: a body of unit mass matters
+   * out to a couple of dozen cells and a body of a millionth of that matters
+   * out to a hundredth of a cell. In a solar system nothing screens anything
+   * and this comes back empty, which turns the inner loop off entirely —
+   * eight bodies' worth of distance and probability per sample per pair per
+   * sub-step, for a number that is one to four decimal places.
+   *
+   * Measured from the nearest point of the segment, so a body is kept if it
+   * could matter ANYWHERE along the line and dropped only if it could not
+   * matter at all.
+   */
+  const blockers = others.filter(c => {
+    if (c === one || c === two) return false;
+
+    const px = c.at[0] - one.at[0], py = c.at[1] - one.at[1];
+
+    // How far along the line the nearest point is, clamped to the ends.
+    const t = Math.min(Math.max((px * dx + py * dy) / (R * R), 0), 1);
+
+    return chance(c.mass ?? 1, Math.hypot(px - dx * t, py - dy * t)) > 1e-4;
+  });
+
+  let met = 0;
+
+  for (let k = 0; k < steps; k++) {
+    const theta = (k + 0.5) * dtheta;
+
+    const f = (1 - Math.cos(theta)) / 2;
+    const x = f * R;
+
+    // What this sample is worth, which is no longer the same for all of them.
+    const width = R * Math.sin(theta) / 2 * dtheta;
+
+    /**
+     * And whatever a third body has already put in this cell, it is not free
+     * for these two to meet in.
+     *
+     * The same `through` the drawing uses, for the same reason and out of the
+     * same number: a charge of one's heading for a charge of two's has to get
+     * past whatever else is standing there, and the chance a cell is free is
+     * one minus the chance something is in it. Which makes gravity here
+     * SCREENED — three bodies in a row do not simply add — and the screening
+     * is short-range, because `chance` is, so it shows up in a close pass and
+     * nowhere else.
+     *
+     * Newton has no such term and neither does general relativity at this
+     * order, so this is a genuine prediction of the model rather than a
+     * correction to it, and the three panels are where to look for it.
+     */
+    let screen = 1;
+
+    for (const c of blockers) {
+      const cx = one.at[0] + dx * f - c.at[0];
+      const cy = one.at[1] + dy * f - c.at[1];
+
+      screen *= through(c.mass ?? 1, Math.hypot(cx, cy));
+      if (screen < 1e-6) break;
+    }
+
+    met += density(one, x) * density(two, R - x) * screen * width;
+  }
+
+  /**
+   * And each of those meetings takes its own bite out of the line.
+   *
+   * No coupling constant: `met` is a count of coincidences per tick, because
+   * every factor in it is a probability or a count, and `BITE` is what the
+   * rule says one costs. What used to be `GAIN` was a fitted 1.776 standing
+   * in for the surface of the unit sphere squared — measured, exactly a
+   * hundred and forty times what the geometry asks for, which is (4π)²/BITE.
+   *
+   * What comes out is a COUNT: meetings along this line this tick. Not a
+   * speed, not an acceleration — a number of events. What it does to anything
+   * is settled in `drawn`, where the count becomes a density and the density
+   * becomes a drift, and the extra one-over-time this file could not previously
+   * account for turns out to be the difference between the two.
+   */
+  return BITE * met * share * dt;
+};
+
+/**
+ * The gravitational constant this model HAS, for two unit masses.
+ *
+ * Not a number put in — a number that comes out, measured off the model's own
+ * pull at a reference separation. `a_rel = 2·G·m/R²` is the definition, so
+ * this is that read backwards, once, at load.
+ *
+ * Which is what makes the Newtonian panel beside these an actual comparison.
+ * It used to be handed `UNIT·SWING²`, a number invented out of two scaling
+ * choices — so the question it asked was "does the model match a Newton
+ * calibrated against the model", which nothing can fail. Handed this, it asks
+ * whether the model's OWN constant produces the published orbits, which
+ * something can.
+ *
+ * Two unit masses a distance R apart meet S times a tick along the line
+ * between them. Each of them has its OWN emission to bias — m of it — so the
+ * count per path is S/m each, and the drift that comes to is LIGHT·(S/m)/SHEET
+ * while the field is weak. So
+ *
+ *     a_rel = LIGHT·S·(1/m_a + 1/m_b) / SHEET   =   G·(m_a + m_b) / R²
+ *
+ * and for two unit masses that reads G = S·LIGHT·R²/SHEET, which is this.
+ *
+ * The `(m_a + m_b)` is not arranged for and is the thing worth checking twice,
+ * because the previous split — share the shortfall between the two in
+ * proportion to what the other weighs — gave `a_rel ∝ m_a·m_b` instead. Which
+ * conserves momentum perfectly well and is not Newton's law: it says a feather
+ * falls slower than a hammer, and it made a solar system impossible, since a
+ * planet a millionth of the Sun's weight would have fallen a millionth as
+ * fast. Dividing by one's own mass instead is the equivalence principle, and
+ * here it is a counting statement rather than a postulate — what bends is the
+ * FRACTION of your paths that got biased, and a heavier thing brought
+ * proportionally more paths to the meeting.
+ */
+export const GRAVITY = (() => {
+  const R = 32;
+
+  const held = (x: number, phase: number) => ({
+    at: [x, 0], vel: [0, 0], path: [x, 0],
+    lobes: 0, omega: SPIN, phase, beat: 1, mass: 1,
+  } as unknown as Live);
+
+  const pair = [held(-R / 2, 0), held(R / 2, 0)];
+
+  // At rest `free` is exactly 1/SHEET, so this is the pull two motionless
+  // unit masses have — which is what a gravitational constant is.
+  return shortfall(pair[0], pair[1], pair, 1) * free(0) * R * R;
+})();
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
index f916dbd..407ef67 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
@@ -1,40 +1,61 @@
 /**
  * EQUATIONS IN THIS FILE
  *
- *   ds²        = e^{2φ}(dx² + dy²)                space, as a metric
- *
- *   S(x)       = Σ_{a<b} cancelling(Fa,Fb)·|Fa·Fb|·closing(d̂a,d̂b)
- *                                                 annihilation, per place
- *   φ(x)       = max(−K·S·dt, −1/4)               what is going, this tick
- *                                                 (per-tick: no ledger — see below)
- *
- *   apart(a,b) = ∫ e^φ ds  along a→b              how far apart they really are
- *   opposed(ψ) = |ψ| / π                          how much of a meeting cancels
- *   u̇          = deficit / 2   per pair, per tick  an ACCELERATION, not a speed
- *   ṙ          = v + u,  |u| ≤ LIGHT              the body's own motion, carried
- *
- *   bend       = ∇φ − (∇φ·ĥ)ĥ                     the geodesic turn, across ĥ
- *
- *   how much space a place has, which the bodies define:
- *     room(x)  = 1 / (1 + Σ_i (1/beat_i) / (1 + |x − r_i|))
- *     reach(x) = LIGHT · room(x)                  how far a pulse gets a tick
- *
- *   movement is a swap:
- *     wake     = −v·dt/step ahead, +v·dt/step behind      taken in front, laid behind
- *     carry    = v·dt / e^φ                       and it advances by that much
+ *   opposed(ψ)  = |ψ| / π                         how much of a meeting cancels
+ *   screen(x)   = Π_c through(m_c, |x − r_c|)     what a third body shadows
+ *
+ *   S(a,b)      = BITE ∫₀^R chance(m_a,s)·chance(m_b,R−s)·opposed·screen ds
+ *                                                 meetings a tick along a→b
+ *
+ *   the density of space, which is the whole of gravity here:
+ *     u        = LIGHT · n / (SHEET + n)          what a count of n comes to
+ *     free(v)  = (1 − v/LIGHT)² / SHEET           ... and so what one more buys
+ *     u̇_a      = free(|v_a|) · S(a,b) / m_a       the pull, per body, per tick
+ *     ṙ_a      = v_a + u_a                        its own course, plus that
+ *
+ *   An annihilation leaves the space where it happened denser: the next path
+ *   out of that point is twice as likely to go the way it went, a second one
+ *   makes it three to one, a third four. So a direction carrying n of them
+ *   weighs 1 + n against the SHEET ways out that weigh one each, and the share
+ *   of paths taking it over the share coming back is n / (SHEET + n).
+ *
+ *   Everything else here falls out of that, and none of it is stated:
+ *
+ *     at rest     free(0) = 1/SHEET               NEWTON, with no free constant
+ *     u̇ ∝ ṅ      a shortage of space is an ACCELERATION and not a speed,
+ *                 because what accumulates is the count and what drifts is a
+ *                 function of the count. That is the one-over-time this file
+ *                 could not previously account for.
+ *     at speed    free(v) → 0 as v → LIGHT        gravity weakens on a body
+ *                 already moving, because moving spends the same budget of
+ *                 paths that being pulled does. At light speed there is
+ *                 nothing left and light does not fall — which relativity says
+ *                 otherwise, and it has been measured. See `free`.
+ *     ÷ m_a       a_a ∝ m_b/R², a_b ∝ m_a/R²      the equivalence principle:
+ *                 heavier things have proportionally more paths to bias, so
+ *                 the same fraction of them bends. Inertia IS path count.
+ *
+ *   G           = S(1,1) · free(0) · R²           measured off the above, once
+ *
+ *   the picture only (φ drives nothing — see `spaceStep`):
+ *     φ(x)      = max(−K·S(x)·dt, −1/4)           where space is going
+ *     ds²       = e^{2φ}(dx² + dy²)
+ *     apart(a,b)= ∫ e^φ ds  along a→b             how far apart they really are
+ *     wake      = −v·dt/step ahead, +v·dt/step behind    taken in front, laid behind
  *
  */
 
 import { CanvasView, Surface } from "./canvas";
 import {
-  chance, Emitter, fade, grainAt, Live, PULSE, WAY, emit, fieldAt, TRAIL,
+  Emitter, fade, grainAt, HALF, Live, sparse, WAY, emit, fieldAt, TRAIL,
 } from "./field";
-import { CYCLE, SPIN } from "./lattice";
+import { free, shortfall } from "./gravity";
+import { CYCLE, SPIN, TAU } from "./lattice";
 import {
-  AMBER, BACKGROUND, CYAN, DECADES, ground, legend, lift, shown, source,
+  AMBER, BACKGROUND, CYAN, decadesFor, ground, legend, lift, shown, source,
   trail,
 } from "./paint";
-import { BITE, cancelling, closing, LIGHT } from "./physics";
+import { cancelling, closing } from "./physics";
 
 /**
  * Gravity as a shortage of space, which is what the lattice actually does.
@@ -100,8 +121,18 @@ export type Space = {
   n: number; x0: number; y0: number; step: number;
 };
 
-export const space = (span: number): Space => {
-  const n = 64;
+export const space = (span: number, sources = 2): Space => {
+  /**
+   * Coarsened by how much is in the picture, exactly as the field sampling is.
+   *
+   * Every cell of this costs a retarded time per source, so a five-body frame
+   * is five times the work of a two-body one — and unlike the field, this grid
+   * is only shading. It says where annihilation is happening, which is a broad
+   * smooth thing; there is nothing in it a finer grid would resolve and a
+   * coarser one would lose.
+   */
+  const n = Math.min(Math.max(
+    Math.round(64 / Math.sqrt(Math.max(sources, 2) / 2)), 24), 64);
 
   return {
     phi: new Float32Array(n * n),
@@ -133,11 +164,11 @@ export const phiAt = (w: Space, x: number, y: number): number => {
  * collision, so both factors are in it, and both are readable on the spot
  * without knowing which sources exist or which two of them are meant.
  */
-const eaten = (live: Live[], x: number, y: number, t: number, reach: number) => {
+const eaten = (live: Live[], x: number, y: number, t: number) => {
   const val: number[] = [], dx: number[] = [], dy: number[] = [];
 
   for (let i = 0; i < live.length; i++) {
-    val[i] = emit(live[i], live[i], x, y, t, reach);
+    val[i] = emit(live[i], live[i], x, y, t);
     dx[i] = WAY[0]; dy[i] = WAY[1];
   }
 
@@ -168,7 +199,7 @@ const eaten = (live: Live[], x: number, y: number, t: number, reach: number) =>
  * ringing for ever after the eating has finished.
  */
 export const spaceStep = (
-  w: Space, live: Live[], t: number, reach: number, dt: number,
+  w: Space, live: Live[], t: number, dt: number,
 ) => {
   const { phi, n, step } = w;
 
@@ -200,252 +231,30 @@ export const spaceStep = (
    * retarded fields and is nought until the two have reached each other.
    */
   /**
-   * How dark to draw a place that is losing space — a DISPLAY number, and
-   * the only one left in this file.
+   * How dark to draw a place that is losing space — a DISPLAY number, and the
+   * only one left in this file.
    *
-   * `phi` no longer has anything to do with the gravity: the pull is counted
-   * along the line between two things out of probabilities (see `shortfall`)
-   * and never consults this grid. What is left here is the picture of where
-   * annihilation is happening, and how strongly to shade it is a question
-   * about looking, not about physics.
+   * `phi` has nothing whatever to do with the gravity here, and it used to,
+   * which was a quiet mistake worth naming. The pull is counted along the line
+   * between two things out of probabilities (see `shortfall`) and never
+   * consults this grid — but `bend` and `carry` did consult it, so a number
+   * chosen to make the shading legible was setting how far a body was turned
+   * and how far a step carried it. A display gain of ten thousand was in the
+   * dynamics. Both of those are gone; what is left is a picture of where
+   * annihilation is happening, and how dark to draw it is a question about
+   * looking.
    */
   const gain = 1e4;
 
   for (let j = 0; j < n; j++)
     for (let i = 0; i < n; i++) {
-      const s = eaten(live, w.x0 + i * step, w.y0 + j * step, t, reach);
+      const s = eaten(live, w.x0 + i * step, w.y0 + j * step, t);
 
       // Never more than a place has to give.
       phi[j * n + i] = Math.max(-gain * s * dt, -0.25);
     }
 };
 
-/**
- * How much space a place has, which is a thing the bodies decide.
- *
- * This is the piece the model was missing, and it is what makes the whole
- * thing depend on SCALE rather than only on shape. A body is a thing that
- * pulses, and pulsing is what charges the space around it; where two of them
- * are close in units of their own pulsing there is little room between them,
- * and where they are far apart in those units there is a great deal. The same
- * three bodies in the same arrangement are therefore not the same experiment
- * at one size as at another — which is exactly the objection to a model whose
- * only lengths come from the viewport, and it is why nothing here reproduced
- * a three-body orbit at any coupling: the arrangement had no size.
- *
- * Bounded in (0, 1] by construction: a place can be crowded down towards
- * having no room at all, and never has more than empty space has.
- *
- * And it is read off the bodies as they stand rather than accumulated, so
- * there is no ledger to run away and no halo — the shortage is a fact about
- * where things ARE, which is the same reason it can be drawn.
- */
-export const room = (live: Live[], x: number, y: number) => {
-  let crowd = 0;
-
-  for (const s of live) {
-    const r = Math.hypot(x - s.at[0], y - s.at[1]);
-
-    // How often it pulses is what it weighs — see `Source.mass`. Scaled so
-    // that one cell from a source of unit mass, half the room is gone; the
-    // rest follows from the one over r, which is a gentle thing by nature
-    // and opens out slowly across a frame.
-    crowd += (CYCLE / (s.beat ?? CYCLE)) * 2 / (1 + r);
-  }
-
-  return 1 / (1 + crowd);
-};
-
-/**
- * And so how far a pulse gets in a tick.
- *
- * One cell where there is a cell to cross, and less where the space has been
- * crowded down. Which is the same statement as the metric — a step is a step
- * of PROPER length, and where there is less of it a tick covers less ground.
- */
-export const reach = (live: Live[], x: number, y: number) => room(live, x, y);
-
-/*
- * Both of the two above are DEFINED AND NOT YET WIRED, which is worth saying
- * plainly rather than leaving to be discovered. A pulse still travels a flat
- * cell a tick whatever room it is crossing, and the retarded time is still
- * solved on straight-line distance. Wiring `reach` into the propagation is
- * what would close the loop — the bodies deciding how much space there is,
- * and the space deciding how far a pulse gets — and it is the next thing.
- */
-
-/**
- * How hard the annihilation pulls on the space. One constant, and the only
- * one in this account.
- */
-
-
-/**
- * How finely the line between two things is walked, in cells.
- *
- * A LENGTH, and that is the point: nothing about how hard two things pull on
- * each other may depend on how far out the camera is. This was read off the
- * grid the field is drawn on — `n = 64` across whatever the frame happened to
- * be — and measured, that made gravity proportional to the cell size: a pair
- * held at sixteen cells pulled five times harder drawn at a span of sixty-four
- * than at twelve.
- */
-const SAMPLE = 0.25;
-
-// One whole turn.
-const TURN_ROUND = Math.PI * 2;
-
-/**
- * How much of what meets here is OPPOSITE rather than alike.
- *
- * The single most important thing in this file, and it took the whole
- * three-body benchmark to find. A wave here is not a shell with a sign at
- * every point — it is an AGGREGATE over the paths a great many discrete
- * charges take, and what it carries at a place is a density. So what two of
- * them do where they meet is not decided by testing one sign against another.
- * It is a FRACTION: of all the pairings happening there over a cycle, how
- * many are opposite.
- *
- * Two cosines a phase ψ apart disagree in sign for ψ/π of the time, which is
- * the whole of this function. Smooth, bounded, and never exactly nought
- * unless the two are perfectly in step at that very place.
- *
- * Testing signs instead — which is what this did — produced every failure
- * this account has had. It made the pull a function of `R mod CYCLE`, because
- * the answer was set by the phase at the ends of the line, swinging it
- * twenty-three fold with an eight-cell period. And it made two sources in
- * step attract with EXACTLY nothing, at every separation from twelve cells to
- * seven hundred, because on the surface between them their fields are
- * identically equal. Neither survives being averaged, which is what an
- * aggregate is.
- *
- * Coherence still matters, but as a strength rather than as a switch: two
- * sources in step come out about half as strong as two half a cycle apart,
- * which is the difference showing up where it belongs.
- */
-const opposed = (psi: number) => {
-  let w = psi % TURN_ROUND;
-
-  if (w > Math.PI) w -= TURN_ROUND;
-  if (w < -Math.PI) w += TURN_ROUND;
-
-  return Math.abs(w) / Math.PI;
-};
-
-/**
- * How much of a source's emission is present at a place, on aggregate.
- *
- * One pulse's worth over the shell it has grown to (see `fade`), times how
- * much it is putting out — which is its mass.
- *
- * This was the duty cycle of the pulse train, `min(2·PULSE/beat, 1)`, and the
- * cap in it was silently clipping every mass above two: measured, the pull
- * between two sources went as the product of their masses up to two and then
- * stopped, so a pair at four and one pulled exactly as hard as a pair at two
- * and one. Which is a real ceiling on a duty cycle — nothing can be present
- * more than all of the time — but it is the wrong quantity to be reading.
- *
- * On aggregate what matters is the RATE at which charge is emitted, and
- * whether that rate is reached by letting go of a shell more often or by
- * putting more into each one is a detail below the level an aggregate sees.
- * Mass is that rate. `beat` goes on setting the grain of the picture, which
- * is what it is for.
- */
-const density = (s: Live, r: number) => chance(s.mass ?? 1, r);
-
-/**
- * How much space goes from between two things, per tick.
- *
- * Walked along the line between them, because that is the line that shortens:
- * an annihilation takes two cells out of the world, and what it does to the
- * distance between a and b is decided by whether those cells were on the way.
- * Everything on that line is head-on by construction, so there is no
- * `closing` factor to apply.
- *
- * At each place: how much of a is here, times how much of b, times how much
- * of that is opposite. The first two are aggregates going as one over the
- * square of the distance, so the line integral of their product goes as one
- * over the square of the separation — measured flat to within four per cent
- * by twenty-four cells and one and a half by forty-eight. Newton's law, out
- * of a shell growing and two densities meeting on it.
- */
-const shortfall = (
-  one: Live, two: Live, t: number, reach: number, dt: number,
-) => {
-  const dx = two.at[0] - one.at[0], dy = two.at[1] - one.at[1];
-
-  const R = Math.hypot(dx, dy);
-  if (R < 1e-9) return 0;
-
-  const steps = Math.max(Math.ceil(R / SAMPLE), 2);
-
-  // Sources turning at different rates drift through every phase against each
-  // other, so half of everything they do is opposite. Turning together, the
-  // phase between them at a place is fixed and set by the path difference.
-  const drifting = Math.abs(one.omega - two.omega) > 1e-9;
-
-  let met = 0;
-
-  for (let k = 0; k < steps; k++) {
-    const x = (k + 0.5) / steps * R;
-
-    const share = drifting ? 0.5
-      : opposed(one.omega * (R - 2 * x) + (one.phase - two.phase));
-
-    met += density(one, x) * density(two, R - x) * share * (R / steps);
-  }
-
-  /**
-   * And each of those meetings takes its own bite out of the line.
-   *
-   * No coupling constant: `met` is a count of coincidences per tick, because
-   * every factor in it is a probability or a count, and `BITE` is what the
-   * rule says one costs. What used to be `GAIN` was a fitted 1.776 standing
-   * in for the surface of the unit sphere squared — measured, exactly a
-   * hundred and forty times what the geometry asks for, which is (4π)²/BITE.
-   *
-   * One honest caveat, and it is the last free thing in this file. What comes
-   * out here is cells per tick — a SPEED of approach, which is what removing
-   * space from between two things gives you. It is added to `carry`, a
-   * velocity, so it acts as an acceleration. That extra one-over-time is not
-   * derivable from any of the above: it is the open question of whether a
-   * shortage of space is a rate or a rate of a rate, and the model has not
-   * said. Everything else here is now a consequence.
-   */
-  return BITE * met * dt;
-};
-
-/**
- * The gravitational constant this model HAS, for two unit masses.
- *
- * Not a number put in — a number that comes out, measured off the model's own
- * pull at a reference separation. `a_rel = 2·G·m/R²` is the definition, so
- * this is that read backwards, once, at load.
- *
- * Which is what makes the Newtonian panel beside these an actual comparison.
- * It used to be handed `UNIT·SWING²`, a number invented out of two scaling
- * choices — so the question it asked was "does the model match a Newton
- * calibrated against the model", which nothing can fail. Handed this, it asks
- * whether the model's OWN constant produces the published orbits, which
- * something can.
- *
- * The two came out within four per cent of each other, which is luck.
- */
-export const GRAVITY = (() => {
-  const R = 32;
-
-  const held = (x: number, phase: number) => ({
-    at: [x, 0], vel: [0, 0], path: [x, 0],
-    lobes: 0, omega: SPIN, phase, beat: 1, mass: 1,
-  } as unknown as Live);
-
-  return shortfall(held(-R / 2, 0), held(R / 2, 0), 0, 0, 1) * R * R / 2;
-})();
-
-/**
- * How far apart two places are, in the metric rather than in the picture.
-/**
- * How far apart two places are, in the metric rather than in the picture.
 /**
  * How far apart two places are, in the metric rather than in the picture.
  *
@@ -479,33 +288,23 @@ export const apart = (
   return (total / steps) * straight;
 };
 
-/**
- * Which way a course bends, when it is going straight in a space that is not.
- *
- * For a conformal metric the geodesic turns by the part of ∇φ lying ACROSS
- * the direction of travel, and by nothing else — so a straight line stays the
- * same length and only comes round, which is the one thing this model allows.
- * Nothing accelerates: there is no force here, and this is not one. It is
- * what "carry on the way you were going" comes to when the ground it is
- * measured against has been shortened on one side.
+/*
+ * There used to be a `bend` here — the geodesic turn, taken as the part of ∇φ
+ * lying across the direction of travel — and a `carry` that advanced a body by
+ * `speed·dt / e^φ`, so that a step of proper length covered more coordinate
+ * where the ground had been thinned.
+ *
+ * Both are gone, and the reason is not that the idea was wrong. It is that
+ * they read `phi`, and `phi` is scaled by a number chosen to make the shading
+ * legible (see `spaceStep`). A picture's contrast setting was deciding how
+ * hard bodies turned. Whatever those two terms were worth, that was not a
+ * measurement of it.
+ *
+ * What replaced them is smaller and says the same thing without a grid in the
+ * middle: a body goes the way it was going, plus however much the space around
+ * it has been biased (`drawn`). One velocity, made of two parts, and the
+ * second part is the whole of gravity.
  */
-const TURN: [number, number] = [0, 0];
-
-export const bend = (
-  w: Space, x: number, y: number, hx: number, hy: number,
-) => {
-  const d = w.step;
-
-  const gx = (phiAt(w, x + d, y) - phiAt(w, x - d, y)) / (2 * d);
-  const gy = (phiAt(w, x, y + d) - phiAt(w, x, y - d)) / (2 * d);
-
-  // Across the way it is going. The part along it would be a change of speed,
-  // and there is nothing here that changes speed.
-  const along = gx * hx + gy * hy;
-
-  TURN[0] = gx - along * hx;
-  TURN[1] = gy - along * hy;
-};
 
 /**
  * Movement, which is not a value being changed.
@@ -525,10 +324,11 @@ export const bend = (
  * Written this way, movement and gravity stop being two mechanisms. Both are
  * the same operation on the space and differ only in shape: annihilation is a
  * loss BETWEEN two things, which brings them together; movement is a loss in
- * front and a gain behind, which carries one along. And the second is the
- * counterweight to the first — measured, a pair sent past each other at half
- * of light hold at eleven cells rather than collapsing, because what their
- * motion lays down behind them pushes out against what their meeting eats.
+ * front and a gain behind, which carries one along.
+ *
+ * Drawn rather than acted on. It is written into `phi`, which is the picture,
+ * so what this shows is the wake of a moving source and not a term in its
+ * dynamics — see the note where `bend` and `carry` used to be.
  */
 const SWAP = 0.5;
 
@@ -541,12 +341,16 @@ const deposit = (w: Space, x: number, y: number, q: number) => {
   w.phi[j * w.n + i] += q;
 };
 
-export const wake = (w: Space, live: Live[], dt: number) => {
+export const wake = (
+  w: Space, live: Live[], going: (s: Live) => [number, number], dt: number,
+) => {
   for (const s of live) {
-    const speed = Math.hypot(s.vel[0], s.vel[1]);
+    const [vx, vy] = going(s);
+
+    const speed = Math.hypot(vx, vy);
     if (speed < 1e-9) continue;
 
-    const hx = s.vel[0] / speed, hy = s.vel[1] / speed;
+    const hx = vx / speed, hy = vy / speed;
 
     // How much of a cell it gets through this tick, which is the whole of
     // what its speed is.
@@ -557,32 +361,6 @@ export const wake = (w: Space, live: Live[], dt: number) => {
   }
 };
 
-/**
- * And it advances by however much coordinate the space it destroyed was
- * worth.
- *
- * Which is the whole coupling between moving and gravity, and it falls out
- * rather than being put in: a step is one step of PROPER length, so where the
- * ground has been thinned by something else eating it, the same step covers
- * more of the picture. A thing crossing a region two things are annihilating
- * gets further for the same effort — and light does too, which is why the
- * pair start hearing each other sooner as they close.
- */
-export const carry = (w: Space, live: Live[], dt: number) => {
-  for (const s of live) {
-    const speed = Math.hypot(s.vel[0], s.vel[1]);
-    if (speed < 1e-9) continue;
-
-    const hx = s.vel[0] / speed, hy = s.vel[1] / speed;
-
-    const left = Math.max(Math.exp(phiAt(w, s.at[0], s.at[1])), 0.05);
-    const advance = speed * dt / left;
-
-    s.at[0] += hx * advance;
-    s.at[1] += hy * advance;
-  }
-};
-
 // A 4x4 ordered pattern, centred on nought and worth about one level of an
 // eight-bit channel.
 const DITHER = [
@@ -620,65 +398,148 @@ export const MetricField = ({
     let img: ImageData | null = null;
 
     let t = 0;
-    let world = space(span);
+    let world = space(span, sources.length);
 
-    type Carried = Live & { carry: [number, number] };
+    /**
+     * `pulled` is how much the space around this body has been biased into
+     * carrying it — a velocity, and the whole of what gravity does here.
+     *
+     * It is not a force having been applied. It is the running count of
+     * annihilations, turned into a drift by `drawn`, and accumulated with the
+     * marginal gain `free` gives at whatever speed the body has already
+     * reached. Which is why it accelerates rather than merely displaces: the
+     * count persists, and the drift is a function of the count.
+     */
+    type Carried = Live & { pulled: [number, number], mark: number[] };
 
     let live: Carried[] = [];
 
     const reset = () => {
       t = 0;
-      world = space(span);
+      world = space(span, sources.length);
       live = sources.map(s => ({
         ...s,
         at: [...s.at] as [number, number],
         path: [s.at[0], s.at[1]],
         vel: [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number],
-        carry: [0, 0] as [number, number],
+        pulled: [0, 0] as [number, number],
+        mark: [s.at[0], s.at[1]],
       }));
+      kept = 0;
     };
 
-    // Everywhere each of them has been, kept up to the moment, so that a ring
-    // already in the air belongs to a place and stays there.
+    // Its own course plus whatever the space around it has been biased into
+    // doing. One velocity, made of two parts — and the split between them is
+    // bookkeeping, not physics: `free` is asked about the sum.
+    const going = (s: Live): [number, number] => {
+      const p = (s as Carried).pulled;
+
+      return [s.vel[0] + p[0], s.vel[1] + p[1]];
+    };
+
+    /**
+     * Everywhere each of them has been, kept two ways, because two different
+     * things want it and they want it at wildly different resolutions.
+     *
+     * `path` is the EMISSION history: what is at distance r left r ticks ago,
+     * from wherever the source was then, so a ring already in the air belongs
+     * to a place and stays there however the thing that made it carries on.
+     * It has to be fine — twice a tick — and `was` indexes it by dividing by
+     * exactly that, so the interval is not adjustable.
+     *
+     * `mark` is the DRAWN trail, and it wants the opposite. A run of ninety
+     * thousand ticks is a hundred and eighty thousand samples of `path` per
+     * body, which is tens of megabytes across a page of these and rather more
+     * points than a curve a few hundred pixels wide has anywhere to put.
+     *
+     * So the fine one is only kept while the field is actually being drawn —
+     * nothing else reads it, since `retard` is only reached from `fieldAt` —
+     * and the coarse one is always kept, at whatever interval leaves a few
+     * thousand points across the whole run.
+     */
+    const EVERY = Math.max(cycle / 3000, TRAIL);
+
+    let kept = 0;
+
     const remember = () => {
-      for (const s of live)
-        for (let k = s.path.length / 2; k <= t / TRAIL; k++)
-          s.path.push(s.at[0], s.at[1]);
+      if (showing)
+        for (const s of live)
+          for (let k = s.path.length / 2; k <= t / TRAIL; k++)
+            s.path.push(s.at[0], s.at[1]);
+
+      while (kept < t / EVERY) {
+        kept++;
+        for (const s of live) s.mark.push(s.at[0], s.at[1]);
+      }
     };
 
     reset();
 
+    // As close as adjacent gets: a source is not space, so neither can be
+    // moved through.
+    const TOUCH = 1;
+
     /**
-     * The contraction, which gives the space a RATE and not a displacement.
+     * What the meetings along each line come to, added to each body's count.
      *
-     * This moved the two ends of the line together directly, by however much
-     * the line had lost, and that was wrong in a way that took the whole
-     * three-body benchmark to see. It made gravity a VELOCITY of approach —
-     * and Newton's is an acceleration. Measured, the difference is everything
-     * the model was failing at: a velocity law has no inertia in the radial
-     * direction, so nothing can overshoot and swing round, and there is no
-     * orbit to be had at any coupling. Every scan came back at the same
-     * forty-five degrees, which is not a dynamics at all — it is the
-     * geometric asymptote of two things on fixed courses being drawn together.
+     * Divided by its OWN mass, which is the whole of the equivalence principle
+     * here and is worth being exact about why. `deficit` is a number of
+     * meetings, and a meeting needs one charge from each side — so it already
+     * carries both masses, and a body twice as heavy has twice as many
+     * meetings simply by having brought twice as much to them. What decides
+     * how far it is bent is not how many of its paths were biased but what
+     * FRACTION of them were, and the count of paths it has is its mass. So the
+     * two masses in `deficit` and the one divided out here leave exactly one
+     * behind: a_a ∝ m_b, a_b ∝ m_a, which is Newton, and it falls out of
+     * counting rather than being imposed.
+     *
+     * This was `deficit·(m_other/(m_a+m_b))` — the momentum-conserving split
+     * of a shared displacement — which also conserves momentum and is not the
+     * same law: it makes the relative acceleration go as m_a·m_b instead of
+     * m_a + m_b, so a light body barely falls towards a heavy one. Momentum is
+     * conserved either way (m_a·ṅ_a = deficit = m_b·ṅ_b here too); what the
+     * old split got wrong was which of the two ways to conserve it.
+     */
+    /**
+     * Below what share of a body's own strongest pull a pair is not walked.
      *
-     * The distance law was never the problem and is worth saying so plainly:
-     * the eating between two sources already goes as one over the square of
-     * the separation, measured flat to within a percent from twenty-four
-     * cells out. That is Newton's law, and it comes out of how a rotating
-     * pair of poles spreads over a shell rather than being put in.
+     * Walking the line is the whole cost of the dynamics, and it is paid per
+     * PAIR — nine bodies is thirty-six of them, of which eight are a Sun and a
+     * planet and the other twenty-eight are two planets whose pull on each
+     * other is a millionth of a millionth of that. Every one of those was
+     * being integrated to four decimal places to arrive at nothing.
      *
-     * So the shortage gives the space a rate of contraction, which persists
-     * and accumulates, and the bodies are CARRIED by it. Their own motion is
-     * untouched — nothing changes speed, which is the model's own rule — and
-     * what accumulates belongs to the space. With that one change the
-     * benchmark stops escaping and stops collapsing: the figure eight holds
-     * between nineteen and fifty-seven cells and comes round three hundred
-     * and twenty-six degrees, and moth and goggles likewise.
+     * What is skipped is decided by estimate, not by measurement of the thing
+     * being skipped, which would defeat the point. `shortfall` comes to about
+     * 3.3·m_a·m_b/R² (see the flatness of `S·R²` there), so the acceleration
+     * it gives A is about m_b/R² up to constants that are the same for every
+     * pair — and only ratios are wanted here, so they cancel.
+     *
+     * Kept relative to each body's own strongest pull rather than against an
+     * absolute floor, so that a light body far from everything still feels
+     * whatever is nearest to it. At a tenth of a millionth, real perturbations
+     * survive comfortably — Jupiter's pull on Saturn is five parts in a
+     * thousand of the Sun's and is nowhere near this — and what goes is only
+     * what could not move anything in the length of the run.
      */
-    const TOUCH = 1;
+    const NOTHING = 1e-7;
+
+    const most: number[] = [];
 
     const spend = (dt: number) => {
-      const reach = span * 0.6;
+      for (let i = 0; i < live.length; i++) most[i] = 0;
+
+      for (let i = 0; i < live.length; i++)
+        for (let j = i + 1; j < live.length; j++) {
+          const dx = live[j].at[0] - live[i].at[0];
+          const dy = live[j].at[1] - live[i].at[1];
+
+          const rr = dx * dx + dy * dy;
+          if (rr < 1e-12) continue;
+
+          most[i] = Math.max(most[i], (live[j].mass ?? 1) / rr);
+          most[j] = Math.max(most[j], (live[i].mass ?? 1) / rr);
+        }
 
       for (let i = 0; i < live.length; i++)
         for (let j = i + 1; j < live.length; j++) {
@@ -688,108 +549,48 @@ export const MetricField = ({
           const coord = Math.hypot(dx, dy);
           if (coord < 1e-6) continue;
 
-          const deficit = shortfall(a, b, t, reach, dt);
-          if (deficit <= 1e-9) continue;
+          const rr = coord * coord;
 
-          dx /= coord; dy /= coord;
+          // Nothing either end could feel — see `NOTHING`.
+          if ((b.mass ?? 1) / rr < NOTHING * most[i]
+            && (a.mass ?? 1) / rr < NOTHING * most[j]) continue;
 
-          /**
-           * And shared out by weight, not evenly.
-           *
-           * The line between them has lost this much, and both ends move to
-           * take it up — but not equally: the heavier one moves less, in
-           * exactly the proportion that leaves the momentum where it was.
-           * Split evenly, as this did, a pair at four and one accelerated
-           * the same amount each and the momentum grew every tick out of
-           * nothing.
-           *
-           * Which is Newton's rule arrived at from the other side. There the
-           * acceleration of one body carries the mass of the OTHER, so the
-           * two accelerations are in inverse proportion to the masses. Here
-           * nothing is pulled at all — a length has gone from between them —
-           * and how a shortening is taken up by its two ends is settled by
-           * the same thing.
-           */
-          const ma = a.mass ?? 1, mb = b.mass ?? 1;
-          const both = ma + mb;
+          const deficit = shortfall(a, b, live, dt);
+          if (deficit <= 1e-12) continue;
 
-          const toA = deficit * (mb / both);
-          const toB = deficit * (ma / both);
+          dx /= coord; dy /= coord;
 
-          a.carry[0] += dx * toA; a.carry[1] += dy * toA;
-          b.carry[0] -= dx * toB; b.carry[1] -= dy * toB;
-        }
+          for (const [s, ux, uy] of [[a, dx, dy], [b, -dx, -dy]] as const) {
+            const [vx, vy] = going(s);
 
-      // And no place of space goes faster than light, whatever the sum of
-      // what is eating it comes to.
-      for (const s of live) {
-        const going = Math.hypot(s.carry[0], s.carry[1]);
+            // Divided by its own mass — the fraction of ITS paths that got
+            // bent — and scaled by how many of them are still free to bend at
+            // the speed it is already going. See `free`.
+            const got = free(Math.hypot(vx, vy)) * deficit / (s.mass ?? 1);
 
-        if (going > LIGHT) {
-          s.carry[0] *= LIGHT / going;
-          s.carry[1] *= LIGHT / going;
+            s.pulled[0] += ux * got; s.pulled[1] += uy * got;
+          }
         }
-      }
     };
 
-    function advance(dt: number) {
-      const reach = span * 0.6;
-
-      spaceStep(world, live, t, reach, dt);
+    /**
+     * One step of the dynamics, and there is very little left of it.
+     *
+     * Count the meetings, add them to each body's density, and move each body
+     * by its own course plus whatever that density comes to. No force, no
+     * potential, no field consulted, no gradient — and nothing that reads the
+     * grid `phi` is drawn on, which is the whole point of the note above.
+     */
+    const step = (dt: number) => {
+      spend(dt);
 
-      /**
-       * Each carries on the way it was going, turned by the ground it is
-       * crossing and by nothing else. Nothing changes speed, and nothing is
-       * pushed towards anything.
-       *
-       * Turned before its own wake is laid down, because a thing does not
-       * feel what it is itself putting behind it — the taking in front and
-       * the laying behind are not two forces on it that happen to cancel,
-       * they are what its moving IS.
-       */
       for (const s of live) {
-        const speed = Math.hypot(s.vel[0], s.vel[1]);
-        if (speed < 1e-9) continue;
-
-        bend(world, s.at[0], s.at[1], s.vel[0] / speed, s.vel[1] / speed);
-
-        /**
-         * Per STEP, not per tick — a thing is only deflected when it moves.
-         *
-         * The geodesic turns by ∂φ/∂n per unit of PROPER LENGTH travelled,
-         * and a body covers `speed·dt` of that in a tick, so the turn rate
-         * goes as the speed. Adding a perpendicular of length `|∇φ|·dt` to a
-         * velocity of length `speed` rotates it by `|∇φ|·dt / speed` — which
-         * is the wrong way round, and wrong by a factor of speed squared.
-         *
-         * Which is the lattice's own position, arrived at dimensionally: a
-         * ray is deflected because the connection it takes next is not where
-         * the last one pointed, and it only takes one by moving. Something
-         * standing still is not on a geodesic at all.
-         */
-        const step = speed * speed * dt;
-
-        const vx = s.vel[0] + TURN[0] * step;
-        const vy = s.vel[1] + TURN[1] * step;
-
-        const now = Math.hypot(vx, vy);
-        if (now > 1e-9) s.vel = [vx * speed / now, vy * speed / now];
-      }
-
-      // Movement: the space in front destroyed, the same laid down behind,
-      // and the thing carried by however much coordinate that was worth.
-      carry(world, live, dt);
-      wake(world, live, dt);
+        const [vx, vy] = going(s);
 
-      // And carried by the space itself, which is where the gravity is.
-      for (const s of live) {
-        s.at[0] += s.carry[0] * dt;
-        s.at[1] += s.carry[1] * dt;
+        s.at[0] += vx * dt;
+        s.at[1] += vy * dt;
       }
 
-      // And whatever space has gone from between them, goes.
-      spend(dt);
-
       // Not through one another: a source is not space.
       for (let i = 0; i < live.length; i++)
         for (let j = i + 1; j < live.length; j++) {
@@ -804,6 +605,47 @@ export const MetricField = ({
           a.at[0] -= dx / gap * back; a.at[1] -= dy / gap * back;
           b.at[0] += dx / gap * back; b.at[1] += dy / gap * back;
         }
+    };
+
+    /**
+     * How many of those to a frame.
+     *
+     * The dynamics are cheap — a line walk per pair — and the picture is not,
+     * so there is no reason to run them at the frame rate. A close pass is
+     * stiff, and at a tenth of a tick per frame it is walked through in
+     * strides; Newton's panel beside it has always sub-stepped, and comparing
+     * a finely integrated orbit against a coarsely integrated one is comparing
+     * two integrators rather than two laws.
+     */
+    /**
+     * The longest step worth taking, in ticks — so the number of them follows
+     * the clock rather than being fixed at it.
+     *
+     * This was twelve a frame whatever `rate` was, which ties the accuracy of
+     * the integration to how fast the picture is being played: at ten ticks a
+     * second each step was a sixtieth of a tick, and at nine hundred it was
+     * one and a quarter. The same arrangement integrated two ways, and the
+     * faster one silently the coarser. Fixing the STEP instead and counting
+     * how many fit is the same choice `newton.tsx` makes when it sub-steps
+     * twenty-four times, and it means the pace is free.
+     */
+    const STRIDE = 0.25;
+
+    // Whether the last frame drew the field at all — see `draw`. Nothing that
+    // feeds only the picture is computed when the picture has no room for it.
+    let showing = true;
+
+    function advance(dt: number) {
+      const n = Math.min(Math.max(Math.ceil(dt / STRIDE), 1), 64);
+
+      for (let k = 0; k < n; k++) step(dt / n);
+
+      // And the picture, which is the expensive half and is worth nothing at
+      // a scale where no shell can be resolved.
+      if (showing) {
+        spaceStep(world, live, t, dt);
+        wake(world, live, going, dt);
+      }
     }
 
     function draw({ ctx, width: w, height: h }: Surface) {
@@ -819,14 +661,110 @@ export const MetricField = ({
        * and the field is thrown away at scales where the arm is perfectly
        * legible and only its grain is not, which is most of them.
        */
-      const turnPx = CYCLE * (Math.min(w, h) / (2 * Math.max(span, 1)));
+      const scale = Math.min(w, h) / (2 * span);
+
+      /**
+       * How long the field's own pattern is, in cells — read off the sources
+       * rather than assumed.
+       *
+       * A source turns over `rate` times per `CYCLE` ticks and what it lays
+       * down travels a cell a tick, so the pattern repeats every `CYCLE/rate`
+       * cells, which is `TAU/ω`. At the lattice's own pace that is `CYCLE`,
+       * and this was written as `CYCLE`; for a body flipping once per `SLOW`
+       * ticks it is twelve times longer, and everything downstream — whether
+       * the picture can be resolved at all, how finely to sample it, whether
+       * to draw shells — was answering about a wavelength none of these
+       * sources has. It had the solar systems sampling at the finest spacing
+       * allowed, over the widest frames in the article, for a pattern a
+       * hundred cells long.
+       */
+      const wave = Math.max(...live.map(s =>
+        TAU / Math.max(Math.abs(s.omega), SPIN / 1e3)));
+
+      const turnPx = wave * scale;
+
+      const paths = () => {
+        for (const s of live)
+          trail(ctx, s.mark, x => w / 2 + x * scale, y => h / 2 + y * scale, 0.5);
+      };
+
+      const dots = () => {
+        for (const s of live)
+          source(ctx, w / 2 + s.at[0] * scale, h / 2 + s.at[1] * scale,
+            { halo: 14, dot: 2.2 });
+      };
+
+      /**
+       * And where it cannot be resolved at all, it is not drawn.
+       *
+       * The legend used to say "too far out to resolve the arm" while the
+       * field was computed and drawn underneath it anyway — a wash of
+       * unresolvable interference behind the one thing the picture was about,
+       * costing the most on exactly the arrangements with the most bodies,
+       * since every sample solves a retarded time per source and a meeting
+       * surface per pair.
+       *
+       * Left where it was, and opted out of rather than lowered. Below thirty
+       * pixels to a turn the shells are under three pixels apart and drawing
+       * them is drawing moiré — so the arrangements that want their field at a
+       * wide span say `summary: false` and get it, and everything else keeps
+       * the picture it had.
+       */
       const brief = summary ?? (turnPx < 30);
 
-      // Smooth where the winding can be read, grainy where it cannot.
-      const grain = grainAt(turnPx);
+      showing = !brief;
+
+      if (brief) {
+        ground(ctx, w, h);
+
+        legend(ctx, w, h,
+          `too far out to resolve a band — showing the path each has taken`);
+
+        paths();
+        dots();
+
+        return;
+      }
+
+      /**
+       * Smooth where the structure can be read, grainy where it cannot — and
+       * smooth outright where there is no grain to show.
+       *
+       * Shells are worth drawing as shells only in the window where one of
+       * them is a thing you can see, and it is bounded at both ends.
+       *
+       * Too far apart, and there is no train: a body of tiny mass lets go of
+       * one every `1/mass` ticks, which for anything planetary is further than
+       * the frame is wide, so what would be drawn is one lonely ring and an
+       * empty picture. See `sparse`.
+       *
+       * Too close together, and there is no ring: at four pixels the shells
+       * are already finer than the screen can hold them apart, and drawing
+       * them produces moiré that moves when the source does — a pattern that
+       * looks like physics and is an artefact of the sampling. Below that the
+       * continuous reading is not merely nicer, it is the only one the picture
+       * can carry, and it is the accurate one anyway.
+       */
+      const shellPx = Math.min(...live.map(s => s.beat ?? 1)) * scale;
+
+      const grain = live.some(s => sparse(s.beat, span)) || shellPx < 4
+        ? 0 : grainAt(turnPx);
 
-      const bandPx = (CYCLE / 2) * (Math.min(w, h) / (2 * Math.max(span, 1)));
-      const SAMPLE = Math.max(Math.min(bandPx / 5, 4), 1.4);
+      const bandPx = (wave / 2) * scale;
+
+      /**
+       * How finely to sample the picture — and it is coarsened by how much is
+       * IN the picture.
+       *
+       * Every sample costs a retarded time per source and a meeting surface
+       * per PAIR, so the work per sample goes as the number of bodies and
+       * then some: nine of them is eighty-one meeting surfaces where two is
+       * one. So the grid opens out in proportion — the same total work over
+       * fewer, bigger pixels, which is the right thing to give up when the
+       * alternative is an accurate picture nobody can watch move.
+       */
+      const crowd = Math.max(live.length, 2) / 2;
+      const SAMPLE = Math.max(Math.min(bandPx / 5, 4) * crowd, 1.4);
 
       const cols = Math.max(Math.round(w / SAMPLE), 1);
       const rows = Math.max(Math.round(h / SAMPLE), 1);
@@ -840,8 +778,26 @@ export const MetricField = ({
 
       const px = img.data;
 
-      const scale = Math.min(w, h) / (2 * span);
-      const reach = span * 0.6;
+      /**
+       * What counts as full brightness, and how far down from it to draw.
+       *
+       * Both were fixed, and both had to stop being fixed once there was a
+       * frame with a Sun in it. The brightest thing any of these pictures can
+       * hold is one source's own cell — `mass·fade(HALF)` — and how far the
+       * field falls from there to the corner is set by how wide the frame is,
+       * since it goes as one over r². Three decades covers a fourteen-cell
+       * picture and blacks out most of a thirty-six-cell one.
+       *
+       * So the top of the scale is measured off the sources actually present
+       * and the range is worked out from the span. Which is auto-exposure, and
+       * it is a drawing decision — it is stated on the picture, and nothing
+       * downstream of it is a number this model claims.
+       */
+      let peak = 0;
+
+      for (const s of live) peak = Math.max(peak, (s.mass ?? 1) * fade(HALF));
+
+      const decades = decadesFor(span);
 
       for (let y = 0; y < rows; y++) {
         const wy = ((y + 0.5) * (h / rows) - h / 2) / scale;
@@ -849,10 +805,10 @@ export const MetricField = ({
         for (let x = 0; x < cols; x++) {
           const wx = ((x + 0.5) * (w / cols) - w / 2) / scale;
 
-          const v = Math.max(Math.min(fieldAt(wx, wy, t, live, reach, grain), 1), -1);
+          const v = fieldAt(wx, wy, t, live, grain);
 
           // Shown on a log scale — see `shown`, and the legend below.
-          const k = shown(v);
+          const k = shown(Math.max(Math.min(v / peak, 1), -1), decades);
           const i = (y * cols + x) * 4;
           const d = DITHER[(y & 3) * 4 + (x & 3)];
 
@@ -899,22 +855,16 @@ export const MetricField = ({
       ctx.imageSmoothingEnabled = true;
       ctx.drawImage(buf, 0, 0, w, h);
 
-      legend(ctx, w, h, brief
-        ? `too far out to resolve the arm — showing the path each has taken`
-        : `field 1/r², log over ${DECADES} decades · ${
-          grain < 0.05 ? 'spiral, drawn continuous'
-            : grain > 0.95 ? 'shells' : 'spiral fading to shells'}`);
-
-      // And the shape of the motion, which is what survives being drawn from
-      // far away — the same picture Newton's panel draws, so the two can be
-      // read against each other.
-      if (brief)
-        for (const s of live)
-          trail(ctx, s.path, x => w / 2 + x * scale, y => h / 2 + y * scale, 0.5);
+      legend(ctx, w, h, `field 1/r², log over ${decades} decades · ${
+        grain < 0.05 ? 'drawn continuous'
+          : grain > 0.95 ? 'shells' : 'fading to shells'}`);
 
-      for (const s of live)
-        source(ctx, w / 2 + s.at[0] * scale, h / 2 + s.at[1] * scale,
-          { halo: 14, dot: 2.2 });
+      // And where each has been, over the field it laid down getting there.
+      // Both, now, rather than one or the other: the waves are what the model
+      // says is happening and the path is what came of it, and a picture of a
+      // solar system wants to show that the orbit was traced THROUGH this.
+      paths();
+      dots();
     }
 
     return {
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
index eee5396..980fe5d 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
@@ -78,6 +78,18 @@ export type Model = {
    */
   newton?: Closed;
 
+  /**
+   * And what GENERAL RELATIVITY would do with it, between the two.
+   *
+   * Worth having beside Newton rather than instead of him, because everything
+   * here runs at a tenth to a third of the speed of light — see the note in
+   * `newton.tsx` for why that is forced rather than chosen — and at those
+   * speeds the two classical answers are visibly different curves. Which of
+   * them this model's own account lands nearer is the question the row of
+   * panels is asking.
+   */
+  relativity?: Closed;
+
   /**
    * Models drawn in the same block as this one, because they are the same
    * experiment asked twice: a line and its anti-line, an arrangement flat and
@@ -257,12 +269,19 @@ export const metricOf = (model: Model): Closed | undefined => {
   });
 };
 
-/** And what Newton makes of it, which is not a reading of this model at all. */
-export const newtonOf = (model: Model): Closed | undefined => {
-  if (!model.newton) return undefined;
+/**
+ * And what the two classical accounts make of it, neither of which is a
+ * reading of this model at all.
+ *
+ * Framed like the closed form unless told otherwise, for the same reason the
+ * metric reading is: panels of the same arrangement at different sizes are not
+ * a comparison.
+ */
+const against = (model: Model, own: Closed | undefined): Closed | undefined => {
+  if (!own) return undefined;
 
   const like = model.closed === false ? {} : (model.closed ?? {});
-  const given = { ...like, ...model.newton };
+  const given = { ...like, ...own };
 
   return reading<Closed, 'sources'>(given, 'sources', () => {
     const world = model.world;
@@ -271,3 +290,7 @@ export const newtonOf = (model: Model): Closed | undefined => {
     return sized(world, given.scale ?? 1).sources.map(emitterOf);
   });
 };
+
+export const newtonOf = (model: Model) => against(model, model.newton);
+
+export const relativityOf = (model: Model) => against(model, model.relativity);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
index a098025..ecbdc9a 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -1,9 +1,10 @@
+import { CYCLE } from "./lattice";
 import { LIGHT, PACE } from "./physics";
 import { bySide, Graph, perPoint } from "./discrete";
 import { Polarity, Source } from "./physics";
 import { RenderMode } from "./GraphCanvas";
 import { alternatingIntoRandom, collisionGroups, lineGroups } from "./lines";
-import { GRAVITY } from "./metric";
+import { GRAVITY } from "./gravity";
 import { APART, Model, NEAR } from "./model";
 
 /**
@@ -196,8 +197,13 @@ const worlds: Model[] = ([
   },
   {
     name: 'two sources, pulsing against each other',
-    note: 'Half a cycle apart: the midline is now where they always cancel, '
-      + 'so the same pair closes faster on the same rules.',
+    note: 'Half a cycle apart, so the midline is now where they always cancel '
+      + 'rather than where they always agree — which is the whole difference '
+      + 'in the picture. It is NOT a difference in how fast they close: at '
+      + 'this separation the two are several wavelengths apart and the phase '
+      + 'between them has averaged out, so both pairs pull identically. See '
+      + '`shortfall` — coherence is a near-field effect here, real inside one '
+      + 'wavelength and gone beyond it.',
     sources: [{ at: LEFT }, { at: RIGHT, phase: 0.5 }],
     metric: true,
     draw: asShells,
@@ -854,15 +860,37 @@ const lines: Model[] = [
  * close. (Dragonfly, at the values commonly quoted, came back only to 5e-2
  * over one period and is left out rather than presented as periodic.)
  *
- * The published conditions are in units where G, the masses and the extent
- * are all one; the two constants below put them into cells and ticks. Note
- * that scaling length and speed independently is not a Newtonian similarity
- * transform, so what is preserved here is the SHAPE of the initial condition
- * and not its Newtonian periodicity — which costs nothing, because the thing
- * being run is not Newtonian either.
+ * The published conditions are in units where G, the masses and the extent are
+ * all one, so putting them into cells and ticks is a similarity transform: a
+ * length scale S and a speed scale V, with G·m → S·V². And that leaves exactly
+ * one freedom, not two — pick the size, and the pace is whatever makes S·V²
+ * come to the gravitational constant this model actually has.
+ *
+ * Which is the whole point. `SWING` was 0.25, chosen so the pictures looked
+ * right, and `gm` was then handed `UNIT·SWING²` — a number invented out of two
+ * drawing decisions. So the Newtonian panel was calibrated against the model
+ * it was supposed to be judging, and the comparison could not fail. Solved for
+ * instead, the published orbit drawn beside this one is the published orbit AT
+ * THIS MODEL'S OWN STRENGTH, and whether the two curves agree is a question
+ * with an answer.
+ *
+ * Checked: at this scale, integrating Newton over one published period returns
+ * the figure eight to within 0.119 cells, Lagrange to 0.042 and Euler to 0.109,
+ * over periods of 2090, 2732 and 1856 ticks.
+ *
+ * The three from Suvakov and Dmitrasinovic do not come back, and the reason is
+ * worth knowing rather than hiding. Their closest approaches are 0.0106, 0.0794
+ * and 0.0180 in published units — which at this size is 0.38 cells for
+ * butterfly I and 0.65 for goggles, both INSIDE the half-cell the Newtonian
+ * panel softens at and well inside the one cell this model will not let two
+ * things come closer than. Those two pass closer than the lattice has anywhere
+ * to put them, and no account here can draw them, Newton's included. (Moth I,
+ * at 2.9 cells, is the one of the three that is genuinely resolvable.)
  */
-const UNIT = 18;      // cells per unit of the published solutions
-const SWING = 0.25;   // cells a tick per unit of their velocity
+const UNIT = 36;                          // cells per unit of the published solutions
+
+// And so the pace, solved rather than chosen — see above.
+const SWING = Math.sqrt(GRAVITY / UNIT);  // cells a tick per unit of their velocity
 
 // Three equal masses: two out at ±1 and one at the middle, the outer pair
 // given the same velocity and the middle one twice it the other way, so the
@@ -943,32 +971,453 @@ const KNOWN: { name: string, note: string, sources: Source[] }[] = [
   },
 ];
 
+// How long the benchmark runs get, and how wide they are framed. One published
+// period of the figure eight is about two thousand ticks at this size.
+const KNOWN_FOR = 2200;
+const KNOWN_SPAN = UNIT * 3;
+
 const known: Model[] = KNOWN.map(({ name, note, sources }) => ({
   name: `three bodies: ${name}`,
   note,
-  world: { sources },
+  world: { sources: sources.map(s => ({ ...s, settled: true })) },
   lattice: false,
 
-  // Only the metric reading, with what Newton expects beside it — the flow
-  // account is a third picture of the same thing and would only crowd the
+  // Only the metric reading, and the two classical ones beside it — the flow
+  // account is a fourth picture of the same thing and would only crowd the
   // comparison these are here for.
   closed: false,
-  // Newton, given the model's OWN gravitational constant — so the two panels
-  // are the same law with the same strength, and the only question left is
-  // whether that law traces the published curve.
-  newton: { span: UNIT * 2.6, cycle: 400, gm: GRAVITY },
-
-  // Far too wide to resolve a shell, so the picture says what it can
-  // carry: the path each has taken, drawn exactly as Newton's panel
-  // draws its own.
-  metric: { span: UNIT * 2.6, cycle: 400, summary: true },
+
+  // Newton and Einstein, both given the model's OWN gravitational constant —
+  // so all three panels are the same strength and the only question left is
+  // what each LAW does with it.
+  newton: { span: KNOWN_SPAN, cycle: KNOWN_FOR, rate: 60, gm: GRAVITY },
+  relativity: { span: KNOWN_SPAN, cycle: KNOWN_FOR, rate: 60, gm: GRAVITY },
+
+  // Far too wide to resolve a shell, so the picture says what it can carry:
+  // the path each has taken, drawn exactly as the classical panels draw theirs.
+  metric: { span: KNOWN_SPAN, cycle: KNOWN_FOR, rate: 60, summary: true },
 }));
 
+/**
+ * And the real thing: gravitating systems, in their own units.
+ *
+ * The three-body benchmarks above are shapes — published curves with G, the
+ * masses and the extent all set to one, so nothing in them is a length or a
+ * weight. These are the opposite. Every number below is measured: semi-major
+ * axes in astronomical units or hundreds of thousands of kilometres, standard
+ * gravitational parameters in the same units, circular speeds worked out from
+ * those and from nothing else. Two scales turn them into cells and ticks, and
+ * then the masses are not chosen either — a mass is whatever makes this
+ * model's own G reproduce the measured GM.
+ *
+ * Which is the only honest way to ask the question the article is for. A
+ * curve fitted at one scale says nothing; a solar system with the real mass
+ * ratios and the real speed ratios either comes out or it does not.
+ *
+ * One thing about the scales has to be said plainly, because it is a
+ * limitation and not a choice. An orbit worth watching must be tens of cells
+ * across and must come round inside a couple of thousand ticks, and a circle
+ * of radius R closed in time T is travelled at 2πR/T — so everything here runs
+ * between a twentieth and a tenth of the speed of light. The real Mercury goes
+ * at 0.00016 c. There is no scale at which this article can draw the solar
+ * system AND keep it non-relativistic, so what is drawn is a solar system with
+ * the right ratios and the wrong pace, and both classical panels are given the
+ * same wrong pace so that the comparison is still a comparison.
+ *
+ * It is also why the relativistic panel is here at all. At these speeds the
+ * two classical accounts are visibly different curves, and this model is a
+ * third — and the three come apart in an interesting way:
+ *
+ *     Newton         circles, by construction
+ *     Schwarzschild  perihelion a little INSIDE Newton's, going round FASTER
+ *     this model     apoapsis OUTSIDE Newton's, going round SLOWER
+ *
+ * So the model's departure is opposite in sign to relativity's, and larger.
+ * Both scale with speed the same way — Mercury departs most, Mars least — but
+ * gravity here WEAKENS on a body already moving (see `free`) where relativity
+ * strengthens it. That is a difference of principle rather than of amount, and
+ * these three pictures are where to look at it.
+ */
+const SUN = 39.4784176;                  // GM in AU^3/yr^2, for the Sun
+
+/**
+ * A gravitating system, given in real units and put into cells and ticks.
+ *
+ * `cells` and `ticks` are the only freedoms; everything else is measurement,
+ * and it is measurement at 1:1 — the real semi-major axes, the real
+ * eccentricities, the real orientations. Which is the whole point of having a
+ * solar system in the article rather than another arrangement chosen because
+ * it behaves, and it was not what this did.
+ *
+ * It put every body on a CIRCLE at its semi-major axis, which is a different
+ * solar system. Mercury's orbit is a fifth eccentric — it runs from 0.307 AU
+ * out to 0.467, half again as far at one end as the other — and Mars is a
+ * tenth. Drawn as circles, the panel that draws Newton correctly draws four
+ * circles, so there is nothing in the picture for the other two panels to
+ * disagree WITH; and the one thing this row of panels is for — where the
+ * perihelion goes, which is what was measured on Mercury and is the whole
+ * reason relativity is standing here — was not in the picture at all.
+ *
+ * So each is started at its perihelion, along its real longitude of
+ * perihelion, at the speed vis-viva gives there:
+ *
+ *     r_peri = a(1 − e)
+ *     v_peri = √( GM/a · (1 + e)/(1 − e) )
+ *
+ * which is exact for an ellipse rather than an approximation of one. The
+ * longitudes then lay the orbits round the frame the way they actually lie,
+ * instead of lining every body up on one axis.
+ *
+ * The mass conversion is the other piece worth reading. GM has units of
+ * length³ over time², so in cells and ticks it is `gm·cells³/ticks²` — and a
+ * mass here is that over `GRAVITY`, the constant this model was measured to
+ * have (see `gravity.ts`). Nothing is fitted. Feed it the Sun and it works out
+ * what the Sun weighs on a lattice.
+ *
+ * WHAT IS 1:1 HERE, checked rather than asserted. Every conversion above is
+ * one constant applied to everything, so every ratio survives it exactly. At
+ * 28 cells to the AU:
+ *
+ *     Mercury  0.38710 AU  ->  10.839 cells      28.0000 cells/AU
+ *     Venus    0.72333     ->  20.253            28.0000
+ *     Earth    1.00000     ->  28.000            28.0000
+ *     Mars     1.52371     ->  42.664            28.0000
+ *
+ * and the same for the masses — Mercury is 1.6601e−7 of the Sun in the sky and
+ * 1.6601e−7 of it here — and for the speeds, where Mercury is 1.60727 times
+ * Earth's in both. Distance, mass and speed are 1:1 to as many figures as the
+ * inputs have.
+ *
+ * ONE THING IS NOT, and it cannot be. Light travels one cell a tick by
+ * definition, which at this scale is 107 AU a year; the real figure is 63241.
+ * So the orbits here run 590 times fast against their own light — Earth at
+ * 0.0586 c where it should be 0.0000994 — and that is forced rather than
+ * chosen: a system drawn small enough to see and quick enough to watch is a
+ * system whose bodies cross a good fraction of a light-tick every tick. It is
+ * also exactly why the panels differ at all, since both relativity's
+ * correction and this model's go as v/c. What is being compared is three laws
+ * at the same wrong speed, which is a fair comparison, and not any of them at
+ * the right one.
+ */
+type Body = [
+  name: string, axis: number, eccentricity: number, perihelion: number, gm: number,
+];
+
+/**
+ * How slowly a body of a solar system turns over, in turns per `CYCLE` ticks.
+ *
+ * A body alternates at some rate and nothing in the model fixes it at the
+ * lattice's fastest — see `Spin.flips`. What it fixes is the picture: the
+ * pattern travels a cell a tick whatever the rate, so a body flipping every
+ * `P` ticks lays down bands `P` cells apart, and at `rate` ticks a second they
+ * cross a given place `rate/P` times a second.
+ *
+ * At the lattice's own pace, P is `CYCLE` — eight ticks — and any clock fast
+ * enough to carry a solar system through years of it strobes: a hundred and
+ * twenty ticks a second over a period of eight is fifteen hertz. Turning the
+ * clock down fixed the strobe and made the run crawl, which was trading one
+ * complaint for the other, because the two were tied together and had no
+ * business being.
+ *
+ * At one turn per `SLOW` ticks they come apart. The clock can run as fast as
+ * it likes; what is on screen is a front leaving every `SLOW` ticks and
+ * crossing the frame at a cell a tick, which is a wave you can watch.
+ *
+ * And it costs nothing in the dynamics, which is the part that has to be
+ * checked rather than assumed. `shortfall` reads the phase between two sources
+ * only where they are COHERENT — equal rates — and averages it away otherwise;
+ * beyond a wavelength the coherent answer converges to the same half anyway.
+ * Given a spread of rates (below) no two bodies here are coherent, so every
+ * pair uses the half exactly, which is what `GRAVITY` was measured against.
+ * Measured: identical orbits to six figures before and after.
+ */
+const SLOW = 96;
+
+const system = ({ cells, ticks, centre, around }: {
+  cells: number;                          // cells per unit of length
+  ticks: number;                          // ticks per unit of time
+  centre: number;                         // GM of the thing in the middle
+  around: Body[];
+}): Source[] => {
+  const scale = cells / ticks;            // real speed to cells a tick
+
+  /**
+   * And every body given its own rate, a few per cent apart.
+   *
+   * Not decoration. Two things alternating at exactly the same rate hold a
+   * fixed phase relation for ever, which is a real thing for two sources
+   * deliberately built alike and an absurd one for a star and a planet.
+   * Spread, they drift through every phase against each other — `drifting` in
+   * `shortfall` — and half of what they do is opposite, which is the aggregate
+   * answer and the one this model's G is calibrated on.
+   */
+  const flips = (i: number) => (CYCLE / SLOW) * (1 + 0.037 * i);
+
+  const orbiting = around.map(([, axis, e, perihelion, gm], i) => {
+    const turn = perihelion * Math.PI / 180;
+
+    // At perihelion, a(1 − e) out along the apsidal line.
+    const r = axis * (1 - e) * cells;
+
+    /**
+     * And the speed there, across that line — perihelion is where there is no
+     * radial velocity left to have.
+     *
+     * Two corrections, both of which only show for the Moon and both of which
+     * Newton's own panel caught.
+     *
+     * The ellipse a two-body pair traces is the RELATIVE orbit, so its
+     * constant is G(M + m) and not GM. For a planet at three millionths of the
+     * Sun that is six figures in; for the Moon at a part in eighty-one it is
+     * half a per cent on the speed and two and a half on the apogee, and the
+     * panel came back with 39.5 cells where the Moon's apogee is 40.6.
+     *
+     * And what that gives is the RELATIVE speed, which is not this body's.
+     * Split about the barycentre, the satellite carries M/(M + m) of it and
+     * the middle carries the rest the other way — see the recoil below. Given
+     * the whole of it and then recoiling as well, the pair separate at
+     * v(1 + m/M) and the apogee comes out long instead, which it did: 42.8.
+     */
+    const v = Math.sqrt((centre + gm) / axis * (1 + e) / (1 - e))
+      * (centre / (centre + gm)) * scale;
+
+    return {
+      at: [r * Math.cos(turn), r * Math.sin(turn)] as [number, number],
+      drift: [-v * Math.sin(turn), v * Math.cos(turn)] as [number, number],
+      mass: gm * cells ** 3 / ticks ** 2 / GRAVITY,
+      flips: flips(i + 1),
+      settled: true,
+    };
+  });
+
+  const heart = centre * cells ** 3 / ticks ** 2 / GRAVITY;
+
+  /**
+   * And the middle is given the recoil, so the whole thing stays where it is
+   * put.
+   *
+   * Otherwise the centre of mass drifts off at whatever the satellites' total
+   * momentum comes to divided by everything, and the picture slowly leaves the
+   * frame — which for the Earth and the Moon is not slow at all, since the
+   * Moon is a part in eighty-one rather than a part in a million.
+   *
+   * It is also the only way the wobble is in the picture. The Earth goes round
+   * the barycentre too, by a part in eighty-one of the Moon's orbit, and a
+   * two-body pair where only one end moves is not the two-body problem.
+   */
+  const kick = orbiting.reduce(
+    (sum, s) => [sum[0] - s.mass * s.drift[0], sum[1] - s.mass * s.drift[1]],
+    [0, 0],
+  );
+
+  return [
+    {
+      at: [0, 0],
+      drift: [kick[0] / heart, kick[1] / heart],
+      mass: heart,
+      flips: flips(0),
+      settled: true,
+    },
+    ...orbiting,
+  ];
+};
+
+const systems: Model[] = ([
+  {
+    name: 'the Sun and Mercury',
+    note: 'The same system as below with everything else taken out, framed on '
+      + 'the one orbit that is visibly an ellipse. Mercury\u2019s eccentricity is '
+      + '0.206, so it runs from 0.307 AU out to 0.467 \u2014 half again as far at '
+      + 'one end as the other \u2014 and here that is 20.0 cells to 30.4, which '
+      + 'is what Newton\u2019s panel draws against a true 20.0 to 30.3. Venus and '
+      + 'Earth really are all but circular (e = 0.007 and 0.017), so an inner '
+      + 'solar system drawn correctly is mostly circles and this is where the '
+      + 'shape is. It is also where relativity was measured: the perihelion '
+      + 'advance is Mercury\u2019s, and the three panels part company on exactly '
+      + 'that \u2014 Newton returns to the same perihelion, Schwarzschild carries '
+      + 'it forward, and this model carries it backward and opens the orbit '
+      + 'out to 39 cells.',
+    cells: 65, ticks: 12000, span: 44, cycle: 24000, rate: 600,
+    centre: SUN,
+    around: [['Mercury', 0.38710, 0.20563, 0, SUN * 1.66012e-7]],
+  },
+  {
+    name: 'the inner solar system',
+    note: 'The Sun, Mercury, Venus, Earth and Mars — real distances, real '
+      + 'eccentricities, real longitudes of perihelion, and the masses worked '
+      + 'out from this model\u2019s own G. Newton traces the four ellipses and '
+      + 'closes them; relativity advances each perihelion a little; this model '
+      + 'retards it and opens the orbit out. Mercury departs most in all three '
+      + 'panels, because it is both the fastest and the most eccentric, which '
+      + 'is why it was the one the perihelion was measured on \u2014 and why it '
+      + 'has a frame of its own above. Measured over the eleven thousand ticks '
+      + 'of this run: Mercury runs 8.6 to 13.2 cells and comes round 15.1 '
+      + 'times under Newton, 8.6 to 12.3 and 16.3 times under Schwarzschild, '
+      + 'and 8.6 to 20.5 and 8.9 times here. Venus and Earth are drawn as very '
+      + 'nearly circles because they very nearly are: their eccentricities are '
+      + '0.007 and 0.017.',
+    cells: 28, ticks: 3000, span: 66, cycle: 30000, rate: 600,
+    centre: SUN,
+    around: [
+      ['Mercury', 0.38710, 0.20563, 77.46, SUN * 1.66012e-7],
+      ['Venus', 0.72333, 0.00677, 131.60, SUN * 2.44784e-6],
+      ['Earth', 1.00000, 0.01671, 102.95, SUN * 3.00317e-6],
+      ['Mars', 1.52371, 0.09341, 336.06, SUN * 3.22716e-7],
+    ],
+  },
+  {
+    name: 'the entire solar system',
+    note: 'All eight, on the same ruler as the picture above \u2014 28 cells to '
+      + 'the AU \u2014 so Mercury is still 8.6 cells out at perihelion and '
+      + 'Neptune is 835. Which is what a solar system drawn at 1:1 looks '
+      + 'like: everything inside Jupiter is a smudge near the middle, and it '
+      + 'is not the picture that is wrong. Nothing outside Mars gets anywhere '
+      + 'in thirty-six thousand ticks either \u2014 that is twelve years here, '
+      + 'so Jupiter goes round once, Saturn a third of the way, and Neptune '
+      + 'through seven degrees of the hundred and sixty-five years it takes. '
+      + 'What the three panels have to disagree about is therefore all in the '
+      + 'inner four, and it is the same disagreement as above: Mercury opens '
+      + 'from 13.2 cells to 20.6 in this model and closes to 12.3 under '
+      + 'Schwarzschild, while Neptune at a hundredth of light does not '
+      + 'measurably differ in any of them.',
+    cells: 28, ticks: 3000, span: 900, cycle: 60000, rate: 900, height: 420,
+    centre: SUN,
+    around: [
+      ['Mercury', 0.38710, 0.20563, 77.46, SUN * 1.66012e-7],
+      ['Venus', 0.72333, 0.00677, 131.60, SUN * 2.44784e-6],
+      ['Earth', 1.00000, 0.01671, 102.95, SUN * 3.00317e-6],
+      ['Mars', 1.52371, 0.09341, 336.06, SUN * 3.22716e-7],
+      ['Jupiter', 5.20288, 0.04839, 14.73, SUN * 9.54792e-4],
+      ['Saturn', 9.53667, 0.05386, 92.60, SUN * 2.85886e-4],
+      ['Uranus', 19.18916, 0.04726, 170.96, SUN * 4.36624e-5],
+      ['Neptune', 30.06992, 0.00859, 44.97, SUN * 5.15139e-5],
+    ],
+  },
+  {
+    name: 'the Earth and the Moon',
+    note: 'Two bodies at eighty-one to one, in units of a hundred thousand '
+      + 'kilometres and days, with the Moon\u2019s real eccentricity of 0.055 — '
+      + 'so perigee and apogee differ by about a ninth, which is visible. The '
+      + 'one case here where both ends of the pair weigh something, so the '
+      + 'Earth is given the recoil and the barycentre stays put. It circles '
+      + 'that by a part in eighty-one of the Moon\u2019s orbit, which is half a '
+      + 'cell here and about a pixel \u2014 small, but it is why the relative '
+      + 'orbit goes against G(M + m) rather than GM, and Newton\u2019s panel '
+      + 'only returns the apogee to its true 40.6 cells once it does. The '
+      + 'model conserves the same momentum exactly, since what one end takes '
+      + 'up is the same count of meetings the other end does.',
+    cells: 10, ticks: 120, span: 60, cycle: 30000, rate: 600,
+    centre: 2.97600,                                 // GM in (10^5 km)^3/day^2, Earth
+    around: [['the Moon', 3.84400, 0.0549, 0, 2.97600 / 81.300]],
+  },
+  {
+    name: 'Jupiter and the Galilean moons',
+    note: 'A system with moons rather than planets, and the same rules again a '
+      + 'thousand times lighter. These four are very nearly circular — the '
+      + 'largest eccentricity here is a hundredth — so what there is to read is '
+      + 'not the shape but the timing. Io, Europa and Ganymede are in the '
+      + 'Laplace resonance, periods 1:2:4, which is the sharpest thing in the '
+      + 'article to check a law against: Newton holds it exactly, and this '
+      + 'model very nearly holds it while running every moon slow, which is '
+      + 'the signature of a weaker G rather than of a different distance law.',
+    cells: 2.6, ticks: 450, span: 66, cycle: 40000, rate: 600,
+    centre: 945.79,                                  // GM in (10^5 km)^3/day^2, Jupiter
+    around: [
+      ['Io', 4.2170, 0.0041, 0, 0.044496],
+      ['Europa', 6.7090, 0.0094, 0, 0.023911],
+      ['Ganymede', 10.7040, 0.0013, 90, 0.073828],
+      ['Callisto', 18.8270, 0.0074, 200, 0.053606],
+    ],
+  },
+] as {
+  name: string, note: string,
+  cells: number, ticks: number, span: number, cycle: number,
+  rate: number, height?: number,
+  centre: number, around: Body[],
+}[]).map((
+  { name, note, cells, ticks, span, cycle, rate, height, centre, around },
+): Model => {
+  const sources = system({ cells, ticks, centre, around });
+
+  /**
+   * And the pace, which is now free outright.
+   *
+   * It was tied to the wave twice over and is tied to nothing now. A source's
+   * charge reverses every `CYCLE/rate` ticks, so the field panel flickered at
+   * the clock over that; `SLOW` broke the first knot by making the pattern
+   * long, and taking the field out of these pictures altogether broke the
+   * second. What is drawn here is a path, and a path does not flicker.
+   *
+   * The other thing that used to make this a compromise was the integration:
+   * twelve sub-steps a FRAME meant a quicker clock was a coarser integration.
+   * Fixed at a quarter-tick STRIDE instead (see `metric.tsx`), the number of
+   * sub-steps follows the pace and the accuracy does not move — so the only
+   * cost of running faster is arithmetic per second, and the entire solar
+   * system, which has to carry Jupiter round, gets the most of it.
+   */
+  const framed = { span, cycle, rate, height };
+
+  return {
+    name,
+    note,
+    world: { sources },
+
+    // No lattice run: a ball with room for a solar system is more points than
+    // there are anything. And no flow reading, for the same reason as the
+    // benchmarks — three panels is already the comparison.
+    lattice: false,
+    closed: false,
+
+    newton: { ...framed, gm: GRAVITY },
+    relativity: { ...framed, gm: GRAVITY },
+
+    /**
+     * And the model's own panel draws the WAVES, not only the path.
+     *
+     * Which is the whole difference between this panel and the two beside it,
+     * and leaving it out made the row a comparison of three curves — three
+     * pictures of the same kind, where only one of them has anything of its
+     * own to show. There is no field in Newton's account and none in
+     * Einstein's; here the orbit is a consequence of what is drawn, and the
+     * shells crossing the frame are what is doing it.
+     *
+     * Said outright rather than left to the span, because at fifty-three cells
+     * the automatic reading would call it too wide — a rule about resolving a
+     * turning source's arm, and these do not turn. What they emit is a shell
+     * every `1/mass` ticks, and at planetary masses that is one shell in a
+     * frame and an aggregate everywhere else, which draws perfectly well.
+     */
+    /**
+     * And the model's panel draws the PATH, not the field.
+     *
+     * The field went in and came out again, and it is worth leaving the reason
+     * rather than the argument. There is a real thing it could show — the
+     * orbit here is a consequence of what a body emits, where Newton's and
+     * Einstein's are consequences of a law — but not at this scale and not
+     * with these masses. Drawn at equal brightness it says every body puts out
+     * as much as the Sun, which is false by six orders. Drawn by strength it
+     * says only the Sun is there, which is true and is a picture of one
+     * object. And whatever it is drawn as, the pattern travels a cell a tick,
+     * so at any clock fast enough to carry a solar system through years of
+     * itself the field is moving faster than it can be looked at.
+     *
+     * None of those is a rendering problem. They are three faces of the same
+     * fact: the wave is a light-tick across and the orbit is a hundred million
+     * of them, and one picture does not hold both. The wave pictures earlier
+     * in the article are where the field is drawn, at the scale it is a fact
+     * at; here what carries over is the shape of the motion, which is also
+     * what the two panels beside it can be compared against.
+     */
+    metric: { ...framed, summary: true },
+  };
+});
+
 /** Everything, in the order it is read in. */
 export const MODELS: Model[] = [
   ...blocks,
   ...worlds,
   ...closedOnly,
+  ...systems,
   ...known,
   ...lines,
 ];
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
index 902587f..58a456a 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
@@ -1,42 +1,63 @@
 /**
  * EQUATIONS IN THIS FILE
  *
- *   a_i  = Σ_{j≠i} G m_j (r_j − r_i) / (|r_j − r_i|² + soft²)^{3/2}
- *   velocity Verlet:
+ *   Newton:
+ *     a_i  = Σ_{j≠i} G m_j (r_j − r_i) / (|r_j − r_i|² + soft²)^{3/2}
+ *
+ *   Einstein, to the order that shows:
+ *     L    = |(r_j − r_i) × (v_i − v_j)|            angular momentum, per pair
+ *     a_i  = a_i^Newton · (1 + 3 L² / (c² |r_j − r_i|²))
+ *
+ *   which is the Schwarzschild orbit exactly, since
+ *     u'' + u = GM/L² + 3GM u²/c²                   with u = 1/r
+ *   and the extra term integrates to the perihelion advance
+ *     Δφ   = 6π GM / (c² a (1 − e²))                per orbit
+ *
+ *   velocity Verlet, for both:
  *     r' = r + v h + ½ a h²
  *     v' = v + ½ (a + a') h
  *
- *   units: the published solutions have G = m = extent = 1. Positions here
- *   are scaled by UNIT and velocities by SWING, and a Newtonian similarity
- *   transform with length S and speed V needs G m → S·V². So `gm` is
- *   UNIT·SWING² and the orbit drawn is the published one exactly, at this
- *   size and this pace.
+ *   units: the published three-body solutions have G = m = extent = 1, and a
+ *   Newtonian similarity transform with length S and speed V needs G m → S·V².
+ *   So `gm` is not chosen here — `models.ts` picks the length it wants and
+ *   solves for the speed that makes S·V² come to the model's OWN G. Which is
+ *   what makes this a comparison: the same constant on both sides.
  *
  */
 
 import { CanvasView, Surface } from "./canvas";
 import { Emitter } from "./field";
 import { ground, NEUTRAL, rgba, source, trail } from "./paint";
+import { LIGHT } from "./physics";
 
 /**
- * What Newton would do with the same arrangement.
+ * What Newton would do with the same arrangement — and what Einstein would.
  *
- * Not part of the model, and drawn beside it rather than as one of its
- * readings — this is the thing being compared AGAINST. The arrangements it is
- * given are published closed orbits of the equal-mass three-body problem, so
- * what it draws is a curve that is known to close, and any departure in the
- * panel beside it is the difference between a force that reaches across a gap
- * and a shortage of space that has to be eaten.
+ * Not a reading of this model, and drawn beside it rather than as one of its
+ * panels: these are the things being compared AGAINST. The arrangements they
+ * are given are published closed orbits of the equal-mass three-body problem
+ * and the actual solar system, so what the Newtonian panel draws is a curve
+ * that is known to close, and any departure in the panels beside it is a
+ * difference of law rather than of setup.
  *
- * Worth being plain about what a fair comparison is. This model has no force
- * and no long range; gravity acts only where two things are annihilating each
- * other's emissions, and a body that emits nothing feels nothing. So these
- * are not expected to agree, and the six are useful because they are six
- * different shapes rather than because any of them ought to come out.
+ * The relativistic panel matters here more than it usually would, and the
+ * reason is a fact about drawing orbits on a lattice rather than about
+ * gravity. An orbit worth watching has to be tens of cells across and has to
+ * come round inside a few hundred ticks, and a circle of radius R closed in
+ * time T is travelled at 2πR/T — so at forty cells and eight hundred ticks
+ * that is a third of the speed of light, and there is no choice about it. Put
+ * the same orbit at four cells or give it eighty thousand ticks and the
+ * picture is of nothing. So everything in this article is a relativistic
+ * orbit, whatever it is a picture of, and the gap between the two classical
+ * panels is wide enough to see.
+ *
+ * Which makes it the right question to ask of the model: not "is it Newton",
+ * which nothing at these speeds is, but WHERE between the two it falls.
  */
-export const NewtonField = ({
+export const ForceField = ({
   sources,
   gm = 1,
+  relativity = false,
   height = 320,
   span = 46,
   rate = 10,
@@ -44,27 +65,42 @@ export const NewtonField = ({
 }: {
   sources: Emitter[];
 
-  // G·m, in cells and ticks. See the units note above.
+  // G, in cells and ticks. See the units note above.
   gm?: number;
 
+  // Whether to add the leading relativistic term. Off, this is Newton exactly.
+  relativity?: boolean;
+
   span?: number;
   rate?: number;
   cycle?: number;
   height?: number;
 }) => <CanvasView
   height={height}
-  deps={[sources, gm, span, rate, cycle]}
+  deps={[sources, gm, relativity, span, rate, cycle]}
   paint={() => {
     // Softened at half a cell, which is the closest two things in this
     // article are ever allowed to be anyway — and without it a close pass
     // is a division by nothing.
     const SOFT = 0.5;
 
-    // How much of the path to keep, in samples. Enough for a whole period of
-    // the slowest of them.
-    const TRAIL = 5000;
+    /**
+     * How often to record where each of them is, in TICKS.
+     *
+     * Not every integrator step, which is what this did. A step is `dt/24` of
+     * a tick and `dt` follows the frame rate, so how much history the trail
+     * held depended on how fast the machine was drawing and on nothing else —
+     * and once these runs went to twelve thousand ticks, a five-thousand
+     * sample cap held the last few hundred ticks of a several-thousand-tick
+     * orbit. The curve being compared was a short arc near the body.
+     *
+     * Sampled against the clock instead, the whole run is kept whatever the
+     * frame rate, and `trail` walks it at whatever stride the canvas can use.
+     */
+    const EVERY = Math.max(cycle / 4000, 0.05);
 
     let t = 0;
+    let kept = 0;
     let at: [number, number][] = [];
     let vel: [number, number][] = [];
     let path: number[][] = [];
@@ -74,11 +110,12 @@ export const NewtonField = ({
       at = sources.map(s => [...s.at] as [number, number]);
       vel = sources.map(s => [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number]);
       path = sources.map((s, i) => [at[i][0], at[i][1]]);
+      kept = 0;
     };
 
     reset();
 
-    const pull = (r: [number, number][]) => r.map((ri, i) => {
+    const pull = (r: [number, number][], v: [number, number][]) => r.map((ri, i) => {
       let ax = 0, ay = 0;
 
       r.forEach((rj, j) => {
@@ -89,7 +126,38 @@ export const NewtonField = ({
 
         // Each pulls in proportion to what it weighs, exactly as it emits in
         // proportion to it on the other side of the comparison.
-        const k = gm * (sources[j].mass ?? 1) / (d * d * d);
+        let k = gm * (sources[j].mass ?? 1) / (d * d * d);
+
+        /**
+         * And the one correction that shows at these speeds.
+         *
+         * Schwarzschild's orbit differs from Newton's by a single term, and
+         * written as a force it is a factor: the pull is stronger by
+         * 3L²/(c²r²), where L is the angular momentum of the pair. Head-on it
+         * is nothing — L is nought, and a radial fall is Newtonian to this
+         * order — and it grows with how fast the two are going round each
+         * other and how close they are, which is why it is a perihelion
+         * effect and not a change to the distance law.
+         *
+         * Written this way it reproduces the standard result exactly rather
+         * than approximately: substituted into the orbit equation it gives
+         * u'' + u = GM/L² + 3GMu²/c², which is the Schwarzschild geodesic, and
+         * integrating the extra term over one orbit gives the
+         * 6πGM/(c²a(1−e²)) advance that was measured on Mercury.
+         *
+         * Summed pairwise for three bodies it stops being exact — the real
+         * thing at this order is Einstein–Infeld–Hoffmann, which has terms
+         * coupling all three at once — but the pairwise part is what dominates
+         * and it is what there is to draw.
+         */
+        if (relativity) {
+          const rx = -dx, ry = -dy;                       // from j to i
+          const wx = v[i][0] - v[j][0], wy = v[i][1] - v[j][1];
+
+          const spin = rx * wy - ry * wx;                 // |r × v|, signed
+
+          k *= 1 + 3 * (spin * spin) / (LIGHT * LIGHT * d * d);
+        }
 
         ax += dx * k; ay += dy * k;
       });
@@ -100,25 +168,28 @@ export const NewtonField = ({
     // Velocity Verlet, which keeps a closed orbit closed over a long run
     // where a plain Euler step would spiral out of it.
     const advance = (h: number) => {
-      const a = pull(at);
+      const a = pull(at, vel);
 
       at = at.map((ri, i) => [
         ri[0] + vel[i][0] * h + 0.5 * a[i][0] * h * h,
         ri[1] + vel[i][1] * h + 0.5 * a[i][1] * h * h,
       ]);
 
-      const a2 = pull(at);
+      const a2 = pull(at, vel);
 
       vel = vel.map((vi, i) => [
         vi[0] + 0.5 * (a[i][0] + a2[i][0]) * h,
         vi[1] + 0.5 * (a[i][1] + a2[i][1]) * h,
       ]);
 
-      at.forEach((p, i) => {
-        path[i].push(p[0], p[1]);
+    };
 
-        if (path[i].length > TRAIL * 2) path[i].splice(0, 2);
-      });
+    // Everywhere each of them has been, sampled against the clock.
+    const remember = () => {
+      while (kept < t / EVERY) {
+        kept++;
+        at.forEach((p, i) => path[i].push(p[0], p[1]));
+      }
     };
 
     function draw({ ctx, width: w, height: h }: Surface) {
@@ -130,7 +201,7 @@ export const NewtonField = ({
 
       // The path each has taken, which is the whole of what there is to
       // compare: a closed curve, or one that is not. Drawn by the same hand
-      // as the model's, so the two panels are the same kind of picture.
+      // as the model's, so the panels are the same kind of picture.
       for (const p of path) trail(ctx, p, sx, sy);
 
       for (const p of at) source(ctx, sx(p[0]), sy(p[1]), { halo: 14, dot: 2.2 });
@@ -138,7 +209,9 @@ export const NewtonField = ({
       ctx.font = "10px ui-monospace, SFMono-Regular, Menlo, monospace";
       ctx.textBaseline = "bottom";
       ctx.fillStyle = rgba(NEUTRAL, 0.55);
-      ctx.fillText(`Newton, G m = ${gm.toFixed(3)} — the published orbit`, 10, h - 8);
+      ctx.fillText(relativity
+        ? `Schwarzschild, G = ${gm.toFixed(3)} — Newton × (1 + 3L²/c²r²)`
+        : `Newton, G = ${gm.toFixed(3)}`, 10, h - 8);
     }
 
     return {
@@ -156,6 +229,8 @@ export const NewtonField = ({
           // through in strides.
           const n = 24;
           for (let k = 0; k < n; k++) advance(dt / n);
+
+          remember();
         }
 
         draw(surface);
@@ -163,3 +238,11 @@ export const NewtonField = ({
     };
   }}
 />;
+
+/** What Newton expects. */
+export const NewtonField = (props: Omit<Parameters<typeof ForceField>[0], 'relativity'>) =>
+  <ForceField {...props} relativity={false} />;
+
+/** And what general relativity expects, to the order that shows here. */
+export const RelativityField = (props: Omit<Parameters<typeof ForceField>[0], 'relativity'>) =>
+  <ForceField {...props} relativity />;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
index f8e5264..828e334 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/paint.ts
@@ -35,6 +35,7 @@ export const CYAN = [61, 220, 255];
 // Space that has not been charged by anything.
 export const NEUTRAL = [140, 147, 168];
 
+
 // A source, which is neither: everything charged came out of one of these, so
 // it is the one thing that isn't an event but a cause of them.
 export const SOURCE = [255, 224, 102];
@@ -139,11 +140,28 @@ export const source = (
  */
 export const DECADES = 3;
 
-const FLOOR = Math.pow(10, -DECADES);
-const TOP = Math.log(1 + 1 / FLOOR);
+/**
+ * And how many a given frame needs, which is a question about the frame.
+ *
+ * Three covers a pair from touching to the edge of a fourteen-cell picture,
+ * and that was every picture here until there were solar systems in the
+ * article. A frame thirty-six cells across spans (36/HALF)² in the field —
+ * nearly four decades — so drawn over three, everything past a third of the
+ * way out is below the floor and the picture is a bright dot on black.
+ *
+ * So it is worked out rather than fixed: enough decades to carry one over r²
+ * from the cell a source sits in to the corner of the frame, and never fewer
+ * than the three that were there before. Stated on the picture, as always,
+ * because a scale that is not stated is a claim.
+ */
+export const decadesFor = (span: number) =>
+  Math.max(DECADES, Math.ceil(2 * Math.log10(2 * Math.max(span, 1))));
 
-export const shown = (v: number) =>
-  Math.log(1 + Math.abs(v) / FLOOR) / TOP;
+export const shown = (v: number, decades = DECADES) => {
+  const floor = Math.pow(10, -decades);
+
+  return Math.log(1 + Math.abs(v) / floor) / Math.log(1 + 1 / floor);
+};
 
 /** Said on the picture, because a scale that is not stated is a claim. */
 export const legend = (
@@ -167,6 +185,13 @@ export const legend = (
  * compared anyway. Drawn the same way on both sides, so a closed curve beside
  * one that is not is a comparison and not two different kinds of picture.
  */
+// How many points of a path are worth stroking. A path kept at two samples a
+// tick over twelve thousand ticks is twenty-four thousand points, and a curve
+// a few hundred pixels wide has nowhere to put them — so it is walked at
+// whatever stride keeps it near this, and the last point is always included so
+// the trail reaches the thing that drew it.
+const STROKE = 2000;
+
 export const trail = (
   ctx: CanvasRenderingContext2D,
   path: number[],
@@ -174,19 +199,22 @@ export const trail = (
   sy: (y: number) => number,
   alpha = 0.32,
 ) => {
-  if (path.length < 4) return;
+  const points = path.length / 2;
+  if (points < 2) return;
+
+  const stride = Math.max(Math.floor(points / STROKE), 1) * 2;
 
   ctx.strokeStyle = rgba(HALO, alpha);
   ctx.lineWidth = 1.1;
   ctx.lineCap = "round";
 
   ctx.beginPath();
+  ctx.moveTo(sx(path[0]), sy(path[1]));
 
-  for (let k = 0; k < path.length; k += 2) {
-    const x = sx(path[k]), y = sy(path[k + 1]);
+  for (let k = stride; k < path.length; k += stride)
+    ctx.lineTo(sx(path[k]), sy(path[k + 1]));
 
-    if (k) ctx.lineTo(x, y); else ctx.moveTo(x, y);
-  }
+  ctx.lineTo(sx(path[path.length - 2]), sy(path[path.length - 1]));
 
   ctx.stroke();
   ctx.lineCap = "butt";
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
index c471ae8..e874ddf 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
@@ -330,11 +330,38 @@ export type Spin = {
    */
   turning?: number;
 
-  // Whether it alternates at all. A source that turns is already alternating
-  // and defaults to off; one that does not is a source with nothing to make a
-  // wave out of unless it flips, and defaults to on. Off for both is a magnet
-  // simply held, which puts out one steady stream per pole.
-  flips?: boolean;
+  /**
+   * Whether it alternates at all, and if so how fast.
+   *
+   * A source that turns is already alternating and defaults to off; one that
+   * does not is a source with nothing to make a wave out of unless it flips,
+   * and defaults to on. Off for both is a magnet simply held, which puts out
+   * one steady stream per pole.
+   *
+   * A NUMBER is how many times it turns over per `CYCLE` ticks, so one is as
+   * fast as anything here alternates — an eighth of a turn a tick, which is
+   * the smallest rotation this space has — and a fraction is slower. There is
+   * no such thing as faster, for the same reason `turnEvery` cannot go below
+   * one: anything quicker is not a faster alternation but a coarser one.
+   *
+   * Which matters for two reasons that have nothing to do with each other.
+   *
+   * A body's alternation sets the WAVELENGTH of what it puts out, and so how
+   * fast the picture of it moves: the pattern travels a cell a tick whatever
+   * it is, so a source flipping every `P` ticks lays down bands `P` cells
+   * apart and a viewer sees them go by at `rate/P` a second. At the lattice's
+   * own pace that is a strobe in any picture watched at a watchable speed, and
+   * the two demands — a clock that moves and a wave that can be looked at —
+   * are only separable because this can be turned down.
+   *
+   * And nothing makes two independent bodies alternate in step. Given
+   * different rates they drift through every phase against each other, which
+   * is what `shortfall` means by `drifting`, and half of everything they do
+   * is opposite. Which is also what the coherent calculation converges to
+   * beyond a wavelength — so at solar-system separations this changes the
+   * picture and does not change the pull.
+   */
+  flips?: boolean | number;
 
   // Where in the cycle it starts, in turns. The only thing one source can be
   // against another, and the reason two of them meeting are alike or
@@ -371,8 +398,15 @@ export const sided = (s: Spin) => !!(s.axis || s.turning);
  * same spacing. What separates them is not the clock. It is whether the state
  * the clock advances has a direction in it — see `sided`.
  */
-export const rate = (s: Spin): number =>
-  s.turning ?? ((s.flips ?? !s.turning) ? 1 : 0);
+export const rate = (s: Spin): number => {
+  if (s.turning !== undefined) return s.turning;
+
+  // How many turns per CYCLE, said outright — never more than one, which is
+  // as fast as this space alternates.
+  if (typeof s.flips === "number") return Math.min(Math.abs(s.flips), 1);
+
+  return (s.flips ?? true) ? 1 : 0;
+};
 
 /**
  * Where its north points at a given tick, in turns.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
index 52fb5c4..e47c0a9 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
@@ -6,8 +6,10 @@ import { ContinuousField } from "./continuous";
 import { Graph } from "./discrete";
 import { GraphCanvas } from "./GraphCanvas";
 import { MetricField } from "./metric";
-import { Closed, closedOf, Lattice, latticeOf, metricOf, Model, newtonOf } from "./model";
-import { NewtonField } from "./newton";
+import {
+  Closed, closedOf, Lattice, latticeOf, metricOf, Model, newtonOf, relativityOf,
+} from "./model";
+import { NewtonField, RelativityField } from "./newton";
 
 // The transport icons, which are the only things here that are only pictures.
 // Font Awesome Free v7.3.1 by @fontawesome — https://fontawesome.com/license/free
@@ -203,6 +205,11 @@ const MetricView = ({ sources = [], span, cycle, rate, summary, height = 320 }:
 const NewtonView = ({ sources = [], span, cycle, rate, gm, height = 320 }: Closed) =>
   <NewtonField sources={sources} span={span} cycle={cycle} rate={rate} gm={gm} height={height} />;
 
+const RelativityView = ({ sources = [], span, cycle, rate, gm, height = 320 }: Closed) =>
+  <RelativityField
+    sources={sources} span={span} cycle={cycle} rate={rate} gm={gm} height={height}
+  />;
+
 const Caption = ({ children }: { children: any }) => (
   <div style={{ color: '#8a8d99', fontSize: '0.8em', paddingTop: '0.6em' }}>{children}</div>
 );
@@ -232,8 +239,10 @@ export const ModelView = ({ model }: { model: Model }) => {
   const closed = closedOf(model);
   const metric = metricOf(model);
   const newton = newtonOf(model);
+  const einstein = relativityOf(model);
 
-  const readings = [lattice, closed, newton, metric].filter(Boolean).length;
+  const readings =
+    [lattice, closed, newton, einstein, metric].filter(Boolean).length;
   const many = readings > 1;
 
   // A run repeated, where the arrangement is a draw rather than a case.
@@ -261,6 +270,11 @@ export const ModelView = ({ model }: { model: Model }) => {
         <NewtonView {...newton} />
       </div> : null}
 
+      {einstein ? <div>
+        {many ? <Label>what general relativity expects</Label> : null}
+        <RelativityView {...einstein} />
+      </div> : null}
+
       {metric ? <div>
         {many ? <Label>written down — gravity as a metric</Label> : null}
         <MetricView {...metric} />

From 88a42dade0dbc7e0c3dbbcf42b715aa6fbb7c296 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sun, 9 Aug 2026 12:00:46 +0200
Subject: [PATCH 19/47] Change dependence on free

---
 .../2026.RayCalculiAndPhysics/gravity.ts      | 331 +++++++++++-------
 .../2026.RayCalculiAndPhysics/metric.tsx      | 107 +++---
 .../2026.RayCalculiAndPhysics/models.ts       |  72 ++--
 3 files changed, 317 insertions(+), 193 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index 31c460b..0a4fa01 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -7,19 +7,18 @@
  *   S(a,b)      = BITE ∫₀^R chance(m_a,s)·chance(m_b,R−s)·opposed·screen ds
  *                                                 meetings a tick along a→b
  *
- *   drawn(n)    = LIGHT · n / (SHEET + n)         what a count of n comes to
- *   free(v)     = (1 − v/LIGHT)² / SHEET          ... and so what one more buys
- *                                                 (the same law, differentiated
- *                                                 and rewritten in the speed)
+ *   BIAS        = LIGHT / SHEET                   what one annihilation buys
+ *   pace(u)     = u / √(1 + |u|²/LIGHT²)          what a count comes to as a
+ *                                                 speed in the picture
  *
- *   u̇_a         = free(|v_a|) · S(a,b) / m_a      the pull, per body, per tick
+ *   u̇_a         = BIAS · S(a,b) / m_a             the pull, per body, per tick
  *
- *   G           = S(1,1) · free(0) · R²           measured off the above, once
+ *   G           = SHEET / (4π² · HALF)            the far-field constant, in
+ *                                                 closed form — not calibrated
  *
  */
 
-import { chance, Live, SHEET, through } from "./field";
-import { SPIN } from "./lattice";
+import { chance, HALF, Live, SHEET, through } from "./field";
 import { BITE, LIGHT } from "./physics";
 
 /**
@@ -52,82 +51,96 @@ import { BITE, LIGHT } from "./physics";
  *
  *     weight of the way it went      1 + n
  *     weight of each other way       1,  and there are SHEET of them
- *     share going that way           (1 + n) / (SHEET + n)
- *     share coming back              1 / (SHEET + n)
- *     net drift                      LIGHT · n / (SHEET + n)
- *
- * Read the two ends of that.
- *
- * At small n it is LIGHT·n/SHEET — LINEAR in the count. So the drift is
- * proportional to the number of annihilations ACCUMULATED, and its rate of
- * change is proportional to the rate they are happening at. That is the answer
- * to the one thing this file could not previously derive: a shortage of space
- * gives cells per tick, which was being used as an acceleration with an
- * unexplained one-over-time in between. There is no extra one-over-time. The
- * shortage is a rate of change of a DENSITY, the density is what sets the
- * drift, and the drift's derivative is therefore the shortage. Gravity is an
- * acceleration because space remembers.
- *
- * At large n it goes to LIGHT and stops. Nothing can be biased more than
- * completely — every path already goes that way — so the ceiling is a fact
- * about counting rather than a clamp, and the `min(carry, LIGHT)` that used to
- * sit at the bottom of `spend` is gone with nothing put in its place. Where
- * the ceiling starts to bind is where this model stops agreeing with Newton,
- * and it binds when n approaches SHEET, which is to say deep in a strong
- * field. That is where the departure belongs.
+ *     net bias                       LIGHT · n / SHEET
+ *
+ * LINEAR in the count, with nothing in it about how fast the thing is already
+ * going. So the bias is proportional to the number of annihilations
+ * ACCUMULATED, and its rate of change is proportional to the rate they are
+ * happening at — which is why a shortage of space is an ACCELERATION and not a
+ * speed, and it is the whole of the one-over-time this file could not
+ * previously account for. Gravity is an acceleration because space remembers.
+ *
+ * This is the only constant in the dynamics, and it is a ratio of two counts.
  */
-export const drawn = (n: number) => LIGHT * n / (SHEET + n);
+export const BIAS = LIGHT / SHEET;
 
 /**
- * And so: how much of a body's path count is still FREE to be biased.
- *
- * `drawn` says what a count comes to as a drift. What the dynamics need is the
- * other direction — given a thing already drifting at v, what does the NEXT
- * annihilation buy? That is the slope of `drawn`, and it has an exact closed
- * form in terms of the speed rather than the count, because the two are the
- * same statement:
- *
- *     v = LIGHT·n/(SHEET + n)     ⟺     SHEET + n = SHEET/(1 − v/LIGHT)
- *     dv/dn = LIGHT·SHEET/(SHEET + n)²  =  (1 − v/LIGHT)² / SHEET
- *
- * So the marginal gain is `(1 − v/c)²/SHEET`, and reading it that way rather
- * than as a function of the count is not a rearrangement — it is a decision,
- * and worth being plain about which.
- *
- * Taken as a function of the accumulated ANNIHILATION count alone, the model
- * has to keep a ledger per body, and the ledger's zero is wherever the run
- * happened to start. Which is not a fact about anything: a body drifting past
- * at half of light and a body sitting still have the same empty ledger, and
- * the model would say they are equally easy to move. Worse, measured, it is
- * actively wrong — the ledger's magnitude saturates while its DIRECTION keeps
- * turning, so the response along the pull and the response across it come out
- * with different gains, and that difference pumps a circular orbit into an
- * eccentric one and then into the middle. A pair started on a circle at forty
- * cells came in to nine and went round twelve hundred degrees where Newton
- * went round seven hundred and twenty on a circle.
- *
- * Read as a function of the SPEED, all of that goes away and the statement
- * gets better. There is one budget of paths, and moving spends it just as
- * gravitating does: a thing already going at v has committed v/c of its paths
- * to going where it is going, and only what is left can be bent. Which is the
- * model's own account of what movement IS (see `massFor` — mass is the cost of
- * going somewhere, in paths) rather than a second mechanism bolted beside it.
- *
- * What it predicts, and it is a real prediction rather than a correction:
- *
- *   at rest        1/SHEET exactly, so Newton, with no free parameter
- *   at 0.1 c       19% weaker than Newton
- *   at c           NOTHING. Light does not fall.
- *
- * That last one is where this model and general relativity part company on
- * something that has been measured, and it is stated here rather than buried:
- * light bends round the sun, and nothing in this account bends it. Whatever is
- * right about the counting, that is what it owes.
+ * And what a bias comes to as a speed IN THE PICTURE — which is not the same
+ * number, and the difference between them is where this file used to be wrong.
+ *
+ * `BIAS` says how much a count leans a path. What it does not say is per WHOSE
+ * tick, and there is only one honest answer: the counting happens on the
+ * body's own worldline, so `LIGHT·n/SHEET` is cells per tick OF THE BODY'S OWN
+ * CLOCK. Which is a proper velocity, not a coordinate one, and turning it into
+ * what the picture shows is one line of arithmetic that the model does not get
+ * to choose:
+ *
+ *     v = u / √(1 + |u|²/c²)
+ *
+ * Nothing is stipulated by that and nothing is clamped. The ceiling at LIGHT
+ * is still a fact about counting rather than a rule — a count of any size is
+ * allowed, and the picture simply cannot show more than a cell a tick of it —
+ * but it is now the ceiling arithmetic actually has rather than a second
+ * saturation invented beside it.
+ *
+ * WHAT THIS REPLACES, and why, because it was the largest error in the model.
+ *
+ * The count used to be read as the coordinate drift directly, `LIGHT·n/(SHEET
+ * + n)`, and the dynamics then needed the slope of that — how much the NEXT
+ * annihilation buys a thing already moving — which came out as
+ * `(1 − v/c)²/SHEET` and was applied at each body's speed in the frame the
+ * canvas happens to be drawn in. Three things were wrong with it at once:
+ *
+ *  - It is FIRST order in v/c. Anything relativistic is even in v, and a first
+ *    order term is c/v times too big: on the Sun–Mercury panel it weakened
+ *    gravity by 13% at perihelion and 9% at aphelion, against relativity's 4%.
+ *
+ *  - It reads a COORDINATE speed, so it is not a fact about the pair. Boosting
+ *    the whole arrangement sideways — which changes nothing — changed the
+ *    orbit: measured on Sun and Mercury, an apoapsis of 39.9 cells at rest,
+ *    86.3 boosted by a fiftieth of light, and 352 by a twentieth.
+ *
+ *  - Being a velocity-dependent scaling of a central pull it does net work
+ *    round an orbit, so the orbit OPENED rather than merely precessing — which
+ *    is what the 39.9 above is against Newton's 30.4.
+ *
+ * All three go away here, and the objection that sent the model down that road
+ * in the first place goes with them. The worry was that a ledger has an
+ * arbitrary zero — that a body drifting past at half of light and a body
+ * sitting still both start the run with an empty one. They do not. A body
+ * already going at v arrived there by having been biased, and its opening
+ * count is exactly `n = SHEET·γv/c`. The initial drift is not a free parameter
+ * standing beside the ledger; it IS a ledger reading, and saying so is what
+ * makes the count the honest variable.
+ *
+ * What comes out, unstated and unfitted, is the rest of it. Differentiating
+ * the line above gives `dv/du = 1/γ³` along the way a thing is going and
+ * `1/γ` across it — the longitudinal and transverse response of special
+ * relativity, exactly, arrived at from a count of ways out of a point. And the
+ * perihelion advance that leaves on Mercury is +0.56° an orbit against
+ * Schwarzschild's +3.21°: prograde, same sign, and 0.176 of it, which is the
+ * one sixth that relativistic momentum alone has always given.
+ *
+ * WHAT IT STILL OWES, stated here rather than buried. At v = c the count is
+ * infinite, so a finite one more does not turn it: light does not fall, and it
+ * bends round the sun. What that costs is one identifiable thing rather than
+ * the whole account — `shortfall` couples to the rest masses, and an emission
+ * rate standing for ENERGY rather than for rest mass would deflect light by
+ * 2GM/bc². Which is half of what was measured, and getting the other half
+ * needs a metric's spatial part that a model counting one number per place
+ * does not have.
  */
-export const free = (speed: number) => {
-  const left = Math.max(1 - speed / LIGHT, 0);
+export const pace = (ux: number, uy: number): [number, number] => {
+  const g = Math.sqrt(1 + (ux * ux + uy * uy) / (LIGHT * LIGHT));
+
+  return [ux / g, uy / g];
+};
+
+/** And back: what a stated course is, as a count. See `pace`. */
+export const count = (vx: number, vy: number): [number, number] => {
+  const g = 1 / Math.sqrt(Math.max(1 - (vx * vx + vy * vy) / (LIGHT * LIGHT), 1e-12));
 
-  return left * left / SHEET;
+  return [vx * g, vy * g];
 };
 
 /**
@@ -161,10 +174,24 @@ export const free = (speed: number) => {
  *     even, 0.25  −0.89%  −0.92%  −0.94%  −0.95%  −0.96%  −0.96%
  *     this        −0.00%  +0.05%  +0.11%  −0.13%  +0.01%  −0.73%
  *
- * `GRAVITY` is measured through the same function, so correcting the bias
- * moves the constant with it and nothing downstream notices.
+ * WITH ONE THING TO WATCH, which the table above is too short to show. The
+ * whole of the inverse square comes from the last half-cell at either end (see
+ * `GRAVITY`), so the walk is only worth anything while it puts samples IN that
+ * half-cell — and the substitution crowds them there quadratically, `x ≈
+ * Rθ²/4`, so the number that land inside `HALF` goes as `N/√R` and thins out
+ * as the pair separate. At a fixed 256 it holds to a part in five hundred out
+ * to about a thousand cells and then falls apart completely: measured against
+ * a converged integral, 0.5% low at ten thousand and TEN TIMES low at a
+ * million. Neptune is 835 cells from the Sun in the widest panel here, which
+ * is close enough to the edge to have been worth finding.
+ *
+ * So the count is set by the thing that actually decides it — how many samples
+ * fall in the core — rather than fixed. Eight of them is `4π√(R/HALF)`, and
+ * with that it holds to two parts in a thousand at every separation tried up
+ * to a million cells, while nothing under six hundred pays anything at all.
  */
-const WALK = 256;
+const WALK = (R: number) =>
+  Math.max(256, Math.ceil(4 * Math.PI * Math.sqrt(R / HALF)));
 
 // One whole turn.
 const TURN_ROUND = Math.PI * 2;
@@ -242,7 +269,7 @@ export const shortfall = (
   const R = Math.hypot(dx, dy);
   if (R < 1e-9) return 0;
 
-  const steps = WALK;
+  const steps = WALK(R);
 
   // x = R(1 − cos θ)/2, so dx = R·sin θ/2 · dθ — see `WALK`.
   const dtheta = Math.PI / steps;
@@ -272,18 +299,38 @@ export const shortfall = (
    * spread is widest where the shell is nearest — which is to say, at the ends.
    *
    * So the phase is averaged over the line rather than read off it: every path
-   * difference between +ωR and −ωR occurs, equally, and the fraction opposite
-   * is the mean over all of them. Which is smooth, and behaves the way
-   * coherence ought to:
+   * difference between +ωR and −ωR occurs, and the fraction opposite is the
+   * mean over them.
+   *
+   * WEIGHTED, though, and not flat, which is the part that had to be got right
+   * a second time. A flat average is a hard window on the path difference —
+   * every value in [−ωR, +ωR] counting the same and everything outside it
+   * counting nothing — and a hard window does not converge, it RINGS. What is
+   * left of it goes as one over ωR and oscillates in R with the period of the
+   * pattern, so the pull between two sources alternating at the same rate
+   * still rippled by ±4.5% every four cells at solar separations. Which is not
+   * a force law, and it hid from the previous measurement for the same reason
+   * it hid from the one before that: the separations tried were multiples of
+   * the cycle, and the ripple is exactly nought there. The calibration
+   * separation was one of them.
+   *
+   * The window's own argument says it should not be flat anyway. The extremes
+   * of the range are the two endpoints, which is to say the two sources
+   * themselves, and those are precisely where a straight-line path difference
+   * means least — the shell is nearest, so the spread of real paths arriving
+   * is widest, so the straight line is the worst sample of it there. A raised
+   * cosine says that and nothing more: full weight in the middle, nothing at
+   * the ends, no parameter.
    *
    *     R (cells)      1      2      4      8     16     32
-   *     in step        0.13   0.25   0.50   0.50   0.50   0.50
-   *     half a cycle   0.88   0.75   0.50   0.50   0.50   0.50
+   *     in step        0.07   0.15   0.30   0.50   0.50   0.50
+   *     half a cycle   0.93   0.85   0.70   0.50   0.50   0.50
    *
-   * — a real, strong effect inside one wavelength, gone beyond it. Two things
-   * a long way apart cannot be in step in any way that matters, and the model
-   * now says so rather than pretending to know their separation to within a
-   * wavelength.
+   * — a real, strong effect inside one wavelength, gone beyond it, and gone
+   * SMOOTHLY: the residual ripple over R from twenty to thirty-four cells
+   * falls from 8.45% of the share to 0.32%. Two things a long way apart cannot
+   * be in step in any way that matters, and the model now actually says so
+   * rather than saying it on average and oscillating about it.
    *
    * Sources turning at DIFFERENT rates never had a fixed relation to average
    * in the first place, and go straight to a half.
@@ -293,15 +340,21 @@ export const shortfall = (
   let share = 0.5;
 
   if (!drifting) {
-    let sum = 0;
-
-    // Evenly, unlike the walk below: this is an average over path
-    // DIFFERENCES, and every one of them is meant to count the same.
-    for (let k = 0; k < steps; k++)
-      sum += opposed(
-        one.omega * (R - 2 * ((k + 0.5) / steps) * R) + (one.phase - two.phase));
+    let sum = 0, weight = 0;
+
+    // Evenly in the path difference, unlike the walk below: this is an average
+    // over path DIFFERENCES and not over places on the line. The weight is the
+    // window, not a measure.
+    for (let k = 0; k < steps; k++) {
+      const f = (k + 0.5) / steps;
+      const w = 0.5 - 0.5 * Math.cos(TURN_ROUND * f);
+
+      sum += w * opposed(
+        one.omega * (R - 2 * f * R) + (one.phase - two.phase));
+      weight += w;
+    }
 
-    share = sum / steps;
+    share = sum / weight;
   }
 
   /**
@@ -382,35 +435,60 @@ export const shortfall = (
    *
    * What comes out is a COUNT: meetings along this line this tick. Not a
    * speed, not an acceleration — a number of events. What it does to anything
-   * is settled in `drawn`, where the count becomes a density and the density
-   * becomes a drift, and the extra one-over-time this file could not previously
-   * account for turns out to be the difference between the two.
+   * is settled in `BIAS` and `pace`, where the count becomes a density and the
+   * density becomes a drift, and the extra one-over-time this file could not
+   * previously account for turns out to be the difference between the two.
    */
   return BITE * met * share * dt;
 };
 
 /**
- * The gravitational constant this model HAS, for two unit masses.
+ * The gravitational constant this model HAS, for two unit masses — in closed
+ * form, and far from either of them.
  *
- * Not a number put in — a number that comes out, measured off the model's own
- * pull at a reference separation. `a_rel = 2·G·m/R²` is the definition, so
- * this is that read backwards, once, at load.
+ * Not a number put in and, now, not a number measured off a run either. `a_rel
+ * = 2·G·m/R²` is the definition; two unit masses a distance R apart meet S
+ * times a tick along the line between them; each has its OWN emission to bias,
+ * m of it, so the count per path is S/m each and the bias that comes to is
+ * `BIAS·S/m`. So
  *
- * Which is what makes the Newtonian panel beside these an actual comparison.
- * It used to be handed `UNIT·SWING²`, a number invented out of two scaling
- * choices — so the question it asked was "does the model match a Newton
- * calibrated against the model", which nothing can fail. Handed this, it asks
- * whether the model's OWN constant produces the published orbits, which
- * something can.
+ *     a_rel = BIAS·S·(1/m_a + 1/m_b)   =   G·(m_a + m_b) / R²
  *
- * Two unit masses a distance R apart meet S times a tick along the line
- * between them. Each of them has its OWN emission to bias — m of it — so the
- * count per path is S/m each, and the drift that comes to is LIGHT·(S/m)/SHEET
- * while the field is weak. So
+ * and for two unit masses G = S·BIAS·R². What is new is that the limit of that
+ * as R grows can be written down rather than sampled, because the whole of the
+ * inverse square comes from the two ends of the walk and nowhere else:
  *
- *     a_rel = LIGHT·S·(1/m_a + 1/m_b) / SHEET   =   G·(m_a + m_b) / R²
+ *     far from a, chance(b, R − x) is flat at m_b·SHEET/(4πR²)
+ *     ∫₀^∞ chance(m_a, x) dx = m_a·SHEET/(4π) · 2/HALF     ... the core, twice
+ *     two ends, BITE a meeting, half of them opposite
  *
- * and for two unit masses that reads G = S·LIGHT·R²/SHEET, which is this.
+ *     G = BITE·½·2 · (SHEET/4π)(2/HALF) · (SHEET/4π) · BIAS = SHEET/(4π²·HALF)
+ *
+ * — 0.405285, and checked against the integral itself at a converged sample
+ * count out to a million cells, where it agrees to two parts in a thousand.
+ *
+ * WHICH IS THE HONEST CONSTANT AND THE OTHER ONE WAS NOT, and the difference
+ * matters more than its size. `shortfall` is not exactly inverse square: the
+ * ends of the walk give the 1/R² and the middle of it adds a cross term, so
+ * the pull measured as `S·R²` runs
+ *
+ *     R        24     32     48     64    100    200    → ∞
+ *     G(R)   1.085  1.070  1.052  1.044  1.033  1.018  1.000  × this
+ *
+ * — an excess of about (0.54·ln R + 0.23)/R, which is a real short-range
+ * prediction of the model and decays only as fast as that. It is NOT the
+ * `max(r, HALF)` core: a smooth core of the same size gives the same curve.
+ *
+ * This used to be evaluated at R = 32 and handed to `newton.tsx` as "the
+ * model's own G", which meant the comparison panel was given the one value the
+ * model has at exactly one separation — 7% above the law it is being compared
+ * against, at a separation nothing in the article actually orbits at, and on a
+ * node of the coherence ripple that used to sit on top of it. Taking the limit
+ * instead puts the constant where a constant belongs and leaves the r-
+ * dependence in the open, as the thing to look for rather than the thing
+ * folded into the calibration. On Sun and Mercury it is worth +10.2° of
+ * perihelion advance an orbit, against relativity's +3.2°, and it is now the
+ * model's largest stated departure rather than its largest hidden one.
  *
  * The `(m_a + m_b)` is not arranged for and is the thing worth checking twice,
  * because the previous split — share the shortfall between the two in
@@ -423,17 +501,4 @@ export const shortfall = (
  * FRACTION of your paths that got biased, and a heavier thing brought
  * proportionally more paths to the meeting.
  */
-export const GRAVITY = (() => {
-  const R = 32;
-
-  const held = (x: number, phase: number) => ({
-    at: [x, 0], vel: [0, 0], path: [x, 0],
-    lobes: 0, omega: SPIN, phase, beat: 1, mass: 1,
-  } as unknown as Live);
-
-  const pair = [held(-R / 2, 0), held(R / 2, 0)];
-
-  // At rest `free` is exactly 1/SHEET, so this is the pull two motionless
-  // unit masses have — which is what a gravitational constant is.
-  return shortfall(pair[0], pair[1], pair, 1) * free(0) * R * R;
-})();
+export const GRAVITY = SHEET / (4 * Math.PI * Math.PI * HALF);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
index 407ef67..845fab5 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
@@ -8,34 +8,42 @@
  *                                                 meetings a tick along a→b
  *
  *   the density of space, which is the whole of gravity here:
- *     u        = LIGHT · n / (SHEET + n)          what a count of n comes to
- *     free(v)  = (1 − v/LIGHT)² / SHEET           ... and so what one more buys
- *     u̇_a      = free(|v_a|) · S(a,b) / m_a       the pull, per body, per tick
- *     ṙ_a      = v_a + u_a                        its own course, plus that
+ *     u_a       = own_a + pulled_a                its count, in cells a tick of
+ *                                                 ITS OWN clock
+ *     u̇_a      = BIAS · S(a,b) / m_a             the pull, per body, per tick
+ *     ṙ_a      = pace(u_a) = u_a/√(1 + |u_a|²)   ... and what that comes to
+ *                                                 as a speed in the picture
  *
  *   An annihilation leaves the space where it happened denser: the next path
  *   out of that point is twice as likely to go the way it went, a second one
  *   makes it three to one, a third four. So a direction carrying n of them
- *   weighs 1 + n against the SHEET ways out that weigh one each, and the share
- *   of paths taking it over the share coming back is n / (SHEET + n).
+ *   weighs 1 + n against the SHEET ways out that weigh one each, and what that
+ *   leans a path by is LIGHT·n/SHEET — linear, with no ceiling in it.
  *
  *   Everything else here falls out of that, and none of it is stated:
  *
- *     at rest     free(0) = 1/SHEET               NEWTON, with no free constant
+ *     BIAS        one annihilation buys LIGHT/SHEET, whatever else is going on
+ *                 — so at rest, NEWTON, with no free constant
  *     u̇ ∝ ṅ      a shortage of space is an ACCELERATION and not a speed,
  *                 because what accumulates is the count and what drifts is a
  *                 function of the count. That is the one-over-time this file
  *                 could not previously account for.
- *     at speed    free(v) → 0 as v → LIGHT        gravity weakens on a body
- *                 already moving, because moving spends the same budget of
- *                 paths that being pulled does. At light speed there is
- *                 nothing left and light does not fall — which relativity says
- *                 otherwise, and it has been measured. See `free`.
+ *     at speed    the count is per tick of the BODY'S clock, so `pace` is what
+ *                 the picture sees. Differentiated, that is 1/γ³ along the way
+ *                 it is going and 1/γ across — special relativity's own
+ *                 response, out of a count of ways out of a point, and it puts
+ *                 Mercury's perihelion +0.56° an orbit against Schwarzschild's
+ *                 +3.21°: same sign, one sixth the size. See `pace`.
  *     ÷ m_a       a_a ∝ m_b/R², a_b ∝ m_a/R²      the equivalence principle:
  *                 heavier things have proportionally more paths to bias, so
  *                 the same fraction of them bends. Inertia IS path count.
  *
- *   G           = S(1,1) · free(0) · R²           measured off the above, once
+ *   G           = SHEET / (4π²·HALF)              the far-field limit, closed
+ *                                                 form. `S·R²` is 8.5% above
+ *                                                 it at 24 cells and decays as
+ *                                                 ln R/R — the model's largest
+ *                                                 departure, and now a stated
+ *                                                 one. See `GRAVITY`.
  *
  *   the picture only (φ drives nothing — see `spaceStep`):
  *     φ(x)      = max(−K·S(x)·dt, −1/4)           where space is going
@@ -49,7 +57,7 @@ import { CanvasView, Surface } from "./canvas";
 import {
   Emitter, fade, grainAt, HALF, Live, sparse, WAY, emit, fieldAt, TRAIL,
 } from "./field";
-import { free, shortfall } from "./gravity";
+import { BIAS, count, pace, shortfall } from "./gravity";
 import { CYCLE, SPIN, TAU } from "./lattice";
 import {
   AMBER, BACKGROUND, CYAN, decadesFor, ground, legend, lift, shown, source,
@@ -302,8 +310,8 @@ export const apart = (
  *
  * What replaced them is smaller and says the same thing without a grid in the
  * middle: a body goes the way it was going, plus however much the space around
- * it has been biased (`drawn`). One velocity, made of two parts, and the
- * second part is the whole of gravity.
+ * it has been biased. One count, made of two parts (`own` and `pulled`), and
+ * the second part is the whole of gravity.
  */
 
 /**
@@ -402,15 +410,23 @@ export const MetricField = ({
 
     /**
      * `pulled` is how much the space around this body has been biased into
-     * carrying it — a velocity, and the whole of what gravity does here.
+     * carrying it, and `own` is the course it was sent on — both as COUNTS,
+     * which is to say in cells per tick of the body's own clock.
      *
-     * It is not a force having been applied. It is the running count of
-     * annihilations, turned into a drift by `drawn`, and accumulated with the
-     * marginal gain `free` gives at whatever speed the body has already
-     * reached. Which is why it accelerates rather than merely displaces: the
-     * count persists, and the drift is a function of the count.
+     * Neither is a force having been applied. `pulled` is the running tally of
+     * annihilations and nothing else; `own` is the same quantity read off the
+     * drift the source was given, because a body already going somewhere got
+     * there by having been biased and its opening tally is not empty (see
+     * `count`). Keeping them apart is bookkeeping — the dynamics only ever ask
+     * for the sum — but it is the bookkeeping the picture wants, since one of
+     * them is what was set up and the other is what gravity did.
+     *
+     * Which is why it accelerates rather than merely displaces: the count
+     * persists, and what the picture shows is a function of the count.
      */
-    type Carried = Live & { pulled: [number, number], mark: number[] };
+    type Carried = Live & {
+      own: [number, number], pulled: [number, number], mark: number[],
+    };
 
     let live: Carried[] = [];
 
@@ -422,19 +438,20 @@ export const MetricField = ({
         at: [...s.at] as [number, number],
         path: [s.at[0], s.at[1]],
         vel: [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number],
+        own: count(s.drift?.[0] ?? 0, s.drift?.[1] ?? 0),
         pulled: [0, 0] as [number, number],
         mark: [s.at[0], s.at[1]],
       }));
       kept = 0;
     };
 
-    // Its own course plus whatever the space around it has been biased into
-    // doing. One velocity, made of two parts — and the split between them is
-    // bookkeeping, not physics: `free` is asked about the sum.
+    // Its own count plus whatever the space around it has added to it, turned
+    // into the speed the picture can show. See `pace`: the sum is a proper
+    // velocity and this is the only place it becomes a coordinate one.
     const going = (s: Live): [number, number] => {
-      const p = (s as Carried).pulled;
+      const { own, pulled } = s as Carried;
 
-      return [s.vel[0] + p[0], s.vel[1] + p[1]];
+      return pace(own[0] + pulled[0], own[1] + pulled[1]);
     };
 
     /**
@@ -516,13 +533,27 @@ export const MetricField = ({
      * pair — and only ratios are wanted here, so they cancel.
      *
      * Kept relative to each body's own strongest pull rather than against an
-     * absolute floor, so that a light body far from everything still feels
-     * whatever is nearest to it. At a tenth of a millionth, real perturbations
-     * survive comfortably — Jupiter's pull on Saturn is five parts in a
-     * thousand of the Sun's and is nowhere near this — and what goes is only
-     * what could not move anything in the length of the run.
+     * absolute floor, so a light body far from everything still feels whatever
+     * is nearest to it. A body's dominant pull is by definition at ratio one,
+     * so nothing that matters is ever at risk: Jupiter's pull on Saturn is
+     * four parts in ten thousand of the Sun's and survives with room to spare.
+     *
+     * Measured on the entire solar system, against the same run with every
+     * pair walked:
+     *
+     *     threshold   pairs walked   speed    worst orbit moved by
+     *     1e−6            81%        1.30x           4.0e−6
+     *     1e−5            51%        2.71x           9.1e−4
+     *     1e−4            39%        3.83x           7.3e−4
+     *     1e−3            27%        5.68x           7.3e−4
+     *
+     * The shift stops moving at 1e−4 and stays put however much further this
+     * is pushed, which is the signal to stop: what is left is Mercury, whose
+     * orbit in this model is wide and sensitive enough that seven parts in ten
+     * thousand is the integrator rather than the pruning. So 1e−4, which is
+     * where the last pair that changes anything drops out.
      */
-    const NOTHING = 1e-7;
+    const NOTHING = 1e-4;
 
     const most: number[] = [];
 
@@ -561,12 +592,10 @@ export const MetricField = ({
           dx /= coord; dy /= coord;
 
           for (const [s, ux, uy] of [[a, dx, dy], [b, -dx, -dy]] as const) {
-            const [vx, vy] = going(s);
-
             // Divided by its own mass — the fraction of ITS paths that got
-            // bent — and scaled by how many of them are still free to bend at
-            // the speed it is already going. See `free`.
-            const got = free(Math.hypot(vx, vy)) * deficit / (s.mass ?? 1);
+            // bent — and multiplied by what one bent path is worth, which is
+            // the same number however fast it is already going. See `BIAS`.
+            const got = BIAS * deficit / (s.mass ?? 1);
 
             s.pulled[0] += ux * got; s.pulled[1] += uy * got;
           }
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
index ecbdc9a..118a050 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -1028,15 +1028,35 @@ const known: Model[] = KNOWN.map(({ name, note, sources }) => ({
  * two classical accounts are visibly different curves, and this model is a
  * third — and the three come apart in an interesting way:
  *
- *     Newton         circles, by construction
- *     Schwarzschild  perihelion a little INSIDE Newton's, going round FASTER
- *     this model     apoapsis OUTSIDE Newton's, going round SLOWER
+ *     Newton         closed ellipses, by construction
+ *     Schwarzschild  perihelion advancing  +3.2° an orbit for Mercury here
+ *     this model     perihelion advancing  +11.5°, and the same way round
  *
- * So the model's departure is opposite in sign to relativity's, and larger.
- * Both scale with speed the same way — Mercury departs most, Mars least — but
- * gravity here WEAKENS on a body already moving (see `free`) where relativity
- * strengthens it. That is a difference of principle rather than of amount, and
- * these three pictures are where to look at it.
+ * So the model's departure is now the SAME sign as relativity's and about
+ * three and a half times the size, where it used to be the opposite sign and
+ * three times the size. Both of those are worth reading against what changed.
+ *
+ * The sign came from the velocity term, which is gone. Gravity here used to
+ * weaken on a body already moving, by an amount first order in v/c and read
+ * off the frame the canvas happened to be drawn in — so it retarded the
+ * perihelion, opened the orbit out, and could be made to do almost anything by
+ * boosting the whole picture sideways. What replaced it is the observation
+ * that a count of annihilations is a count per tick of the BODY'S clock (see
+ * `pace` in `gravity.ts`), which is second order, frame-stable, and worth
+ * +0.56° an orbit — one sixth of Schwarzschild's, which is what relativistic
+ * momentum on its own has always given.
+ *
+ * What is left is not a velocity effect at all. `shortfall` is not exactly
+ * inverse square — the two ends of the line give the 1/R² and the middle of it
+ * adds about (0.54·ln R + 0.23)/R on top — so the model pulls 8.5% harder than
+ * its own far-field constant at twenty-four cells, and that is the whole of
+ * the remaining +10.9°. It is a SHORT-RANGE departure rather than a fast one,
+ * which is a different claim and a checkable one: drawn at the same speeds and
+ * eight times the size, Mercury's advance here falls from 11.5° to 3.6° while
+ * Schwarzschild's stays at 3.2°. These panels are drawn at the small end on
+ * purpose — a solar system with a visible wave in it has to be — so what they
+ * show is the model at its least Newtonian, and the departure they show is a
+ * statement about cells and not about speed.
  */
 const SUN = 39.4784176;                  // GM in AU^3/yr^2, for the Sun
 
@@ -1235,8 +1255,12 @@ const systems: Model[] = ([
       + 'shape is. It is also where relativity was measured: the perihelion '
       + 'advance is Mercury\u2019s, and the three panels part company on exactly '
       + 'that \u2014 Newton returns to the same perihelion, Schwarzschild carries '
-      + 'it forward, and this model carries it backward and opens the orbit '
-      + 'out to 39 cells.',
+      + 'it forward by 3.2\u00b0 an orbit, and this model carries it forward the '
+      + 'same way by 11.5\u00b0 and closes the orbit in to 25.2 cells. The '
+      + 'direction is right and the size is not, and what is wrong with the '
+      + 'size is short range rather than fast: at eight times this scale and '
+      + 'the same speeds it comes down to 3.6\u00b0 while Schwarzschild\u2019s stays '
+      + 'where it is.',
     cells: 65, ticks: 12000, span: 44, cycle: 24000, rate: 600,
     centre: SUN,
     around: [['Mercury', 0.38710, 0.20563, 0, SUN * 1.66012e-7]],
@@ -1247,13 +1271,16 @@ const systems: Model[] = ([
       + 'eccentricities, real longitudes of perihelion, and the masses worked '
       + 'out from this model\u2019s own G. Newton traces the four ellipses and '
       + 'closes them; relativity advances each perihelion a little; this model '
-      + 'retards it and opens the orbit out. Mercury departs most in all three '
-      + 'panels, because it is both the fastest and the most eccentric, which '
-      + 'is why it was the one the perihelion was measured on \u2014 and why it '
-      + 'has a frame of its own above. Measured over the eleven thousand ticks '
-      + 'of this run: Mercury runs 8.6 to 13.2 cells and comes round 15.1 '
-      + 'times under Newton, 8.6 to 12.3 and 16.3 times under Schwarzschild, '
-      + 'and 8.6 to 20.5 and 8.9 times here. Venus and Earth are drawn as very '
+      + 'advances it the same way and too far, and pulls the orbit in. Mercury '
+      + 'departs most in all three panels \u2014 not because it is fastest, '
+      + 'which is what the velocity term this model used to have would have '
+      + 'said, but because it is CLOSEST: the departure goes as one over the '
+      + 'separation in cells, so the innermost body sees the most of it. '
+      + 'Measured over the eleven thousand ticks of this run: Mercury runs 8.6 '
+      + 'to 13.2 cells and comes round 15.1 times under Newton, 8.6 to 12.3 '
+      + 'and 16.3 times under Schwarzschild, and 8.6 to 9.5 and 21.4 times '
+      + 'here \u2014 which at 8.6 cells is the model well inside the range '
+      + 'where it agrees with anything. Venus and Earth are drawn as very '
       + 'nearly circles because they very nearly are: their eccentricities are '
       + '0.007 and 0.017.',
     cells: 28, ticks: 3000, span: 66, cycle: 30000, rate: 600,
@@ -1276,10 +1303,13 @@ const systems: Model[] = ([
       + 'so Jupiter goes round once, Saturn a third of the way, and Neptune '
       + 'through seven degrees of the hundred and sixty-five years it takes. '
       + 'What the three panels have to disagree about is therefore all in the '
-      + 'inner four, and it is the same disagreement as above: Mercury opens '
-      + 'from 13.2 cells to 20.6 in this model and closes to 12.3 under '
-      + 'Schwarzschild, while Neptune at a hundredth of light does not '
-      + 'measurably differ in any of them.',
+      + 'inner four, and it is the same disagreement as above: Mercury closes '
+      + 'from 13.7 cells to 9.5 in this model and to 12.3 under '
+      + 'Schwarzschild, while Neptune — eight hundred and thirty-five cells '
+      + 'out, where this model’s short-range excess is under two parts in a '
+      + 'thousand — does not measurably differ in any of them. Which is the '
+      + 'clearest thing this frame has to say: the disagreement is with the '
+      + 'near, not with the fast.',
     cells: 28, ticks: 3000, span: 900, cycle: 60000, rate: 900, height: 420,
     centre: SUN,
     around: [

From 29642f9396f399fb79777c784f5b13bd9c1c37a9 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sun, 9 Aug 2026 18:05:43 +0200
Subject: [PATCH 20/47] Reproducing Newtonian gravity

---
 .../2026.RayCalculiAndPhysics/continuous.tsx  | 1081 -----------------
 .../2026.RayCalculiAndPhysics/discrete.ts     |  390 +++---
 .../2026.RayCalculiAndPhysics/field.ts        |   58 +-
 .../2026.RayCalculiAndPhysics/gravity.ts      |  636 +++++++---
 .../2026.RayCalculiAndPhysics/index.tsx       |    6 +-
 .../2026.RayCalculiAndPhysics/metric.tsx      |  350 +++++-
 .../2026.RayCalculiAndPhysics/model.ts        |   49 +-
 .../2026.RayCalculiAndPhysics/models.ts       |  132 +-
 .../2026.RayCalculiAndPhysics/physics.ts      |   30 +-
 .../2026.RayCalculiAndPhysics/views.tsx       |   16 +-
 10 files changed, 1180 insertions(+), 1568 deletions(-)
 delete mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
deleted file mode 100644
index 44a99c9..0000000
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/continuous.tsx
+++ /dev/null
@@ -1,1081 +0,0 @@
-/**
- * EQUATIONS IN THIS FILE
- *
- *   S(x)      = Σ_{a<b} cancelling(Fa,Fb)·|Fa·Fb|·closing(d̂a,d̂b)
- *                                                 annihilation, per place
- *   share     = Σ cancelling / Σ meeting          how much of it is opposite
- *   want      = BITE · share                      cells a tick, from the rule
- *
- *   u(x)      = −Σ_k (q/2)·tanh(n̂·e / SPREAD)·exp(−(e×n̂ / LOCAL)²)·n̂
- *                                                 the flow of space, |u| ≤ LIGHT
- *   ḧ         = c²∇²h + (u − ḣ)·pull              carried, at the speed of light
- *   river     = |ḣ|² / 2                          and half its square is
- *   fall      = −∇ river                          ... the free-fall acceleration
- *
- *   wake(s)   = Σ± pace·ê / (2πr²)                what movement puts back
- *   v̇         = fall − (fall·ĥ)ĥ                   turned only, never sped up
- *
- */
-
-import { CanvasView, Surface } from "./canvas";
-import {
-  Emitter, emit, fieldAt, grainAt, Live, retard, TRAIL, was, wasGoing,
-  CARRY, RETARD, WAY,
-} from "./field";
-import { CYCLE } from "./lattice";
-import { BITE, cancelling, closing, LIGHT } from "./physics";
-import {
-  AMBER, BACKGROUND, CYAN, ground, legend, lift, shown, source,
-} from "./paint";
-
-/**
- * Gravity as a flow: space is given a speed, and everything is carried by it.
- *
- * This is the older of the two accounts in this article and the more
- * elaborate. It measures where annihilation is happening, turns that into a
- * velocity field for the space itself, gives that field a wave equation so it
- * travels at the speed of light, and then carries each source by the flow it
- * is standing in and turns it by how steeply that flow falls away.
- *
- * `metric.tsx` is the other account, and it says the same thing far more
- * directly — that annihilation does not push anything, it removes the space,
- * and everything else is what is left of the geometry. Both are drawn from
- * the same field (`field.ts`), so what they disagree about is only what
- * annihilation DOES, which is the thing worth seeing two ways.
- */
-
-/**
- * Where space is being destroyed, asked of places rather than of pairs.
- *
- * This is the piece that adding cosines does not give you, and without it the
- * continuous version is not the same physics — it is the same picture with
- * the gravity left out. Two opposite charges meeting in the model do not
- * average to nothing and stay where they are. They ANNIHILATE, and
- * annihilating takes the point each of them was on out of the world, which
- * leaves whatever was on either side of them nearer together. That is the
- * whole of why two magnets attract here: not a force between them, an ongoing
- * loss of the space in between.
- *
- * The first version of this asked the question of a PAIR — walk the line
- * joining two named sources, see how much of what meets there is opposite.
- * It gives the right rate and it is the wrong question, because it is not a
- * question about anywhere. It needs to know which sources exist and which two
- * of them are being considered, and it produces one number for the pair
- * rather than a fact about each place. Nothing built on it can deflect a
- * third thing, because a third thing is not in the sum.
- *
- * Asked of a place, it is local, and everything it needs is at that place.
- * How much of each charge is here; which way each of them is travelling; and
- * therefore how much of what is here is meeting head-on rather than crossing.
- * Two things annihilate when they are opposite in charge AND opposed in
- * direction — one without the other is a crossing, not a collision — so both
- * factors are in it, and both are readable on the spot.
- *
- * What comes out is the field this model puts where mass usually goes:
- * annihilation per unit of space per tick. It is not a property anything has.
- * It is something that happens somewhere.
- */
-const SITES: number[] = [];                       // x, y, eaten, nx, ny, met — six at a time
-let siteCount = 0;
-
-/*
- * How much space a tick's worth of meeting destroys is `BITE`, and it is the
- * one number tying this rate to the lattice's — stated with the other laws
- * rather than here, because it is not a fact about the survey.
- *
- * A source emits a shell every tick and shells travel a cell a tick, so along
- * any line between two of them one shell meets one shell every tick, and a
- * meeting of opposites takes two cells out of the world. That is a COUNT —
- * one meeting, two cells — with nothing in it about how large the region is
- * where the meeting happens.
- *
- * Which is the thing the survey below cannot supply and must not be asked to.
- * It measures a density, and a density integrated over an area gives a number
- * that grows with the area: two sources far apart overlap over more of the
- * picture than two close together, and reading their annihilation off that
- * integral has them eating faster the further apart they are, which is not
- * merely wrong but backwards. Everything the survey knows is WHERE the eating
- * is happening and along what. How MUCH is set by the cadence, and shared out
- * over the places in proportion to what is going on at each.
- */
-
-/**
- * And how far the loss of a point is felt, which is not far.
- *
- * A collision removes the two points its charges were on and joins what was
- * behind each directly to the other. That shortens the LINE they were on and
- * does nothing whatever to a point off to the side, which is joined to the
- * world by paths that never went through the collision. So the influence of
- * an annihilation is confined to a neighbourhood of it, and this is the size
- * of that neighbourhood.
- *
- * Which is a real claim and an unusual one. Gravity here is not long-range,
- * and it is not something a mass has and radiates. It acts along the lines
- * where annihilation is actually happening, which is to say between things
- * that are cancelling each other's emissions. A body that emits nothing feels
- * nothing, however much is going on beside it.
- *
- * But it must not be smaller than the grid the annihilation was surveyed on,
- * and that is what it was. A few cells, against sites laid out one every few
- * cells, gives a field that is a row of separate little pushes with nothing
- * between them: a body sitting on the axis is either on top of one, where the
- * transverse falloff is flat because it is at the peak of it, or between two,
- * where there is nothing at all. Either way it feels no gradient, and a body
- * that feels no gradient is never turned — which was the whole complaint. The
- * loss has to be smeared over at least the spacing of the places it was
- * measured at, or what is being drawn is the grid rather than the field.
- */
-let LOCAL = 3;                                    // cells, set by the survey
-
-// How far apart the closest pair are, which is the distance the pull has to
-// work over. Also set by the survey.
-let SPREAD = 1;
-
-/**
- * Survey the framed region for it, once a tick.
- *
- * A coarse grid is enough: what is being looked for is where the annihilation
- * is, and it is spread over the overlap of two fields rather than
- * concentrated at points. Everything below a fraction of the strongest is
- * dropped, because most of any of these pictures is space where nothing is
- * meeting anything and summing a few hundred nothings into every query is the
- * whole cost of this.
- */
-const survey = (live: Live[], t: number, span: number) => {
-  const STEPS = 22;
-
-  siteCount = 0;
-  SITES.length = 0;
-
-  if (live.length < 2) return;
-
-  // Centred on the sources, since that is where anything is.
-  let mx = 0, my = 0;
-  for (const s of live) { mx += s.at[0] / live.length; my += s.at[1] / live.length; }
-
-  /**
-   * And it looks at the pair, not at the picture.
-   *
-   * The grid was laid across the whole view, so its cells are a couple of
-   * cells of world across — which is fine while the two are far apart and
-   * useless the moment they are not. A pair three cells apart has the whole
-   * of its encounter inside ONE cell of that grid: the survey finds a site or
-   * two in roughly the right place, or none at all, and the pull collapses
-   * exactly as the two are closing on each other. They drifted together,
-   * slowed for no reason in the model, and stopped short.
-   *
-   * Framed on the pair instead, the resolution follows them down. What is
-   * being measured is where annihilation is happening, and that is between
-   * them, wherever they have got to and however little room it now takes.
-   */
-  let nearest = Infinity;
-
-  for (let i = 0; i < live.length; i++)
-    for (let j = i + 1; j < live.length; j++)
-      nearest = Math.min(nearest, Math.hypot(
-        live[j].at[0] - live[i].at[0], live[j].at[1] - live[i].at[1],
-      ));
-
-  const look = Math.min(span, Math.max(isFinite(nearest) ? nearest * 1.6 : span, 5));
-  const step = (2 * look) / STEPS;
-
-  // Wide enough that the sites blend into a field rather than staying a row
-  // of separate pushes, which is what gives it a gradient to turn anything
-  // with. See `LOCAL`.
-  LOCAL = Math.max(step * 2, 1.5);
-  SPREAD = Math.max(isFinite(nearest) ? nearest / 4 : step, 0.75);
-
-  const val: number[] = [];
-  const dirX: number[] = [];
-  const dirY: number[] = [];
-
-  let strongest = 0;
-
-  // What the picture is doing as a whole: how much of what meets is opposite,
-  // and how much meets at all. Their ratio is the only thing about magnitude
-  // the survey has any business reporting.
-  let cancelled = 0, meeting = 0;
-
-  for (let gy = 0; gy < STEPS; gy++) {
-    const y = my - look + (gy + 0.5) * step;
-
-    for (let gx = 0; gx < STEPS; gx++) {
-      const x = mx - look + (gx + 0.5) * step;
-
-      for (let i = 0; i < live.length; i++) {
-        val[i] = emit(live[i], live[i], x, y, t);
-        dirX[i] = WAY[0]; dirY[i] = WAY[1];
-      }
-
-      // What is annihilating here, and what is meeting here at all — which
-      // is more, because alike charges meeting head-on turn around rather
-      // than cancelling, and either way they stop going forwards.
-      let eaten = 0, here = 0, nx = 0, ny = 0;
-
-      for (let i = 0; i < live.length; i++) {
-        for (let j = i + 1; j < live.length; j++) {
-          // How much of what is here is one field against the other at all,
-          // whichever way round — the denominator of the share. Two things
-          // annihilate when they are opposite in charge AND opposed in
-          // direction, and one without the other is a crossing rather than a
-          // collision, so both factors have to be in it.
-          const closes = closing(
-            [dirX[i], dirY[i]], [dirX[j], dirY[j]],
-          );
-          if (closes <= 0) continue;              // crossing, not meeting
-
-          const strength = Math.abs(val[i] * val[j]) * closes;
-
-          here += strength;
-          meeting += strength;
-
-          // And opposite in charge as well: annihilation rather than a
-          // bounce. The same law the lattice reads at ±1 to get
-          // 'annihilate' — see `cancelling`.
-          const against = cancelling(val[i], val[j]) * strength;
-          if (against <= 0) continue;
-
-          eaten += against;
-
-          // The line they are meeting along, which is the line that shortens.
-          nx += (dirX[i] - dirX[j]) * against;
-          ny += (dirY[i] - dirY[j]) * against;
-        }
-      }
-
-      if (here <= 0) continue;
-
-      cancelled += eaten;
-
-      const len = Math.hypot(nx, ny) || 1;
-
-      SITES.push(x, y, eaten, nx / len, ny / len, here);
-      siteCount++;
-
-      if (here > strongest) strongest = here;
-    }
-  }
-
-  // Note there is no global reading of how much bounces and how much
-  // annihilates. That question is settled at each meeting by what the two
-  // charges there are, in `bounced` above — a share taken over the whole
-  // picture is an average of a decision, and an average of a decision is not
-  // a thing anything experiences.
-
-  if (!strongest) { SITES.length = 0; siteCount = 0; return; }
-
-  // Thinned to what is worth summing over, and the total kept with it so that
-  // what is dropped is not quietly handed to what is not.
-  const floor = strongest * 0.05;
-  let kept = 0, total = 0;
-
-  let seen = 0;
-
-  for (let k = 0; k < siteCount; k++) {
-    if (SITES[k * 6 + 5] < floor) continue;
-
-    for (let c = 0; c < 6; c++) SITES[kept * 6 + c] = SITES[k * 6 + c];
-
-    total += SITES[kept * 6 + 2];
-    seen += SITES[kept * 6 + 5];
-    kept++;
-  }
-
-  SITES.length = kept * 6;
-  siteCount = kept;
-
-  // The meeting is kept as it was measured — a density, per unit of space,
-  // per tick. Normalising it to a share of the whole encounter, which is what
-  // it used to do, is what made the shadow useless: a wave crossing the gap
-  // met "a fifth of the total" however thick the thing it was crossing, so
-  // the attenuation stopped depending on how much was actually in the way.
-  // What a wave loses is a density times a path, and both of those have to
-  // survive to the place that multiplies them.
-
-  /**
-   * Rebuilt whatever else is true of this tick, and before anything can
-   * return early.
-   *
-   * A shadow is a fact about where the sources are NOW. Left over from the
-   * tick before while they have moved on — which is what happened whenever a
-   * pair was bouncing without annihilating, since there was nothing to scale
-   * and the function gave up before reaching this — it darkens places nothing
-   * is crossing any more, and the picture fills with patches of black that
-   * belong to a configuration that has gone.
-   */
-
-  if (!kept || total <= 0) return;
-
-  /**
-   * And the whole of it scaled to what a tick's meeting actually costs.
-   *
-   * The share is how much of the encounter annihilates rather than bounces,
-   * which is between nought and one and says nothing about how big the
-   * encounter is. Multiplied by `BITE`, that is the space a tick destroys.
-   * Divided out over the sites in proportion to what each is doing, the
-   * distribution stays exactly what was measured and the total stops being an
-   * accident of how much of the picture the two fields happen to overlap in.
-   */
-  const share = meeting > 1e-12 ? cancelled / meeting : 0;
-
-  /**
-   * And the size of it is fixed by what the pair actually do to each other,
-   * not by what the sites happen to add up to.
-   *
-   * A meeting costs two cells: the charge arriving is on a point, the charge
-   * it meets is on the next one, and annihilating is both of them ceasing to
-   * be anywhere. One meeting a tick, so two cells a tick, times the share of
-   * the encounter that is opposite rather than alike. That is the whole rate
-   * and it is a count — it does not know or care how the annihilation is
-   * spread about.
-   *
-   * Scaling the SITES to sum to it is not the same thing and was the error.
-   * What a source is moved by is not the sum of the sites, it is the flow it
-   * stands in — the sum after each site's reach has fallen away across the
-   * distance and off to the side. Most of it never arrives. So the sites
-   * summed to two cells a tick and the pair closed at a fifth of one, and
-   * every picture of two things attracting was running at a fraction of the
-   * rate the rule gives, with the fraction set by how the survey's kernels
-   * happened to overlap.
-   *
-   * Measured at the sources instead: lay the sites down at whatever relative
-   * strengths they were found with, ask how fast the gap between the pair is
-   * closing under that, and scale the lot until the answer is two cells a
-   * tick. Then the shape is the survey's and the size is the rule's, which is
-   * the right division of labour between the two.
-   */
-  for (let k = 0; k < kept; k++) SITES[k * 6 + 2] /= total;
-
-  let closes = 0;
-
-  for (let i = 0; i < live.length; i++) {
-    for (let j = i + 1; j < live.length; j++) {
-      const a = live[i], b = live[j];
-
-      let ux = b.at[0] - a.at[0], uy = b.at[1] - a.at[1];
-      const apart = Math.hypot(ux, uy);
-      if (apart < 1e-6) continue;
-
-      ux /= apart; uy /= apart;
-
-      flowAt(a.at[0], a.at[1]);
-      const ain = FLOW[0] * ux + FLOW[1] * uy;
-
-      flowAt(b.at[0], b.at[1]);
-      const bin = -(FLOW[0] * ux + FLOW[1] * uy);
-
-      closes += ain + bin;
-    }
-  }
-
-  if (closes <= 1e-9) return;
-
-  const want = BITE * share;
-
-  for (let k = 0; k < kept; k++) SITES[k * 6 + 2] *= want / closes;
-};
-
-// The optical-depth shadow that used to live here is gone. A wave is not
-// thinned by what it passes through — it stops dead at the first thing it
-// meets, which is `meets` above — so there was nothing left for it to say,
-// and it was still being rebuilt over the whole grid every tick.
-
-/**
- * The flow of space, which is where gravity actually is.
- *
- * Each place that is destroying space draws what is around it inwards along
- * the line the collision there is happening on: everything on one side comes
- * one way, everything on the other side comes the other, and a point off to
- * the side barely moves at all. Summed over everywhere that is doing it, that
- * is the whole field, and nothing in the sum knows about sources or pairs —
- * only about places and what is happening at them.
- *
- * And there is the deflection, for free and without a force anywhere. The
- * flow has a gradient, so it does not merely carry a body — it turns it. A
- * velocity is a displacement per tick, and a displacement in a space that is
- * being sheared comes out pointing somewhere else. Nothing accelerates: the
- * body's own motion is untouched and its speed never changes. It is carried,
- * and what carries it is not uniform.
- */
-/**
- * The space itself, kept between ticks, and how fast it is going.
- *
- * Everything before this treated gravity as a speed: work out where
- * annihilation is happening, work out how fast that drags each source, move
- * it that far, throw the answer away and do it again next tick. Which cannot
- * be right, and the discrete rule says why. `annihilate` does not push
- * anything. It rewires — the point behind one dying charge is spliced
- * directly onto the point behind the other — and it STAYS rewired. The state
- * is in the space, not in the bodies, and a speed recomputed from scratch
- * every tick is precisely a model with no state in the space at all.
- *
- * So the space gets a displacement of its own, `h`, which is how far each
- * place has been carried from where it started, and it is kept. Annihilation
- * adds to it and nothing takes it away: once the ground between two things
- * has gone, it has gone, and they are nearer whether or not anything is still
- * eating.
- *
- * And `h` is given a wave equation rather than being applied where it is
- * made. A contraction here has to reach a place over there, and it has to
- * take the time light takes — so the field obeys
- *
- *     d²h/dt² = c² ∇²h + S
- *
- * with S the annihilation. Ripples in `h` then travel outward at exactly c,
- * which is what a gravitational wave is: not a thing added to the model, but
- * what persistence and a finite speed give you together the moment you stop
- * applying the answer instantly and everywhere. Neither alone produces one.
- *
- * A grid fixed for the whole run, unlike the survey's, which re-frames on the
- * pair every tick. A field that is carried from one tick to the next cannot
- * be resampled onto a moving grid without smearing everything it remembers.
- */
-type Warp = {
-  hx: Float32Array; hy: Float32Array;             // where each place has got to
-  vx: Float32Array; vy: Float32Array;             // and how fast it is going
-  sx: Float32Array; sy: Float32Array;             // what is driving it this tick
-  n: number; x0: number; y0: number; step: number;
-};
-
-const warp = (span: number): Warp => {
-  // Forty across is enough to carry a wave and cheap enough to ask the
-  // calibrated flow at every one of its places, once a tick.
-  const n = 40;
-  const step = (2 * span) / n;
-
-  return {
-    hx: new Float32Array(n * n), hy: new Float32Array(n * n),
-    vx: new Float32Array(n * n), vy: new Float32Array(n * n),
-    sx: new Float32Array(n * n), sy: new Float32Array(n * n),
-    n, x0: -span, y0: -span, step,
-  };
-};
-
-// Read between the grid's places, since it is asked at arbitrary points.
-const WARP: [number, number] = [0, 0];
-
-const warpAt = (w: Warp, a: Float32Array, b: Float32Array, x: number, y: number) => {
-  const fx = Math.min(Math.max((x - w.x0) / w.step, 0), w.n - 1.001);
-  const fy = Math.min(Math.max((y - w.y0) / w.step, 0), w.n - 1.001);
-
-  const i = Math.floor(fx), j = Math.floor(fy);
-  const u = fx - i, v = fy - j;
-
-  const k = j * w.n + i;
-
-  WARP[0] = (a[k] * (1 - u) + a[k + 1] * u) * (1 - v)
-    + (a[k + w.n] * (1 - u) + a[k + w.n + 1] * u) * v;
-  WARP[1] = (b[k] * (1 - u) + b[k + 1] * u) * (1 - v)
-    + (b[k + w.n] * (1 - u) + b[k + w.n + 1] * u) * v;
-};
-
-/**
- * One step of it.
- *
- * The annihilation found this tick is laid down as the source term — the same
- * shape `flowAt` used to hand straight to the sources, put into the field
- * instead — and then the field is left to carry it. The Laplacian is the
- * plain five-point one, which is all a wave equation on a grid needs, and the
- * time step is a fraction of a cell against a speed of one, so it is nowhere
- * near the limit where that would misbehave.
- *
- * A little damping, because nothing here should ring for ever: an annihilation
- * that has finished leaves its displacement behind, which is the point, but
- * the SPEED it left the space with has to die away or the picture keeps
- * sloshing long after anything is happening.
- */
-const warpStep = (w: Warp, dt: number) => {
-  const { hx, hy, vx, vy, sx, sy, n, step } = w;
-
-  /**
-   * What the space would be doing here if the annihilation acted at once,
-   * which is what the survey has already been calibrated to give.
-   *
-   * Used as the speed the field is DRAWN TOWARDS rather than as a force added
-   * to it — which keeps the one number that ties this to the discrete rule.
-   * `survey` scales the sites so that a pair whose every meeting cancels
-   * would close at two cells a tick, and if that were integrated as an
-   * acceleration the speed would simply grow past it and the calibration
-   * would mean nothing. Relaxed towards, the near field settles at exactly
-   * the rate the rule gives, and everything the wave equation adds is what
-   * happens on the way there and further out.
-   */
-  for (let j = 0; j < n; j++) {
-    for (let i = 0; i < n; i++) {
-      const k = j * n + i;
-
-      flowAt(w.x0 + i * step, w.y0 + j * step);
-
-      sx[k] = FLOW[0]; sy[k] = FLOW[1];
-    }
-  }
-
-  // A step of the wave equation: the Laplacian carries it, at exactly the
-  // speed of light in the units everything else here is in.
-  const c2 = LIGHT * LIGHT / (step * step);
-  const pull = 2.5;
-
-  for (let j = 1; j < n - 1; j++) {
-    for (let i = 1; i < n - 1; i++) {
-      const k = j * n + i;
-
-      const lx = hx[k - 1] + hx[k + 1] + hx[k - n] + hx[k + n] - 4 * hx[k];
-      const ly = hy[k - 1] + hy[k + 1] + hy[k - n] + hy[k + n] - 4 * hy[k];
-
-      vx[k] += (c2 * lx + (sx[k] - vx[k]) * pull) * dt;
-      vy[k] += (c2 * ly + (sy[k] - vy[k]) * pull) * dt;
-    }
-  }
-
-  // And the displacement keeps what the speed has given it. Nothing takes it
-  // back: once the ground has gone it has gone.
-  for (let k = 0; k < hx.length; k++) { hx[k] += vx[k] * dt; hy[k] += vy[k] * dt; }
-};
-
-/**
- * How steeply the ground falls away here.
- *
- * The flow has exactly one scalar in it — how fast the space is going — and
- * the slope of half its square is where everything else comes from. That is
- * not a choice: a flow which is the gradient of something obeys
- * `(u . grad) u = grad(|u|^2 / 2)`, and `(u . grad) u` is what a thing sitting
- * still in the coordinates is carried by as the flow it is standing in
- * accelerates. So the slope of `|u|^2 / 2` IS the free-fall acceleration, and
- * it is the same quantity Newton called the gradient of a potential — a river
- * running in at `sqrt(2M/r)` has half its square equal to `M/r` exactly.
- *
- * Which means nothing here is imported. The rule is still that annihilation
- * takes two cells out of the space between whatever is annihilating. The flow
- * is what that does to the space. And a falloff nobody put in — the whole
- * inverse-square of it — is sitting in that flow already, waiting to be
- * differentiated.
- *
- * Read over three quarters of a cell either side, which is wide enough to see
- * past the survey's own grid and narrow enough to still be local.
- */
-const NUDGE = 0.75;
-
-const river = (w: Warp, x: number, y: number) => {
-  warpAt(w, w.vx, w.vy, x, y);
-
-  return (WARP[0] * WARP[0] + WARP[1] * WARP[1]) / 2;
-};
-
-const FALL: [number, number] = [0, 0];
-
-const fallAt = (w: Warp, x: number, y: number) => {
-  FALL[0] = -(river(w, x + NUDGE, y) - river(w, x - NUDGE, y)) / (2 * NUDGE);
-  FALL[1] = -(river(w, x, y + NUDGE) - river(w, x, y - NUDGE)) / (2 * NUDGE);
-};
-
-/**
- * What movement itself does to the space it is moving through.
- *
- * `consumeAhead` is a SWAP: the ray takes the point in front of it and that
- * point ends up behind. So anything going anywhere is laying space down
- * behind itself at exactly the rate it takes it up in front, one cell for
- * every cell it goes — and the space it crosses is not merely crossed, it is
- * carried from one end of the thing to the other.
- *
- * Which is the other half of what happens between two sources. The
- * annihilation between them takes space OUT and draws them together. The
- * motion of each puts space BACK, behind it, and pushes them apart. Where
- * those balance is where a pair neither closes nor escapes.
- *
- * Two things about how this is written, and both were got wrong first.
- *
- * It is never its own. A thing does not feel its own wake: the taking in
- * front and the laying behind are not two forces on it that happen to cancel
- * — they are what its moving IS, and `vel` already counts them. Put on the
- * grid with everything else, where there is no way to ask whose wake a place
- * is in, each source read its own and got a shove forward of about two thirds
- * of its own pace on top of its own pace, every tick, compounding through the
- * field. That is a rocket, and it showed as sources tearing away in the
- * direction they were already going.
- *
- * And it is retarded, off the same trail `emit` uses. A wake is news, and
- * news travels at one cell a tick like everything else here.
- */
-const WAKE: [number, number] = [0, 0];
-
-// How far in front the taking happens and how far behind the laying: one
-// point either side, in a lattice whose points are one apart.
-const SWAP = 0.5;
-
-const wakeAt = (s: Live, x: number, y: number, t: number) => {
-  WAKE[0] = 0; WAKE[1] = 0;
-
-  const when = retard(s, x, y, t);
-  if (!isFinite(when)) return;
-
-  wasGoing(s, when);
-
-  const px = RETARD[0], py = RETARD[1];
-  const pace = Math.hypot(CARRY[0], CARRY[1]);
-  if (pace < 1e-9) return;
-
-  const ax = CARRY[0] / pace, ay = CARRY[1] / pace;
-
-  // A point of space being made pushes what is around it away; a point being
-  // taken up draws it in. Movement is one of each, half a cell apart, and far
-  // off the two very nearly cancel — which is exactly right, and is why a
-  // swap is not a source of anything. Near to, they do not.
-  for (let k = 0; k < 2; k++) {
-    const side = k ? -SWAP : SWAP;
-    const sign = k ? 1 : -1;
-
-    const ex = x - (px + ax * side), ey = y - (py + ay * side);
-
-    const r = Math.hypot(ex, ey);
-    if (r < SWAP) continue;
-
-    WAKE[0] += sign * pace * ex / (r * 2 * Math.PI * r);
-    WAKE[1] += sign * pace * ey / (r * 2 * Math.PI * r);
-  }
-};
-
-const FLOW: [number, number] = [0, 0];
-
-const flowAt = (x: number, y: number) => {
-  FLOW[0] = 0; FLOW[1] = 0;
-
-  for (let k = 0; k < siteCount; k++) {
-    const sx = SITES[k * 6], sy = SITES[k * 6 + 1];
-    const q = SITES[k * 6 + 2];
-    const nx = SITES[k * 6 + 3], ny = SITES[k * 6 + 4];
-
-    const ex = x - sx, ey = y - sy;
-
-    const on = ex * nx + ey * ny;
-    const off = ex * -ny + ey * nx;
-
-    /**
-     * Everything on one side comes one way and everything on the other comes
-     * the other, so the line through it is shorter by `q` and the place
-     * itself does not move.
-     *
-     * Saturating over the distance the pair are apart, not over the size of
-     * the picture. Tied to the picture, the pull quietly gave out exactly
-     * when it should have been strongest: a pair a few cells apart has every
-     * site a few cells from each of them, and `tanh` of a few cells over a
-     * width set by the whole view is almost nothing — so they drifted
-     * together, slowed, and stopped short of touching for no reason in the
-     * model at all.
-     */
-    const side = Math.tanh(on / SPREAD);
-    const fade = Math.exp(-((off / LOCAL) ** 2));
-
-    FLOW[0] -= (q / 2) * side * fade * nx;
-    FLOW[1] -= (q / 2) * side * fade * ny;
-  }
-
-  /**
-   * And no place of space goes faster than light, whatever the sites add up
-   * to.
-   *
-   * Not a safety rail — it is the same rule everything else here obeys, and
-   * without it the calibration in `survey` has a hole in it. That divides by
-   * how fast the sites it found happen to close the pair, and when the two
-   * are nearly touching, or arranged so that what is being eaten is mostly
-   * off to the side of the line between them, the measured closing goes to
-   * almost nothing while the rate the rule asks for does not. The quotient
-   * runs away. Measured on the fly-by that pulses every fifth tick, the flow
-   * carrying a source reached three hundred and fifty thousand cells a tick
-   * and the pair were flung four hundred cells apart in forty.
-   *
-   * Held to light, the same arrangement simply closes as fast as anything can
-   * close and no faster. The pair still meet, the gap still goes at two cells
-   * a tick between them, and the number that used to be unbounded is now the
-   * one bound this whole model has.
-   */
-  const going = Math.hypot(FLOW[0], FLOW[1]);
-
-  if (going > LIGHT) { FLOW[0] *= LIGHT / going; FLOW[1] *= LIGHT / going; }
-};
-
-// A 4x4 ordered pattern, centred on nought and worth about one level of an
-// eight-bit channel. See the use below.
-const DITHER = [
-  0, 8, 2, 10,
-  12, 4, 14, 6,
-  3, 11, 1, 9,
-  15, 7, 13, 5,
-].map(v => (v / 16) - 0.5);
-
-/**
- * One canvas of it, evaluated rather than simulated.
- *
- * Every sample is independent of every other, so there is no state to carry
- * between frames and nothing to ease: the drawn field IS the field, at
- * whatever real-valued t the clock has reached. Which is the visible payoff
- * of having a function rather than a run — the animation above has to walk
- * towards each tick because the world only exists at whole ones, and this
- * one is simply continuous, so it moves the way a wave moves.
- *
- * Drawn small and stretched. The field has no detail below the scale of its
- * own bands, so sampling it at every pixel is spending several times over
- * for a picture that is smooth by construction; a quarter-scale buffer drawn
- * up with the canvas's own interpolation is the same image for a sixteenth
- * of the arithmetic.
- */
-export const ContinuousField = ({
-  sources,
-  height = 320,
-  span = 14,
-  rate = 10,
-  cycle = 200,
-}: {
-  sources: Emitter[];
-
-  // How much of the world is on screen, as a radius in cells.
-  span?: number;
-
-  // Ticks a second, and it need not be a whole number of anything.
-  rate?: number;
-
-  // Ticks before it starts again from the beginning. A pair that closes on
-  // each other ends up adjacent and then has nothing left to do — neither is
-  // space, so neither can be moved through, and adjacent is as close as
-  // adjacent gets. Watching that happen is the point; watching it having
-  // happened is not.
-  cycle?: number;
-
-  height?: number;
-}) => <CanvasView
-  height={height}
-  deps={[sources, span, rate, cycle]}
-  paint={() => {
-    // The small buffer the field is evaluated into, before being drawn up to
-    // the size of the canvas.
-    const buf = document.createElement("canvas");
-    const bufCtx = buf.getContext("2d")!;
-
-    let img: ImageData | null = null;
-
-    let t = 0;
-
-    // Where the sources have got to. The ones handed in say where they start,
-    // and nothing about where they stay.
-    let live: Live[] = [];
-
-    let field = warp(span);
-
-    const reset = () => {
-      t = 0;
-      field = warp(span);
-      live = sources.map(s => ({
-        ...s,
-        at: [...s.at] as [number, number],
-        path: [s.at[0], s.at[1]],
-        vel: [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number],
-      }));
-    };
-
-    // Everywhere each of them has been, kept up to the moment. Filled to the
-    // current time rather than appended to once per frame, so the record is
-    // evenly spaced whatever the frame rate happens to be doing.
-    const remember = () => {
-      for (const s of live) {
-        for (let k = s.path.length / 2; k <= t / TRAIL; k++) {
-          s.path.push(s.at[0], s.at[1]);
-        }
-      }
-    };
-
-    function draw({ ctx, width: w, height: h }: Surface) {
-
-      /**
-       * Css pixels to a sample, and it cannot be one number.
-       *
-       * What has to be resolved is a band, and a band is `CYCLE/2` cells of
-       * world however the view is set — so how many pixels it covers depends
-       * entirely on how far out the camera is. A single source framed at
-       * fourteen cells gives a band forty-odd pixels and four pixels a sample
-       * is plenty. The same four pixels against a pair framed at sixty gives a
-       * band ten pixels wide and two and a half samples across it, which is
-       * under what it takes to see a wave at all: what gets drawn there is not
-       * a coarse version of the field, it is the moiré of a grid beating
-       * against one, and no amount of smoothing afterwards recovers it.
-       *
-       * So the sampling follows the bands rather than the screen. Five or so to
-       * a band everywhere, which is what the wide views were missing and what
-       * the close ones were spending several times over.
-       */
-      // Smooth where the winding can be read, grainy where it cannot.
-      const grain = grainAt(CYCLE * (Math.min(w, h) / (2 * Math.max(span, 1))));
-
-      const bandPx = (CYCLE / 2) * (Math.min(w, h) / (2 * Math.max(span, 1)));
-
-      const SAMPLE = Math.max(Math.min(bandPx / 5, 4), 1.4);
-
-      const cols = Math.max(Math.round(w / SAMPLE), 1);
-      const rows = Math.max(Math.round(h / SAMPLE), 1);
-
-      if (buf.width !== cols || buf.height !== rows) {
-        buf.width = cols; buf.height = rows;
-        img = null;
-      }
-
-      // Asked for once and written over ever after. At this sampling it is a
-      // hundred thousand pixels a frame, and handing that back to be
-      // collected sixty times a second is most of what the drawing would
-      // otherwise cost.
-      if (!img) img = bufCtx.createImageData(cols, rows);
-
-      const px = img.data;
-
-      // Cells to the shorter side of the picture, so the same world is framed
-      // whatever shape the canvas is.
-      const scale = Math.min(w, h) / (2 * span);
-
-      for (let y = 0; y < rows; y++) {
-        const wy = ((y + 0.5) * (h / rows) - h / 2) / scale;
-
-        for (let x = 0; x < cols; x++) {
-          const wx = ((x + 0.5) * (w / cols) - w / 2) / scale;
-
-          const v = Math.max(Math.min(fieldAt(wx, wy, t, live, grain), 1), -1);
-
-          /**
-           * Amber one way, cyan the other, and the background where the two
-           * meet — so a seam is a dark channel and needs no line drawn on it.
-           *
-           * Shown at the strength it actually has, which it was not. A gamma
-           * of about a half lifts the faint parts of a picture towards the
-           * bright ones, and here that is a lie with consequences: a wave
-           * thinned to a hundredth of itself by distance and by everything it
-           * has crossed was being drawn at a fifth, so the outer half of
-           * every picture looked like a place where something was happening.
-           * It is not. Gravity here goes as the product of two waves meeting,
-           * so it falls away faster than either of them does — and if the
-           * waves are drawn brighter than they are, the eye is being told the
-           * opposite of the truth about where anything can still act.
-           *
-           * Straight through, then. What is visible is what is there, and
-           * where the picture goes dark is where the two have nothing left to
-           * do to each other.
-           */
-          // Shown on a log scale — see `shown`, and the legend below.
-          const k = shown(v);
-          const i = (y * cols + x) * 4;
-
-          /**
-           * And a little noise added before it is rounded to a byte.
-           *
-           * The field is smooth and the colours it maps to are eight bits, so
-           * a gradient that takes two hundred pixels to go from one shade to
-           * the next has a hard edge every two hundred pixels — a set of
-           * contour lines nothing asked for, which read as the picture being
-           * coarse when what is coarse is only the counting. Half a level of
-           * dither, from a fixed pattern rather than from a random number so
-           * that a still frame is stable, turns each of those edges into a
-           * scatter that averages to the right value and has no edge in it.
-           */
-          const d = DITHER[(y & 3) * 4 + (x & 3)];
-
-          // The ground, plus however far this place leans towards one charge
-          // or the other. At nought it is the ground exactly, which is why a
-          // place where the two cancel needs nothing drawn on it to read as
-          // empty — and why the tints are the same three numbers the lattice
-          // strokes its charges with. See `paint.ts`.
-          const tint = v > 0 ? AMBER : CYAN;
-
-          px[i] = BACKGROUND[0] + lift(tint, 0) * k + d;
-          px[i + 1] = BACKGROUND[1] + lift(tint, 1) * k + d;
-          px[i + 2] = BACKGROUND[2] + lift(tint, 2) * k + d;
-          px[i + 3] = 255;
-        }
-      }
-
-      bufCtx.putImageData(img, 0, 0);
-
-      ground(ctx, w, h);
-
-      ctx.imageSmoothingEnabled = true;
-      ctx.drawImage(buf, 0, 0, w, h);
-
-      legend(ctx, w, h);
-
-      // The sources, drawn exactly as the lattice draws its own.
-      for (const s of live)
-        source(ctx, w / 2 + s.at[0] * scale, h / 2 + s.at[1] * scale,
-          { halo: 14, dot: 2.2 });
-    }
-
-    /**
-     * And everything is carried by the flow of the space it is in.
-     *
-     * Three things, in this order, and the order says what the model claims.
-     * A source goes on going the way it was going, because nothing here
-     * accelerates anything. The space it is in is carried by `flowAt`,
-     * wherever annihilation is shortening it. And the source's own direction
-     * is turned by how steeply that flow falls away — not by being pushed,
-     * but because a straight line through ground that is running downhill
-     * across it does not stay straight.
-     *
-     * The turning is `fallAt`, taken across the direction of travel only, so
-     * that a change of direction is all it can ever be. Nothing here changes
-     * speed.
-     *
-     * They stop when they are adjacent, which is not a fudge to keep them
-     * apart: a source is not space, so there is nothing left between them to
-     * annihilate and nothing either could move through if there were.
-     */
-    const TOUCH = 1;                              // as close as adjacent gets
-
-    function pull(dt: number) {
-      // Where space is going, worked out once for the whole picture. After
-      // this nothing asks about sources again — only about places.
-      survey(live, t, span);
-
-      // What the annihilation does to the space, carried forward and let
-      // travel. See `warpStep` — this is where gravity now lives.
-      warpStep(field, dt);
-
-      /**
-       * And what each source is carried by is the SPEED of the space it is
-       * standing in, not the annihilation happening elsewhere at this moment.
-       *
-       * Which is the whole difference. A contraction over there reaches here
-       * when the wave carrying it does, and having arrived it leaves this
-       * place displaced for good — so a source goes on being where the space
-       * put it after the eating has stopped, and feels nothing at all from an
-       * annihilation whose news has not yet arrived.
-       */
-      const carry = live.map(s => {
-        warpAt(field, field.vx, field.vy, s.at[0], s.at[1]);
-
-        let cx = WARP[0], cy = WARP[1];
-
-        // And what the others have laid down behind them. Never its own —
-        // see `wakeAt`.
-        for (const o of live) {
-          if (o === s) continue;
-
-          wakeAt(o, s.at[0], s.at[1], t);
-
-          cx += WAKE[0]; cy += WAKE[1];
-        }
-
-        return [cx, cy] as [number, number];
-      });
-
-      const turned = live.map(s => {
-        /**
-         * Turned by the slope of the ground, and only across the way it is
-         * going.
-         *
-         * The part of that slope pointing along the direction of travel is
-         * dropped before anything is added, which is what keeps this a
-         * turning and not a pull. Renormalising afterwards would have hidden
-         * the difference and did: what used to be here took the flow's change
-         * along the line of travel, which for a river running straight in is
-         * a change of length and no change of angle at all, and then handed
-         * that length to the renormalisation to be thrown away. Measured, it
-         * delivered a hundredth of what an orbit needs and most of that
-         * parallel — so a pair sent past each other flew past each other, the
-         * line between them swung forty degrees the way any two things
-         * passing would, and stopped. Which is exactly the complaint: no
-         * orbit, just a flyby with the arithmetic of one.
-         *
-         * Across the direction of travel there is nothing to throw away.
-         * `fallAt` is the free-fall acceleration and a component of it
-         * perpendicular to a velocity can only rotate that velocity — so the
-         * speed is left exactly alone by construction, and the
-         * renormalisation below is now just tidying the second-order error of
-         * a finite step rather than doing the work.
-         */
-        const speed = Math.hypot(s.vel[0], s.vel[1]);
-        if (speed < 1e-9) return s.vel;
-
-        fallAt(field, s.at[0], s.at[1]);
-
-        const hx = s.vel[0] / speed, hy = s.vel[1] / speed;
-        const along = FALL[0] * hx + FALL[1] * hy;
-
-        const vx = s.vel[0] + (FALL[0] - along * hx) * dt;
-        const vy = s.vel[1] + (FALL[1] - along * hy) * dt;
-
-        const now = Math.hypot(vx, vy);
-        if (now < 1e-9) return s.vel;
-
-        return [vx * speed / now, vy * speed / now] as [number, number];
-      });
-
-      for (let i = 0; i < live.length; i++) {
-        const s = live[i];
-
-        s.vel = turned[i];
-
-        s.at[0] += (s.vel[0] + carry[i][0]) * dt;
-        s.at[1] += (s.vel[1] + carry[i][1]) * dt;
-      }
-
-      // Not through one another: a source is not space.
-      for (let i = 0; i < live.length; i++) {
-        for (let j = i + 1; j < live.length; j++) {
-          const a = live[i], b = live[j];
-
-          const dx = b.at[0] - a.at[0], dy = b.at[1] - a.at[1];
-          const gap = Math.hypot(dx, dy);
-          if (gap >= TOUCH || gap < 1e-9) continue;
-
-          const back = (TOUCH - gap) / 2;
-          const ux = dx / gap, uy = dy / gap;
-
-          a.at[0] -= ux * back; a.at[1] -= uy * back;
-          b.at[0] += ux * back; b.at[1] += uy * back;
-        }
-      }
-
-      /**
-       * And the trail is NOT carried with it, which is the whole of what
-       * makes any of this local.
-       *
-       * It was, and the argument for it sounded right: a ring is centred
-       * where its source was when it left, that place is in the space too,
-       * and if the space is going then so is everywhere in it. What that
-       * argument misses is that the trail is not a set of places. It is a
-       * RECORD of where something was at a moment, and a record that gets
-       * amended is not a record of anything.
-       *
-       * Amended every frame, every position in it drifts a little further
-       * from what was actually the case — so `was` gives a different answer
-       * today than it gave yesterday for the same instant, and every wave in
-       * the air, however old, quietly re-centres itself on the answer. Rings
-       * laid down a hundred ticks ago get up and move because their source
-       * has since been pulled somewhere. Nothing that has already happened
-       * may depend on anything that happened after it, and this was the last
-       * place in the model where it did.
-       */
-    }
-
-    return {
-      start: reset,
-
-      frame: (surface, elapsed) => {
-        // Seconds to ticks, which is the only clock this has. There is no
-        // state carried between frames beyond it, so `t` may be any real
-        // number and the waves travel smoothly rather than a cell at a time.
-        const dt = elapsed * rate;
-
-        t += dt;
-
-        if (t >= cycle) reset();
-        else pull(dt);
-
-        remember();
-
-        draw(surface);
-      },
-
-      // The buffer this holds on to, over and above the canvas the view hands
-      // back for it. There is no other state in it besides a clock.
-      stop: () => {
-        buf.width = 0;
-        buf.height = 0;
-        img = null;
-      },
-    };
-  }}
-/>;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
index 60656c8..24f6866 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
@@ -825,6 +825,46 @@ export class Graph {
    * came instead of setting off somewhere new — and if there is no way back
    * yet then the way back is something it has to have, so it gets one.
    */
+  /**
+   * Two alike charges, each leaving along the other's heading.
+   *
+   * NOT a reversal, which is what this used to do to both of them. Reversing
+   * is the head-on answer, and head-on is one case out of the twenty-six: it
+   * was being applied at every angle, so two charges crossing at a corner both
+   * turned straight back down the roads they came on, which is not a bounce,
+   * it is two bounces that happen to be drawn on top of each other.
+   *
+   * Swapping their headings is what a bounce between equal partners is. Read
+   * the three cases and it is the whole rule:
+   *
+   *   head-on      →  ←     they swap, so each goes back  →  ←  becomes ←  →
+   *   at an angle  ↗  ↖     they swap, so the pair comes in as a ^ and leaves
+   *                         as a v — converging before, diverging after
+   *   side by side ↗  ↗     they swap, and nothing changes, which is right:
+   *                         two charges going the same way have not met so
+   *                         much as arrived together
+   *
+   * Momentum is conserved by construction, since the two headings are only
+   * exchanged and never invented. And the scattered pair is not spent: each is
+   * still a charge going somewhere, and what it meets next is likely to be the
+   * shell behind the one it just met, which carries the opposite charge. So a
+   * turn is a DELAY rather than a loss — measured in transport, letting the
+   * scattered charge carry on and meet its own source's earlier shells makes
+   * the pull 16% stronger at eight cells, falling away to nothing by ninety.
+   */
+  private scatter(one: Ray, a: Boundary, two: Ray, b: Boundary) {
+    // Where each is going now, before either is changed.
+    const mine = this.bare(a), theirs = this.bare(b);
+
+    // Each leaves along the other's, by whichever of its own ways out comes
+    // nearest to it — a ray may only use directions it has.
+    const onto = (ray: Ray, want: number[] | undefined, was: Boundary) =>
+      ray.moving = (want && this.along(ray, want, 1)) ?? this.along(ray, this.bare(was), -1) ?? ray.moving;
+
+    onto(one, theirs, a);
+    onto(two, mine, b);
+  }
+
   private turnAround(ray: Ray, a: Boundary) {
     const dir = this.direction(a);
 
@@ -1272,27 +1312,70 @@ export class Graph {
 
         r.heading = head;
 
-        // The ways this direction is made of. Its own pieces only: a step of
-        // (1,1,1) is (1,0,0) and (0,1,0) and (0,0,1) taken at once, and those
-        // three are the whole of what taking it apart can mean. Their
-        // opposites are not detours down the same road, they are a different
-        // road — a ray that takes them is not going where it was going, and
-        // the direction stops meaning anything.
+        /**
+         * The ways this direction can be taken — and there are two kinds,
+         * where there used to be one.
+         *
+         * TAKING IT APART, which is what this always did. A step of (1,1,1)
+         * is (1,0,0) and (0,1,0) and (0,0,1) taken at once, and those three
+         * are the whole of what breaking it up can mean. Their opposites are
+         * not detours down the same road, they are a different road — a ray
+         * that takes them is not going where it was going.
+         *
+         * AND PUTTING SOMETHING ON IT, which is new and is the half that
+         * matters. A ray heading (1,0,0) can go (1,1,0) or (1,0,1) or
+         * (1,0,−1) instead: still going the way it was going — the component
+         * it had is untouched — with one step of sideways added. `heading`
+         * is not changed by either kind, so whatever it does it comes back
+         * onto the line it set out on, and the deviation is a wander about
+         * that line rather than a change of course.
+         *
+         * WHY IT HAS TO EXIST. Without it a heading can only ever LOSE
+         * components, so a ray emitted into a plane stays in that plane for
+         * ever — (1,1,0) breaks into (1,0,0) and (0,1,0) and neither has a z
+         * to speak of. And a turning magnet emits into a plane by
+         * construction: its poles are in the plane and the axis it turns
+         * about sits on the equator, which emits nothing (see the emission
+         * pass below). So the field it lays down was a disk made of eight
+         * spokes, and the closed form beside it assumes a sphere — `chance`
+         * in `field.ts` divides by 4πr², which is the surface of one, and
+         * that is where its inverse square comes from.
+         *
+         * With this, the emission is still a disk and the TRAVEL is not: a
+         * charge put out into the plane wanders off it a step at a time,
+         * comes back towards the line it was given, and the aggregate over
+         * many charges and many pulses is a sphere. Which is the only way
+         * the two readings can be saying the same thing — a disk of spokes
+         * thins as 1/r and a sphere thins as 1/r², and only one of those is
+         * Newton.
+         */
         const ways: number[][] = [head];
 
         for (let axis = 0; axis < head.length; axis++) {
-          if (!head[axis]) continue;
-
-          const one = new Array(head.length).fill(0);
-          one[axis] = head[axis];
-
-          ways.push(one);
+          if (head[axis]) {
+            // Taken apart: this piece of it on its own.
+            const one = new Array(head.length).fill(0);
+            one[axis] = head[axis];
+
+            ways.push(one);
+          } else {
+            // Or the same direction with one step of sideways on it, either
+            // way round. Both, so the wander has no handedness and a great
+            // many charges spread evenly about the line rather than drifting
+            // off it.
+            for (const side of [1, -1]) {
+              const off = head.slice();
+              off[axis] = side;
+
+              ways.push(off);
+            }
+          }
         }
 
-        // Straight on unless it draws otherwise, and always the whole
-        // direction if there is nothing it can be broken into — an axial
-        // heading has no longer way round.
-        const way = ways.length > 2 && Math.random() < this.wander
+        // Straight on unless it draws otherwise. Every heading has somewhere
+        // sideways to go now, so there is no longer a case with nothing to
+        // choose from.
+        const way = ways.length > 1 && Math.random() < this.wander
           ? ways[1 + Math.floor(Math.random() * (ways.length - 1))]
           : head;
 
@@ -1527,8 +1610,7 @@ export class Graph {
         this.annihilate(it.r, it.a, it.r2, it.b, removed);
       } else {
         this.stats.turned++;
-        this.turnAround(it.r, it.a);
-        this.turnAround(it.r2, it.b);
+        this.scatter(it.r, it.a, it.r2, it.b);
       }
     }
 
@@ -1556,7 +1638,6 @@ export class Graph {
       r.moving = undefined;
       r.wave = undefined;
       r.age = 0;
-      r.fanned = false;
       r.heading = undefined;
 
       for (const bd of r.boundaries) bd.polarity = Polarity.Neutral;
@@ -2131,8 +2212,6 @@ export class Graph {
        * crossing can tell from space.
        */
       range = 14,
-      spread = 0.45,
-      fanAt,
     }: World,
   ): Graph {
     const graph = new Graph();
@@ -2168,13 +2247,6 @@ export class Graph {
     // edge, when in fact they are running the whole way to it.
     graph.focus = radius - 2;
 
-    // Far enough out that a shell has room for its fan, and close enough in
-    // that it has fanned before it gets to whatever it is going to meet —
-    // which is halfway to the nearest other source.
-    const gap = spacing(sources);
-
-    const fan = fanAt ?? Math.max(Math.floor((gap ?? radius / 1.5) / 4), 2);
-
     const count = sources.length;
 
     sources.forEach((source, index) => {
@@ -2274,7 +2346,6 @@ export class Graph {
           ray.wave = undefined;
           ray.heading = undefined;
           ray.age = 0;
-          ray.fanned = false;
           for (const bd of ray.boundaries) bd.polarity = Polarity.Neutral;
         }
       }
@@ -2409,56 +2480,85 @@ export class Graph {
             const north = ray.axis && unit(ray.axis);
 
             /**
-             * Into its poles, and nowhere else.
+             * Into the SHEET its axis lies in — eight directions, not two.
+             *
+             * A point has `3^d − 1` ways out of it and a source pulses into a
+             * plane of them: the 3×3 around it, which is eight in three
+             * dimensions and is what `SHEET` in `field.ts` counts. That is
+             * where the size of the emission comes from, and this emitted two
+             * — its poles alone — so every density downstream was a quarter of
+             * what the closed form assumes.
              *
-             * This used to write onto every direction the source had, using
-             * the axis only to decide WHICH charge each got — north's out of
-             * the half facing along it, south's out of the half facing back,
-             * nothing on the equator. Which is a dipole sprayed over a whole
-             * sphere, and it is why nothing here had a distance law: a fixed
-             * budget spread over a fixed number of directions does not thin
-             * with radius at all.
+             * WHICH plane, and it has to be the one containing the axis and
+             * the axis it turns ABOUT. Not the turn's own plane: that one is
+             * already fixed, so a sheet lying in it never goes anywhere and
+             * what comes out is the disk this had before. Containing `north`
+             * and `up`, the sheet stands on edge and comes round WITH the
+             * axis, and over a revolution it has swept the sphere — which is
+             * the claim `field.ts` makes and the thing the lattice was not
+             * doing.
              *
-             * A magnet emits along its poles. Two directions, and as the axis
-             * comes round an eighth of a turn a tick, over one revolution
-             * those two visit all eight directions of the plane — so the
-             * emission sweeps rather than fills, and what a place at radius r
-             * receives is a fixed budget spread over the shell there. In two
-             * dimensions that is 2πr and the field goes as 1/r; in three the
-             * plane precesses and it is 4πr² and 1/r².
+             * So `side` is the one direction perpendicular to both, and the
+             * sheet is everything with no component along it.
              *
-             * On a lattice the sweep is the alternation you would otherwise
-             * have to arrange: consecutive eighth-turns step axial, diagonal,
-             * axial, so stepping the ring IS alternating between them, and
-             * nothing has to special-case which is which.
+             * TWO OF THE EIGHT ARE SILENT, and it is worth knowing rather
+             * than discovering. Any plane containing `north` also contains
+             * the two directions square to it, and those sit on the dipole's
+             * equator, which emits nothing (see `quantised`). So a sheet of
+             * eight puts out six, and the sweep is what covers the rest.
              */
-            const poles: Boundary[] = [];
+            const sheet: Boundary[] = [];
+
+            // The in-sheet direction square to north, so a boundary's bearing
+            // WITHIN the sheet can be worked out and split half-open.
+            let perp: number[] | undefined;
 
             if (north) {
-              let out: Boundary | undefined, back: Boundary | undefined;
-              let most = -Infinity, least = Infinity;
+              // The axis it turns about: square to the plane the ring lies
+              // in. A quarter of the way round the ring is square to the
+              // start of it, so the two of them span that plane.
+              const ring = ray.ring ?? TURN;
+              const a = ring[0], b = ring[Math.floor(ring.length / 4)] ?? ring[1];
+
+              const up = unit([
+                (a[1] ?? 0) * (b[2] ?? 0) - (a[2] ?? 0) * (b[1] ?? 0),
+                (a[2] ?? 0) * (b[0] ?? 0) - (a[0] ?? 0) * (b[2] ?? 0),
+                (a[0] ?? 0) * (b[1] ?? 0) - (a[1] ?? 0) * (b[0] ?? 0),
+              ]);
+
+              const side = unit([
+                (north[1] ?? 0) * (up[2] ?? 0) - (north[2] ?? 0) * (up[1] ?? 0),
+                (north[2] ?? 0) * (up[0] ?? 0) - (north[0] ?? 0) * (up[2] ?? 0),
+                (north[0] ?? 0) * (up[1] ?? 0) - (north[1] ?? 0) * (up[0] ?? 0),
+              ]);
+
+              const flat = side.some(v => v);
+
+              // up x north: in the sheet, square to north. With `north` it
+              // spans the sheet, so any direction in there resolves against
+              // the two of them into a bearing.
+              perp = unit([
+                (up[1] ?? 0) * (north[2] ?? 0) - (up[2] ?? 0) * (north[1] ?? 0),
+                (up[2] ?? 0) * (north[0] ?? 0) - (up[0] ?? 0) * (north[2] ?? 0),
+                (up[0] ?? 0) * (north[1] ?? 0) - (up[1] ?? 0) * (north[0] ?? 0),
+              ]);
 
               for (const bd of ray.boundaries) {
-                const facing = bd.target;
-                if (!facing) continue;
+                if (!bd.target) continue;
 
                 const d = g.direction(bd);
                 if (!d) continue;
 
-                const along = dot(d, north);
-
-                if (along > most) { most = along; out = bd; }
-                if (along < least) { least = along; back = bd; }
+                // In the sheet: nothing along the one way out of it. The
+                // threshold is the same eighth-turn `turnRing` rounds at.
+                if (!flat || Math.abs(dot(d, side)) < 0.3827) sheet.push(bd);
               }
-
-              if (out) poles.push(out);
-              if (back && back !== out) poles.push(back);
             }
 
-            // A lamp has no poles and no sweep: it puts the same thing out
+            // A lamp has no axis and no sheet: it puts the same thing out
             // everywhere, which is what makes it a set of rings rather than
             // an arm, and there is nothing to narrow.
-            const into = hasSides ? poles : [...ray.boundaries];
+            const into = hasSides ? sheet : [...ray.boundaries];
 
             for (const bd of into) {
               const facing = bd.target;
@@ -2501,10 +2601,47 @@ export class Graph {
                * between the two kinds: an equator is a real answer of nought,
                * and a source with no equator has no such answer to give.
                */
-              const strength = emission(hasSides, beta, () => dot(dir, north!));
+              /**
+               * FOUR ONE WAY AND FOUR THE OTHER, which is what makes it eight.
+               *
+               * Read by the direction's bearing WITHIN the sheet, half-open,
+               * rather than by the sign of its resolution against north — and
+               * the difference is exactly the two directions square to north.
+               *
+               * By the dot product those two are a genuine nought: they sit
+               * on the dipole's equator, `quantised` calls them Neutral, and
+               * the sheet puts out six. But a ring of eight split by a line
+               * through two of them is three, two silent, three — and a
+               * source that emits six of its eight has no inverse square,
+               * because `chance` divides the emission by the shell and the
+               * emission has to be all of it.
+               *
+               * Split half-open instead and the eight come out four and four,
+               * with the two on the line falling opposite ways. Which is not
+               * a new rule: `quantised` already does exactly this for a
+               * source with no sides, and says why — "half-open, so the two
+               * instants fall opposite ways and the halves come out equal —
+               * four cells of one charge and four of the other". The sided
+               * branch never got it. It has it now, and a magnet and a lamp
+               * are quantised the same way.
+               */
+              let charge: Polarity;
+
+              if (hasSides && perp) {
+                // Where this direction lies in the sheet, in turns from north.
+                const turns =
+                  Math.atan2(dot(dir, perp), dot(dir, north!)) / (Math.PI * 2);
+
+                const half = turns + 0.25;
+
+                charge = half - Math.floor(half) < 0.5
+                  ? Polarity.Positive : Polarity.Negative;
+              } else {
+                const strength = emission(hasSides, beta, () => dot(dir, north!));
 
-              const charge = quantised(strength, hasSides, beta);
-              if (charge === Polarity.Neutral) continue; // the equator
+                charge = quantised(strength, hasSides, beta);
+                if (charge === Polarity.Neutral) continue;
+              }
 
               // Which way round the source is putting it out. `emits` is what
               // its north pole gives, so a positive strength is that and a
@@ -2605,109 +2742,30 @@ export class Graph {
       }
 
       /**
-       * Once each, and not straight away.
+       * A SHELL IS NOT REPOPULATED, and this is where it used to be.
        *
-       * Concentric shells one step apart, one per tick, moving one step per
-       * tick, are exactly the shells that tile a ball — so filling every one
-       * of them fills the ball completely, and a ball with no space in it is
-       * a ball in which nothing can move, since moving is trading places with
-       * space. That is not a near miss to be tuned around; unit shells at
-       * every radius sum to the volume they sit in, and it is why spreading
-       * on every tick froze the field solid.
+       * There was a fan here: once a charge got out past `fanAt` it spawned
+       * copies of itself into the ring of directions across its path, so that
+       * a pulse stayed a filled surface however far out it got. It was put
+       * there before it was understood what the falloff had to be, and it is
+       * exactly what stops the falloff happening.
        *
-       * What is affordable is a fixed number of points per shell rather than
-       * a filled one: each ray fans out ONCE, into the ring of directions
-       * across its path, and its children never fan again. A pulse is then
-       * twenty-six rays and their fan — a couple of hundred points — however
-       * far out it gets.
+       * A source lets go of a fixed number of charges and they spread. That
+       * spreading is the whole of the inverse square: the same count over a
+       * shell that has grown as r², which is `chance` in `field.ts` and the
+       * reason it divides by 4πr². Duplicating the charges as they go keeps
+       * the count up with the shell instead, and a fixed count per shell does
+       * not thin at all — measured, the density fell as r^-0.66 where it has
+       * to fall as r^-2, and the missing power was the fan putting back what
+       * the spreading had just taken away.
        *
-       * And it waits until `fanAt` before doing it. A shell of radius two has
-       * only a few dozen cells in it and is already as full as it can be, so
-       * fanning immediately puts every child straight into the crush around
-       * the source, walls the source in, and stops the emission. Waiting
-       * until the shell is wide enough to have somewhere to put them spends
-       * the same points where there is room for them — and where they are
-       * wanted, since what a shell is for is meeting the other one, and that
-       * happens out at the distance between the sources rather than next
-       * door.
+       * What fills the shell instead is `wander`: a charge deviates onto a
+       * diagonal and comes back onto the line it was given, so the emission
+       * is a disk and the TRAVEL is a sphere, and the aggregate over many
+       * charges and many pulses is round without anything being copied. One
+       * charge emitted is one charge in flight, from the source to wherever
+       * it stops being one.
        */
-      if (spread <= 1) {
-        const front: { ray: Ray, dir: number[], polarity: Polarity, wave?: number }[] = [];
-
-        for (const nd of g.nodes) {
-          for (const ray of nd) {
-            if (ray.magnet || !ray.moving) continue;
-            if (ray.moving.polarity === Polarity.Neutral) continue;
-
-            // Age is counted in `tick`, once, for everything in flight.
-            if (ray.fanned || (ray.age ?? 0) < fan) continue;
-
-            const dir = g.direction(ray.moving);
-            if (!dir) continue;
-
-            ray.fanned = true;
-            front.push({ ray, dir, polarity: ray.moving.polarity, wave: ray.wave });
-          }
-        }
-
-        for (const { ray, dir, polarity, wave } of front) {
-          for (const bd of ray.boundaries) {
-            const facing = bd.target;
-            if (!facing) continue;
-
-            const there = facing.at.node;
-            if (there === ray.node) continue;
-            if (there.some(r => r.moving || r.magnet)) continue;
-
-            const d = g.direction(bd);
-            if (!d) continue;
-
-            // BESIDE us — not behind, and not ahead either.
-            //
-            // Behind is everywhere the wave has already been, and filling
-            // that in is a wave that never leaves anywhere. Ahead is where we
-            // are going ourselves, and filling that in is a wave that thickens
-            // into a solid ball instead of staying a surface. What is left is
-            // the ring of directions across our path, which is the front
-            // itself: the shell grows sideways, into the room a bigger shell
-            // has that a smaller one didn't.
-            const along = dot(d, dir);
-            if (along < spread || along > ALONG) continue;
-
-            for (const r of there)
-              for (const x of r.boundaries) x.polarity = polarity;
-
-            // And it leaves in the direction between ours and its own, so the
-            // front fans out as it goes rather than travelling as a sheaf of
-            // parallel lines. Twenty-six directions repeatedly split between
-            // is how a lattice with twenty-six of them makes a round shell.
-            const bias = dir.map((v, i) => v + d[i]);
-
-            facing.at.moving = g.along(facing.at, bias, 1);
-            facing.at.wave = wave; // still the same pulse, spread wider
-            facing.at.source = ray.source;
-            facing.at.turning = ray.turning;
-            facing.at.age = ray.age;
-
-            // And it travels at the speed its parent does.
-            //
-            // Without this a fanned charge is quick and the charge it came
-            // from is slow — three times as quick, where the source is one
-            // that turns — so it runs out through the shell ahead of it and
-            // the one ahead of that, carrying its own polarity into the
-            // middle of theirs. Every shell ends up holding both charges at
-            // once, mixed, and the neat alternation that IS the spiral is
-            // stirred out of the field before anything gets to draw it.
-            facing.at.mass = ray.mass;
-
-            // Already fanned, as far as it is concerned. Otherwise each child
-            // fans in turn and the shell doubles every tick until it has
-            // filled everything, which is where this started.
-            facing.at.fanned = true;
-            facing.at.age = ray.age;
-          }
-        }
-      }
     };
 
     return graph;
@@ -2809,7 +2867,6 @@ export class Graph {
         r.credit = ray.credit;
         r.mass = ray.mass;
         r.age = ray.age;
-        r.fanned = ray.fanned;
         r.axis = ray.axis?.slice();
         r.turning = ray.turning;
         r.ring = ray.ring;
@@ -3211,11 +3268,10 @@ export class Ray {
   source?: number;
   wave?: number;
 
-  // How many ticks a charge has been in flight, and whether it has yet fanned
+  // How many ticks a charge has been in flight.
   // out into the room a bigger shell has that a smaller one hadn't. See the
   // Huygens step in `Graph.sources`.
   age?: number;
-  fanned?: boolean;
 
   /**
    * The way it is going in the large, which is not the same as the step it is
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
index 880974c..2b5dd40 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
@@ -7,7 +7,7 @@
  *   emit         = front · fade · shape · F(d̂)    what one source puts here
  *     front      = min((ct − r)/1.5, 1)           nothing before it arrives
  *     chance(m,r)= m·SHEET / shell(r)              NOT a falloff law:
- *     shell(r)   = Ω·max(r, HALF)^(DIMS − 1)       one charge's worth
+ *     shell(r)   = Ω·max(r, HALF)^(DIMS−1) + FLOOR one charge's worth
  *                  over how much shell there is to share it out across. The
  *                  inverse square is what that COMES TO in three dimensions,
  *                  not something stated — change how the waves are sent out
@@ -20,6 +20,13 @@
  *
  *   R(d̂)         = (gap/2) / (d̂·û)   for d̂·û > HEAD_ON, else ∞
  *                                                 where a wave MAY stop
+ *   SHEET  = 3^(d−1) − 1 = 8      how many charges one pulse is
+ *   WAYS   = 3^d − 1     = 26      how many ways out of a point there are —
+ *                                  a DIFFERENT number, and the one the
+ *                                  counting argument in `gravity.ts` needs
+ *   FLOOR                          the innermost shell is not nought cells
+ *                                  across. See `shell`.
+ *
  *   through(m,r) = max(1 − chance(m, r), 0)       and how much of it doesn't:
  *                  the chance the cell it arrives at is EMPTY. Close in that is
  *                  nought and the surface is a wall; far out it is nearly one
@@ -89,7 +96,36 @@ export const HALF = 0.5;
  * departure is a fact about short range and about nothing else, which is what
  * a departure arising from the graininess of the thing ought to look like.
  */
-export const shell = (r: number) => SPHERE * Math.pow(Math.max(r, HALF), DIMS - 1);
+export const shell = (r: number) =>
+  SPHERE * Math.pow(Math.max(r, HALF), DIMS - 1) + FLOOR;
+
+/**
+ * How many cells the innermost shell has, which is not nought and was being
+ * taken as nought.
+ *
+ * `SPHERE·r^(d−1)` is the surface of a CONTINUUM sphere, and `SHEET` is a
+ * count off the LATTICE — eight of the twenty-six ways out of a point. Divide
+ * one by the other at r = HALF and the model puts eight charges onto
+ * `4π(0.5)² = 3.14` places, so `chance` comes out at 2.546: a probability, over
+ * one. Nobody had evaluated the floor to see what number it gives.
+ *
+ * The lattice's own shell at d steps is the surface of a cube, `24d² + 2` in
+ * three dimensions — twenty-six at one step, which is exactly the ways out of
+ * a point. The `+2` is the two caps the continuum formula has no room for, and
+ * it is the whole of the difference at the core: with it, `chance` at HALF is
+ * `8/(4π·0.25 + 2)`, and with `SPHERE` read off the same cube it is 8/8 = 1
+ * exactly. Saturated, never exceeded, which is what a probability may do.
+ *
+ * WHAT IS STILL OPEN, because this only half-settles it. `24d²` counts cells
+ * at CHEBYSHEV distance d — where a charge has got to after d ticks — while
+ * `chance(m, r)` is asked with the EUCLIDEAN separation of two bodies. On a
+ * 26-connected lattice those differ by up to √3 depending on direction, and
+ * that is the same graph-distance-against-coordinates confusion that makes the
+ * lattice's occupancy hard to read at all. The floor here is the piece that is
+ * certainly wrong without it; the factor of 24/4π between the two measures is
+ * the piece that needs that question answered first.
+ */
+export const FLOOR = 2;
 
 /**
  * How much shell there is at radius one — the surface of the unit sphere in
@@ -124,6 +160,24 @@ const SPHERE = DIMS === 3 ? 4 * Math.PI : DIMS === 2 ? 2 * Math.PI : 2;
  */
 export const SHEET = Math.pow(3, DIMS - 1) - 1;
 
+/**
+ * And how many ways out of a point there are ALTOGETHER, which is a different
+ * number and was being conflated with the one above.
+ *
+ * `3^d − 1`: twenty-six in three dimensions, eight in two. Measured on the
+ * lattice directly — a breadth-first walk from any point reaches exactly 26 at
+ * one step in three dimensions and exactly 8 in two.
+ *
+ * The distinction matters because `SHEET` is an EMISSION count — how many
+ * charges a source lets go of in one pulse, which is the plane it pulses into
+ * — while the counting argument behind `BIAS` needs the number of ALTERNATIVE
+ * directions a biased path could have taken instead. Those are the ways out of
+ * the point, all of them, not the ones this particular source happened to emit
+ * along. `gravity.ts` used `SHEET` for both, which understated the denominator
+ * by a factor of 3.25 in three dimensions.
+ */
+export const WAYS = Math.pow(3, DIMS) - 1;
+
 /**
  * The chance that a given cell at radius r is holding one of this source's
  * charges.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index 0a4fa01..3648fee 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -1,26 +1,126 @@
 /**
  * EQUATIONS IN THIS FILE
  *
- *   opposed(ψ)  = |ψ| / π                         how much of a meeting cancels
- *   screen(x)   = Π_c through(m_c, |x − r_c|)     what a third body shadows
- *
- *   S(a,b)      = BITE ∫₀^R chance(m_a,s)·chance(m_b,R−s)·opposed·screen ds
- *                                                 meetings a tick along a→b
- *
- *   BIAS        = LIGHT / SHEET                   what one annihilation buys
- *   pace(u)     = u / √(1 + |u|²/LIGHT²)          what a count comes to as a
- *                                                 speed in the picture
- *
- *   u̇_a         = BIAS · S(a,b) / m_a             the pull, per body, per tick
- *
- *   G           = SHEET / (4π² · HALF)            the far-field constant, in
- *                                                 closed form — not calibrated
+ *   what a source puts on a place, and what two of them do where they meet:
+ *     chance(m,r) = m·SHEET / shell(r)             one pulse over the shell it
+ *                                                  has grown to. The inverse
+ *                                                  square is what that COMES
+ *                                                  TO in three dimensions.
+ *     opposed(ψ)  = |ψ| / π                        how much of a meeting cancels
+ *     share       = ⟨opposed⟩ over the path        settled once for the pair,
+ *                   differences, Hann-windowed     ½ unless they keep time
+ *     screen      = Π_c through(m_c, ⊥ to a→b)     what a third body shadows
+ *
+ *   the pull, and it is an integral along ONE line — the line whose length is
+ *   the distance between them, which is the line annihilation shortens:
+ *     met(R)      = ∫₀^R dx / (max(x,CORE)²·max(R−x,CORE)²)   exactly:
+ *                 = 2/(CORE·R(R−CORE))                the two cores
+ *                 + (2/R²)(1/CORE − 1/(R−CORE))       their outsides
+ *                 + (4/R³)·ln((R−CORE)/CORE)          the open middle
+ *     S(a,b)      = BITE·share·screen·m_a·m_b·EMIT²·met(R)     meetings a tick
+ *
+ *   The first two terms are the inverse square and go as 1/CORE. The third is
+ *   a RUNNING of the constant with separation, and it carries no CORE at all —
+ *   so the ratio between them is CORE/R, and how many core radii apart two
+ *   things are is the only thing that has ever moved it. See `GRAIN`.
+ *
+ *   what a count of annihilations does to a body:
+ *     BIAS        = LIGHT / WAYS                   what one of them buys, and
+ *                                                  the only constant here
+ *     u̇_a         = BIAS · S(a,b) / m_a            ÷ its OWN mass, which is
+ *                                                  the equivalence principle
+ *     pace(u)     = u / √(1 + |u|²/LIGHT²)         and what a count comes to
+ *                                                  as a speed in the picture
+ *
+ *   Everything below falls out of those and none of it is stated: at rest,
+ *   Newton; differentiated, 1/γ³ along the way a thing is going and 1/γ
+ *   across it, which is special relativity's own response; and ÷ m_a leaves
+ *   a_a ∝ m_b/R², so a feather and a hammer fall together.
+ *
+ *   G           = SHEET² / (4π²·CORE·WAYS)         the far limit of `met`, in
+ *                                                  closed form. Every symbol
+ *                                                  is a count. Nothing fitted.
+ *
+ *   what it still owes: at v = c the count is already infinite, so one more
+ *   annihilation turns it by nothing — light does not fall here. See `pace`.
  *
  */
 
-import { chance, HALF, Live, SHEET, through } from "./field";
+
+import { chance, HALF, Live, SHEET, through, WAYS } from "./field";
 import { BITE, LIGHT } from "./physics";
 
+/**
+ * How many lattice steps a drawn cell stands for.
+ *
+ * THE ONE NUMBER THAT DECIDES WHETHER THIS MODEL IS NEWTON, so it is worth
+ * saying what it is doing here rather than in `models.ts`.
+ *
+ * The line integral below is not an inverse square. It is `1/R²` from the two
+ * cores plus `CORE·ln(R/CORE)/R` from the open middle — the constant RUNS with
+ * separation, logarithmically. Nothing removes that: measured, it is identical
+ * on a sphere, a cube, an octahedron and an invented shell measure, it gets
+ * worse under survival weighting, worse again if a body is spread over many
+ * cells, and swapping the line for a space integral gives `1/R` instead. It
+ * follows from `shell ∝ r²`, which follows from three dimensions, and it is
+ * the same expansion that produces the inverse square in the first place.
+ *
+ * What it depends on is the RATIO `CORE/R` — how many core radii apart the two
+ * things are. And that ratio was being read off the drawing. `HALF` is half a
+ * lattice step, which is right; but `models.ts` draws twenty-eight cells to
+ * the astronomical unit so that a wave is visible, so Mercury sat eight cells
+ * from the Sun and the running was 16%. A picture's zoom was setting the force
+ * law — the same class of mistake as the display gain that used to be in
+ * `bend` and `carry`, one level further in.
+ *
+ * A lattice step is a length, not a pixel. If it is anything like a
+ * fundamental one then Sun and Mercury are an astronomical number of them
+ * apart and the running is nothing at all. So the drawn cell is declared to
+ * stand for this many of them, and the law is evaluated at the separation the
+ * bodies actually have.
+ *
+ * Any value past about a million is indistinguishable — the term goes as
+ * `ln(GRAIN)/GRAIN` — so this is not a fitted parameter with a best value; it
+ * is a statement that the two scales are not the same scale, and one round
+ * number standing for "very much larger than the picture".
+ */
+export const GRAIN = 1e12;
+
+/** And so the core, in drawn cells. */
+const CORE = HALF / GRAIN;
+
+/**
+ * The line between two things, integrated — exactly, with no walk.
+ *
+ * There used to be a numerical walk here: a few hundred samples along the
+ * line, crowded into the ends by `x = R(1 − cos θ)/2` because that is where
+ * the integrand lives. It is gone, and not because the integral is gone —
+ * because `∫₀^R dx / (max(x,h)²·max(R−x,h)²)` has a closed form, and sampling
+ * something you can write down buys nothing but a sample count.
+ *
+ * It buys nothing and it COSTS the thing that matters: a walk can only resolve
+ * a core it puts samples inside, and the innermost sample of that substitution
+ * lands at about `R·π²/16N²`. Resolving a core a trillionth of a cell across
+ * would have taken ten million samples a pair a step. Done exactly, the core
+ * can be as small as it physically is rather than as small as an integrator
+ * can afford.
+ *
+ *     ends    2 / (h·R·(R−h))                    the two half-cells
+ *     near    (2/R²)(1/h − 1/(R−h))              their outsides
+ *     middle  (4/R³)·ln((R−h)/h)                 the open line, and the log
+ *
+ * The first two are the inverse square and go as `1/h`. The third is the
+ * running, and it carries no `h` at all — which is why the ratio between them
+ * is `h/R` and why shrinking the core is the only thing that ever moved it.
+ */
+const met = (R: number, h: number) =>
+  2 / (h * R * (R - h))
+  + (2 / (R * R)) * (1 / h - 1 / (R - h))
+  + (4 / (R * R * R)) * Math.log((R - h) / h);
+
+/** What a source of unit mass puts on the line, per unit of it. */
+const EMIT = SHEET / (4 * Math.PI);
+
 /**
  * The law, with nothing to draw it on.
  *
@@ -50,8 +150,8 @@ import { BITE, LIGHT } from "./physics";
  * Which is a counting argument and it fixes everything, with no constant:
  *
  *     weight of the way it went      1 + n
- *     weight of each other way       1,  and there are SHEET of them
- *     net bias                       LIGHT · n / SHEET
+ *     weight of each other way       1,  and there are WAYS of them
+ *     net bias                       LIGHT · n / WAYS
  *
  * LINEAR in the count, with nothing in it about how fast the thing is already
  * going. So the bias is proportional to the number of annihilations
@@ -60,9 +160,23 @@ import { BITE, LIGHT } from "./physics";
  * speed, and it is the whole of the one-over-time this file could not
  * previously account for. Gravity is an acceleration because space remembers.
  *
+ * WAYS AND NOT SHEET, which this had wrong. `SHEET` is how many charges a
+ * source lets go of in one pulse — the plane it pulses into, eight in three
+ * dimensions. What belongs in the denominator here is how many OTHER
+ * directions the biased path could have taken instead, which is every way out
+ * of the point: `3^d − 1`, twenty-six. The two were one constant, and the
+ * counting argument was being given the emission count in place of the
+ * alternatives it is counting against.
+ *
+ * It moves `GRAVITY` by the same 3.25 and cancels straight back out of every
+ * orbit, because `models.ts` divides the masses by `GRAVITY` — exactly as
+ * `BITE` does. What it does change is the saturation `n/(WAYS + n)`, which is
+ * a real threshold rather than a scale, and is what any accumulated folding
+ * gets read against.
+ *
  * This is the only constant in the dynamics, and it is a ratio of two counts.
  */
-export const BIAS = LIGHT / SHEET;
+export const BIAS = LIGHT / WAYS;
 
 /**
  * And what a bias comes to as a speed IN THE PICTURE — which is not the same
@@ -245,6 +359,88 @@ const opposed = (psi: number) => {
  */
 const density = (s: Live, r: number) => chance(s.mass ?? 1, r);
 
+/**
+ * How much of everything meeting anywhere along the line between two things is opposite —
+ * settled ONCE for the line, and not place by place.
+ *
+ * Which is the difference between a ray and an aggregate, and it is worth
+ * spelling out because it was the largest error left in this model.
+ *
+ * Place by place, the phase between the two arrivals is ω times the path
+ * difference, ω(R − 2x), which sweeps from +ωR at one end to −ωR at the
+ * other and is nought exactly in the middle. That is right FOR A SINGLE RAY.
+ * But the meetings are not spread evenly along the line — the densities
+ * spike at both ends, where each source sits — so the density-weighted
+ * answer was carried almost entirely by the two endpoints, where the phase
+ * is ±ωR. And ±ωR is periodic in R with a period of one wavelength. So the
+ * pull between two things oscillated by a factor of 3.4 as they moved eight
+ * cells, which is not a force law at all. It hid perfectly from measurement
+ * for as long as the separations tried were multiples of the cycle.
+ *
+ * The endpoints are also exactly where a single ray's phase means least. A
+ * charge arriving at a place did not come along the straight line; it came
+ * by whatever path the shell took, and an aggregate is a sum over all of
+ * them. The straight-line path difference is one sample of a spread, and the
+ * spread is widest where the shell is nearest — which is to say, at the ends.
+ *
+ * So the phase is averaged over the line rather than read off it: every path
+ * difference between +ωR and −ωR occurs, and the fraction opposite is the
+ * mean over them.
+ *
+ * WEIGHTED, though, and not flat, which is the part that had to be got right
+ * a second time. A flat average is a hard window on the path difference —
+ * every value in [−ωR, +ωR] counting the same and everything outside it
+ * counting nothing — and a hard window does not converge, it RINGS. What is
+ * left of it goes as one over ωR and oscillates in R with the period of the
+ * pattern, so the pull between two sources alternating at the same rate
+ * still rippled by ±4.5% every four cells at solar separations. Which is not
+ * a force law, and it hid from the previous measurement for the same reason
+ * it hid from the one before that: the separations tried were multiples of
+ * the cycle, and the ripple is exactly nought there. The calibration
+ * separation was one of them.
+ *
+ * The window's own argument says it should not be flat anyway. The extremes
+ * of the range are the two endpoints, which is to say the two sources
+ * themselves, and those are precisely where a straight-line path difference
+ * means least — the shell is nearest, so the spread of real paths arriving
+ * is widest, so the straight line is the worst sample of it there. A raised
+ * cosine says that and nothing more: full weight in the middle, nothing at
+ * the ends, no parameter.
+ *
+ *     R (cells)      1      2      4      8     16     32
+ *     in step        0.07   0.15   0.30   0.50   0.50   0.50
+ *     half a cycle   0.93   0.85   0.70   0.50   0.50   0.50
+ *
+ * — a real, strong effect inside one wavelength, gone beyond it, and gone
+ * SMOOTHLY: the residual ripple over R from twenty to thirty-four cells
+ * falls from 8.45% of the share to 0.32%. Two things a long way apart cannot
+ * be in step in any way that matters, and the model now actually says so
+ * rather than saying it on average and oscillating about it.
+ *
+ * Sources turning at DIFFERENT rates never had a fixed relation to average
+ * in the first place, and go straight to a half.
+ */
+export const coherence = (one: Live, two: Live, R: number) => {
+  if (Math.abs(one.omega - two.omega) > 1e-9) return 0.5;
+
+  const steps = WALK(R);
+
+  let sum = 0, weight = 0;
+
+  // Evenly in the path difference, unlike the walk in `shortfall`: this is an
+  // average over path DIFFERENCES and not over places on the line. The weight
+  // is the window, not a measure.
+  for (let k = 0; k < steps; k++) {
+    const f = (k + 0.5) / steps;
+    const w = 0.5 - 0.5 * Math.cos(TURN_ROUND * f);
+
+    sum += w * opposed(one.omega * (R - 2 * f * R) + (one.phase - two.phase));
+    weight += w;
+  }
+
+  return sum / weight;
+};
+
 /**
  * How much space goes from between two things, per tick.
  *
@@ -261,6 +457,74 @@ const density = (s: Live, r: number) => chance(s.mass ?? 1, r);
  * by twenty-four cells and one and a half by forty-eight. Newton's law, out
  * of a shell growing and two densities meeting on it.
  */
+/**
+ * How much of a source's emission the line between two bodies runs through,
+ * per unit of its mass — `∫ chance(1, x) dx` from the source outward.
+ *
+ * This is the whole of what a body brings to a meeting. `chance` goes as
+ * `1/x²` outside the core and is capped inside it, so the integral converges
+ * and is carried ENTIRELY by the last half-cell: two ends' worth of it, and
+ * `2/HALF` is where the `1/HALF` in `GRAVITY` comes from.
+ */
+const REACH = SHEET / (4 * Math.PI) * (2 / HALF);
+
+/**
+ * How much space goes from between two things, per tick — in the limit that
+ * matters, which is bodies many cells apart.
+ *
+ * THE WALK IS GONE, and this is the one change in this file that alters what
+ * the model predicts, so it is worth the space.
+ *
+ * What was here integrated `chance_a(x)·chance_b(R−x)` along the line, and
+ * that integral is not an inverse square. Partial fractions split it in two:
+ * the `1/x²` pieces are the two cores and give `1/R²`, and the `1/x` pieces
+ * are the open middle and give `ln(R/h)/R³`. So the model's constant RUNS with
+ * separation,
+ *
+ *     G(R) = G_∞ · (1 + HALF·ln(2R)/R)
+ *
+ * — 8.5% at twenty-four cells, 1.5% at two hundred, 0.2% at Neptune's eight
+ * hundred and thirty-five. Logarithmically, which is to say every octave of
+ * distance between the core and the separation contributes the same amount.
+ *
+ * IT IS NOT AN ARTEFACT, and that had to be established before it could be
+ * dealt with honestly. Four things were tried and measured:
+ *
+ *   the domain      integrate over space rather than the line, with the
+ *                   splice's own `sin(θ/2)` weight, and the law comes out
+ *                   `1/R` — the one-dimensional integral is what makes it an
+ *                   inverse square at all
+ *   double counting weight by survival, so a charge that has annihilated is
+ *                   not offered again: the log gets WORSE (the middle has no
+ *                   double counting to remove, only the cores do) and `G`
+ *                   starts varying 50% with mass
+ *   the lattice     sphere, cube, octahedron, or an invented measure — the log
+ *                   is identical in all of them. It follows from `shell ∝ r²`,
+ *                   which follows from three dimensions
+ *   the core        spreading a body over many cells instead of one weakens
+ *                   the `1/R²` (which the core carries) and leaves the log, so
+ *                   the ratio gets worse
+ *
+ * So the log is what the model says, and the only quantity that moves it is
+ * `R/HALF` — how many core radii apart the two things are.
+ *
+ * WHICH IS THE WAY OUT. A source here is ONE CELL. Real bodies are not: if the
+ * cell is anything like a fundamental length, Sun and Mercury sit at `R/HALF ~
+ * 10^40` and the correction is `10^-38`. Macroscopic gravity lives deep in the
+ * asymptote of that running, and this is the model evaluated THERE — the limit
+ * of the same walk, with the same constant, reached rather than assumed.
+ *
+ * What the limit is, is the two ends: `REACH` of one body's emission crossed
+ * with the other's field at the separation, twice over, which is exactly
+ * `GRAVITY·m_a·m_b/(BIAS·R²)`. Nothing is fitted and nothing is dropped that
+ * survives at the scale being drawn.
+ *
+ * WHAT IS GIVEN UP. Two elementary sources a few cells apart really do pull
+ * harder than this, by that logarithm, and that regime is no longer drawn.
+ * It wants its own picture rather than being left to wreck a solar system —
+ * the figure it ruins is Mercury's, which comes out a circle instead of an
+ * ellipse entirely because of it.
+ */
 export const shortfall = (
   one: Live, two: Live, others: Live[], dt: number,
 ) => {
@@ -269,177 +533,212 @@ export const shortfall = (
   const R = Math.hypot(dx, dy);
   if (R < 1e-9) return 0;
 
-  const steps = WALK(R);
-
-  // x = R(1 − cos θ)/2, so dx = R·sin θ/2 · dθ — see `WALK`.
-  const dtheta = Math.PI / steps;
+  const share = coherence(one, two, R);
 
   /**
-   * How much of everything meeting anywhere along this line is opposite —
-   * settled ONCE for the line, and not place by place.
-   *
-   * Which is the difference between a ray and an aggregate, and it is worth
-   * spelling out because it was the largest error left in this model.
-   *
-   * Place by place, the phase between the two arrivals is ω times the path
-   * difference, ω(R − 2x), which sweeps from +ωR at one end to −ωR at the
-   * other and is nought exactly in the middle. That is right FOR A SINGLE RAY.
-   * But the meetings are not spread evenly along the line — the densities
-   * spike at both ends, where each source sits — so the density-weighted
-   * answer was carried almost entirely by the two endpoints, where the phase
-   * is ±ωR. And ±ωR is periodic in R with a period of one wavelength. So the
-   * pull between two things oscillated by a factor of 3.4 as they moved eight
-   * cells, which is not a force law at all. It hid perfectly from measurement
-   * for as long as the separations tried were multiples of the cycle.
+   * Whatever a third body has already put in the way is not free for these two
+   * to meet through.
    *
-   * The endpoints are also exactly where a single ray's phase means least. A
-   * charge arriving at a place did not come along the straight line; it came
-   * by whatever path the shell took, and an aggregate is a sum over all of
-   * them. The straight-line path difference is one sample of a spread, and the
-   * spread is widest where the shell is nearest — which is to say, at the ends.
+   * The same `through` the drawing uses, out of the same number: a charge of
+   * one's heading for a charge of two's has to get past whatever else is
+   * standing there, and the chance a cell is free is one minus the chance
+   * something is in it. Which makes gravity here SCREENED — three bodies in a
+   * row do not simply add — and the screening is short-range, because `chance`
+   * is, so it shows up in a close pass and nowhere else.
    *
-   * So the phase is averaged over the line rather than read off it: every path
-   * difference between +ωR and −ωR occurs, and the fraction opposite is the
-   * mean over them.
+   * Taken at each blocker's nearest approach to the line, once per pair. It
+   * used to be evaluated at every sample of a walk that no longer exists, and
+   * a body either stands between these two or it does not.
    *
-   * WEIGHTED, though, and not flat, which is the part that had to be got right
-   * a second time. A flat average is a hard window on the path difference —
-   * every value in [−ωR, +ωR] counting the same and everything outside it
-   * counting nothing — and a hard window does not converge, it RINGS. What is
-   * left of it goes as one over ωR and oscillates in R with the period of the
-   * pattern, so the pull between two sources alternating at the same rate
-   * still rippled by ±4.5% every four cells at solar separations. Which is not
-   * a force law, and it hid from the previous measurement for the same reason
-   * it hid from the one before that: the separations tried were multiples of
-   * the cycle, and the ripple is exactly nought there. The calibration
-   * separation was one of them.
-   *
-   * The window's own argument says it should not be flat anyway. The extremes
-   * of the range are the two endpoints, which is to say the two sources
-   * themselves, and those are precisely where a straight-line path difference
-   * means least — the shell is nearest, so the spread of real paths arriving
-   * is widest, so the straight line is the worst sample of it there. A raised
-   * cosine says that and nothing more: full weight in the middle, nothing at
-   * the ends, no parameter.
-   *
-   *     R (cells)      1      2      4      8     16     32
-   *     in step        0.07   0.15   0.30   0.50   0.50   0.50
-   *     half a cycle   0.93   0.85   0.70   0.50   0.50   0.50
-   *
-   * — a real, strong effect inside one wavelength, gone beyond it, and gone
-   * SMOOTHLY: the residual ripple over R from twenty to thirty-four cells
-   * falls from 8.45% of the share to 0.32%. Two things a long way apart cannot
-   * be in step in any way that matters, and the model now actually says so
-   * rather than saying it on average and oscillating about it.
-   *
-   * Sources turning at DIFFERENT rates never had a fixed relation to average
-   * in the first place, and go straight to a half.
+   * Newton has no such term and neither does general relativity at this order,
+   * so this is a genuine prediction of the model rather than a correction to
+   * it.
    */
-  const drifting = Math.abs(one.omega - two.omega) > 1e-9;
-
-  let share = 0.5;
+  let screen = 1;
 
-  if (!drifting) {
-    let sum = 0, weight = 0;
+  for (const c of others) {
+    if (c === one || c === two) continue;
 
-    // Evenly in the path difference, unlike the walk below: this is an average
-    // over path DIFFERENCES and not over places on the line. The weight is the
-    // window, not a measure.
-    for (let k = 0; k < steps; k++) {
-      const f = (k + 0.5) / steps;
-      const w = 0.5 - 0.5 * Math.cos(TURN_ROUND * f);
+    const px = c.at[0] - one.at[0], py = c.at[1] - one.at[1];
 
-      sum += w * opposed(
-        one.omega * (R - 2 * f * R) + (one.phase - two.phase));
-      weight += w;
-    }
+    // How far along the line its nearest point is, clamped to the ends.
+    const t = Math.min(Math.max((px * dx + py * dy) / (R * R), 0), 1);
 
-    share = sum / weight;
+    screen *= through(c.mass ?? 1, Math.hypot(px - dx * t, py - dy * t));
+    if (screen < 1e-6) break;
   }
 
+  // Two things a core apart have nothing between them left to eat.
+  if (R <= 2 * CORE) return 0;
+
+  return BITE * share * screen
+    * (one.mass ?? 1) * (two.mass ?? 1) * EMIT * EMIT * met(R, CORE) * dt;
+};
+
+/**
+ * How much space a pair destroys AT A PLACE — per lattice cell, per tick, and
+ * along what axis.
+ *
+ * `shortfall` above is this integrated along the one line whose length is the
+ * distance between the two, which is what the dynamics need. This is the same
+ * quantity before that integral is taken, so it can be asked about anywhere
+ * rather than only on the line, and the two cannot disagree: the integrand is
+ * the identical `chance · chance · share`, with `closing` restored because off
+ * the line it is no longer one by construction.
+ *
+ * A DENSITY PER LATTICE CELL, and that is the whole point of it existing.
+ *
+ * The count at a place is going to be read against `SHEET`, and `SHEET` is a
+ * fact about the discrete model — how many ways out of a point there are when
+ * space is a grid with its diagonals joined, which is 3^d − 1 and has nothing
+ * to do with anything being drawn. So the count it is compared against has to
+ * be per POINT of that grid. Feeding it off a display grid, as the first
+ * attempt at this did, makes how curved space is depend on how many pixels
+ * were spent on the picture — the same mistake `phi`'s `gain` is, one level
+ * further in, and worse, because that one only changed the shading.
+ *
+ * So there is no grid in this function. It is a function of a position, in
+ * cells, and whatever samples it is sampling a field that was already there.
+ *
+ * WHAT IS LEFT OUT, and why. `screen` — a third body standing in the way — is
+ * in `shortfall` and is not here. It is a line-of-sight correction worth under
+ * a part in ten thousand except during a close pass, it costs a loop over
+ * every other body at every place asked, and nothing that reads this is doing
+ * dynamics with it. If that ever changes it belongs back in.
+ *
+ * Filled into `FOLD` rather than returned, for the same reason `WAY` is in
+ * `field.ts`: this is asked thousands of times a frame and has no business
+ * allocating. `[rate, xx, xy, yy]` — the size, then the outer product of the
+ * axis with itself, already scaled by the size.
+ */
+export const FOLD: [number, number, number, number] = [0, 0, 0, 0];
+
+export const annihilation = (
+  one: Live, two: Live, x: number, y: number, share: number,
+) => {
+  FOLD[0] = FOLD[1] = FOLD[2] = FOLD[3] = 0;
+
+  // Which way each of them arrived here, which is straight out from where it
+  // is: a shell expands, so what is at a place is going away from its source.
+  const ax = x - one.at[0], ay = y - one.at[1];
+  const bx = x - two.at[0], by = y - two.at[1];
+
+  const ra = Math.hypot(ax, ay), rb = Math.hypot(bx, by);
+  if (ra < 1e-9 || rb < 1e-9) return FOLD;
+
+  const uax = ax / ra, uay = ay / ra;
+  const ubx = bx / rb, uby = by / rb;
+
   /**
-   * Which of the others could shadow anything on this line — worked out once,
-   * rather than asked at every sample.
+   * BEING IN THE SAME PLACE IS THE EVENT. Not being pointed at each other.
    *
-   * A body screens where `chance` is not negligible, and `chance` goes as
-   * m/r², so it is only ever a near-field thing: a body of unit mass matters
-   * out to a couple of dozen cells and a body of a millionth of that matters
-   * out to a hundredth of a cell. In a solar system nothing screens anything
-   * and this comes back empty, which turns the inner loop off entirely —
-   * eight bodies' worth of distance and probability per sample per pair per
-   * sub-step, for a number that is one to four decimal places.
+   * This had a `closing` factor in it — `−d̂_a · d̂_b`, nought past a right
+   * angle — and that was wrong, on the discrete model's own authority.
    *
-   * Measured from the nearest point of the segment, so a body is kept if it
-   * could matter ANYWHERE along the line and dropped only if it could not
-   * matter at all.
+   * `physics.ts` states the head-on doctrine plainly: two charges moving into
+   * each other are about to be an event, two moving past each other do
+   * nothing whatever to one another. That is true on a LINE, where being
+   * neighbours pointed opposite ways is the only way to meet. It is not what
+   * the lattice does in three dimensions, and `discrete.ts` says so at
+   * length: two shells sweeping through each other are made of rays coming in
+   * at all angles, and what they overwhelmingly do is converge on the SAME
+   * cell from different directions — never neighbours, never pointed at each
+   * other. Arriving together is its own way to meet, and the outcome there is
+   * `outcome(a.polarity, b.polarity)` with NO angular factor anywhere in it.
+   * Opposite cancel, alike turn, however they came.
+   *
+   * So the aggregate of that is the product of the two densities and nothing
+   * else. The chance a cell holds one of a's charges, times the chance it
+   * holds one of b's, is the chance they are in the same place — and being in
+   * the same place is the whole of the condition.
+   *
+   * WHAT IT COSTS, because it is not small. `closing` was confining the
+   * folding to a bounded lens — positive exactly inside the sphere having the
+   * two bodies as a diameter, and nothing at all outside it — and that was
+   * the reason an accumulating ledger here could not creep outwards the way
+   * the old accumulating `phi` did. Without it the folding reaches
+   * everywhere, falling as `1/(r_a² r_b²)`, and whatever reads this has to
+   * bound itself rather than being bounded by the geometry. Which is the
+   * honest position: the containment was an artefact of a rule the model does
+   * not have.
    */
-  const blockers = others.filter(c => {
-    if (c === one || c === two) return false;
+  const rate = BITE * chance(one.mass ?? 1, ra) * chance(two.mass ?? 1, rb)
+    * share;
 
-    const px = c.at[0] - one.at[0], py = c.at[1] - one.at[1];
-
-    // How far along the line the nearest point is, clamped to the ends.
-    const t = Math.min(Math.max((px * dx + py * dy) / (R * R), 0), 1);
+  if (rate <= 0) return FOLD;
 
-    return chance(c.mass ?? 1, Math.hypot(px - dx * t, py - dy * t)) > 1e-4;
-  });
+  // It happened, whatever direction it leaves behind — and whatever it
+  // shortens. Two cells go either way; the angle decides what that costs any
+  // particular distance, not whether the event occurred.
+  FOLD[0] = rate;
 
-  let met = 0;
-
-  for (let k = 0; k < steps; k++) {
-    const theta = (k + 0.5) * dtheta;
-
-    const f = (1 - Math.cos(theta)) / 2;
-    const x = f * R;
-
-    // What this sample is worth, which is no longer the same for all of them.
-    const width = R * Math.sin(theta) / 2 * dtheta;
-
-    /**
-     * And whatever a third body has already put in this cell, it is not free
-     * for these two to meet in.
-     *
-     * The same `through` the drawing uses, for the same reason and out of the
-     * same number: a charge of one's heading for a charge of two's has to get
-     * past whatever else is standing there, and the chance a cell is free is
-     * one minus the chance something is in it. Which makes gravity here
-     * SCREENED — three bodies in a row do not simply add — and the screening
-     * is short-range, because `chance` is, so it shows up in a close pass and
-     * nowhere else.
-     *
-     * Newton has no such term and neither does general relativity at this
-     * order, so this is a genuine prediction of the model rather than a
-     * correction to it, and the three panels are where to look for it.
-     */
-    let screen = 1;
-
-    for (const c of blockers) {
-      const cx = one.at[0] + dx * f - c.at[0];
-      const cy = one.at[1] + dy * f - c.at[1];
-
-      screen *= through(c.mass ?? 1, Math.hypot(cx, cy));
-      if (screen < 1e-6) break;
-    }
-
-    met += density(one, x) * density(two, R - x) * screen * width;
-  }
+  /**
+   * And the axis it folded along, which is `d̂_a − d̂_b` normalised.
+   *
+   * Read it off what `annihilate` actually does rather than off how the two
+   * arrived: the points go, and what was BEHIND each closes onto what was
+   * behind the other. Behind a is back along `−d̂_a` and behind b is back
+   * along `−d̂_b`, so the splice runs from one to the other, which is
+   * `d̂_a − d̂_b`. That derivation never mentioned the angle between them, and
+   * it holds at every angle — which is why dropping the head-on gate above
+   * costs this nothing. Head-on it reduces to `d̂_a`, as it did.
+   *
+   * UNSIGNED, and it has to be. The splice joins what was behind each onto
+   * the other, so what the place is left with is an axis and not an arrow.
+   * Which is why what accumulates is `â ⊗ â` and not `â`: over an orbit a
+   * place is folded from every side in turn, a sum of arrows comes to
+   * nothing, and a sum of outer products does not. That difference is the
+   * whole reason for keeping a second moment — the first one is already in
+   * `pulled`, and it is exactly the part that averages away.
+   *
+   * PARALLEL IS THE ONE DEGENERATE CASE, and it is now reachable where it was
+   * not before. Two charges going the SAME way that land on the same cell
+   * have the same place behind both of them, so there is nothing for the
+   * splice to join and no axis to leave: the annihilation is real — it is in
+   * `FOLD[0]` above — and it shortens nothing. `closing` used to make this
+   * unreachable by throwing the whole event away, which threw away the real
+   * ones alongside it.
+   */
+  const dx = uax - ubx, dy = uay - uby;
+  const len = Math.hypot(dx, dy);
+  if (len < 1e-9) return FOLD;
 
   /**
-   * And each of those meetings takes its own bite out of the line.
+   * HOW MUCH it shortens, which is the length of that splice and not one.
+   *
+   * `d̂_a − d̂_b` is two cells long when the two arrive head-on — which is the
+   * two cells the rule says go — and nought when they arrive going the same
+   * way, because then what is behind both of them is the same place and there
+   * is nothing for the splice to join. In between it is `2·sin(θ/2)`. So the
+   * shortening carries a factor of `len/2`, and this was dividing by `len` to
+   * get an axis and dropping the magnitude on the floor.
    *
-   * No coupling constant: `met` is a count of coincidences per tick, because
-   * every factor in it is a probability or a count, and `BITE` is what the
-   * rule says one costs. What used to be `GAIN` was a fitted 1.776 standing
-   * in for the surface of the unit sphere squared — measured, exactly a
-   * hundred and forty times what the geometry asks for, which is (4π)²/BITE.
+   * WHICH IS THE ANGULAR LAW, and it is derived rather than chosen. `closing`
+   * was `max(−cos θ, 0)`: a hard cutoff, nought for everything inside a right
+   * angle, and it had to go because the lattice interacts on CO-LOCATION at
+   * any angle (see above). But dropping it left nothing in its place, and
+   * nothing is also wrong — it says two charges running side by side into the
+   * same cell shorten as much as two meeting head-on, which the splice plainly
+   * does not do.
    *
-   * What comes out is a COUNT: meetings along this line this tick. Not a
-   * speed, not an acceleration — a number of events. What it does to anything
-   * is settled in `BIAS` and `pace`, where the count becomes a density and the
-   * density becomes a drift, and the extra one-over-time this file could not
-   * previously account for turns out to be the difference between the two.
+   * `sin(θ/2)` is what the splice is. It is smooth where `closing` was a
+   * knife, it is nought only for exactly parallel, and it keeps a space
+   * integral convergent: far from the pair both charges arrive nearly
+   * parallel, so this falls off as `R/D` and suppresses a bulk that would
+   * otherwise make the pull go as `1/R` instead of `1/R²`.
+   *
+   * On the line between two sources it is exactly one — `d̂_a = +r̂` and
+   * `d̂_b = −r̂` — so `shortfall` does not move.
    */
-  return BITE * met * share * dt;
+  const shortens = rate * len / 2;
+
+  const hx = dx / len, hy = dy / len;
+
+  FOLD[1] = shortens * hx * hx;
+  FOLD[2] = shortens * hx * hy;
+  FOLD[3] = shortens * hy * hy;
+
+  return FOLD;
 };
 
 /**
@@ -462,9 +761,9 @@ export const shortfall = (
  *     ∫₀^∞ chance(m_a, x) dx = m_a·SHEET/(4π) · 2/HALF     ... the core, twice
  *     two ends, BITE a meeting, half of them opposite
  *
- *     G = BITE·½·2 · (SHEET/4π)(2/HALF) · (SHEET/4π) · BIAS = SHEET/(4π²·HALF)
+ *     G = BITE·½·4 · (SHEET/4π)² / CORE · BIAS = SHEET²/(4π²·CORE·WAYS)
  *
- * — 0.405285, and checked against the integral itself at a converged sample
+ * — 0.124726, and checked against the integral itself at a converged sample
  * count out to a million cells, where it agrees to two parts in a thousand.
  *
  * WHICH IS THE HONEST CONSTANT AND THE OTHER ONE WAS NOT, and the difference
@@ -501,4 +800,5 @@ export const shortfall = (
  * FRACTION of your paths that got biased, and a heavier thing brought
  * proportionally more paths to the meeting.
  */
-export const GRAVITY = SHEET / (4 * Math.PI * Math.PI * HALF);
+export const GRAVITY =
+  SHEET * SHEET / (4 * Math.PI * Math.PI * CORE * WAYS);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
index 4d3b8d0..e6de5e6 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
@@ -16,9 +16,9 @@ import { Models } from "./views";
  *
  * Which means there is nothing to edit here. To change an arrangement, add
  * one, or change the order they are read in, edit `models.ts`; to change what
- * an arrangement MEANS, edit `discrete.ts` and `continuous.tsx`, which are
- * the two readings, and which share their vocabulary through `lattice.ts` so
- * that neither can drift from the other by redefining a term.
+ * an arrangement MEANS, edit `discrete.ts` and `metric.tsx`, which are the
+ * two readings, and which share their vocabulary through `lattice.ts` and
+ * `physics.ts` so that neither can drift from the other by redefining a term.
  */
 const RayCalculiAndPhysics = () => {
   const referenceCounter = useCounter();
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
index 845fab5..5db7a7c 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
@@ -4,8 +4,12 @@
  *   opposed(ψ)  = |ψ| / π                         how much of a meeting cancels
  *   screen(x)   = Π_c through(m_c, |x − r_c|)     what a third body shadows
  *
- *   S(a,b)      = BITE ∫₀^R chance(m_a,s)·chance(m_b,R−s)·opposed·screen ds
- *                                                 meetings a tick along a→b
+ *   S(a,b)      = BITE·share·screen·m_a·m_b·EMIT²·met(R)    meetings a tick
+ *                                                 along a→b. `met` is that
+ *                                                 line integral in closed
+ *                                                 form — see `gravity.ts`,
+ *                                                 where the running of G with
+ *                                                 separation lives.
  *
  *   the density of space, which is the whole of gravity here:
  *     u_a       = own_a + pulled_a                its count, in cells a tick of
@@ -17,12 +21,12 @@
  *   An annihilation leaves the space where it happened denser: the next path
  *   out of that point is twice as likely to go the way it went, a second one
  *   makes it three to one, a third four. So a direction carrying n of them
- *   weighs 1 + n against the SHEET ways out that weigh one each, and what that
- *   leans a path by is LIGHT·n/SHEET — linear, with no ceiling in it.
+ *   weighs 1 + n against the WAYS out that weigh one each, and what that leans
+ *   a path by is LIGHT·n/WAYS — linear, with no ceiling in it.
  *
  *   Everything else here falls out of that, and none of it is stated:
  *
- *     BIAS        one annihilation buys LIGHT/SHEET, whatever else is going on
+ *     BIAS        one annihilation buys LIGHT/WAYS, whatever else is going on
  *                 — so at rest, NEWTON, with no free constant
  *     u̇ ∝ ṅ      a shortage of space is an ACCELERATION and not a speed,
  *                 because what accumulates is the count and what drifts is a
@@ -38,12 +42,12 @@
  *                 heavier things have proportionally more paths to bias, so
  *                 the same fraction of them bends. Inertia IS path count.
  *
- *   G           = SHEET / (4π²·HALF)              the far-field limit, closed
- *                                                 form. `S·R²` is 8.5% above
- *                                                 it at 24 cells and decays as
- *                                                 ln R/R — the model's largest
- *                                                 departure, and now a stated
- *                                                 one. See `GRAVITY`.
+ *   G           = SHEET² / (4π²·CORE·WAYS)       closed form, nothing fitted.
+ *                                                 `S·R²` runs above it by
+ *                                                 CORE·ln(R/CORE)/R — which
+ *                                                 is nothing at a separation
+ *                                                 of any real bodies. See
+ *                                                 `GRAIN` in `gravity.ts`.
  *
  *   the picture only (φ drives nothing — see `spaceStep`):
  *     φ(x)      = max(−K·S(x)·dt, −1/4)           where space is going
@@ -55,24 +59,28 @@
 
 import { CanvasView, Surface } from "./canvas";
 import {
-  Emitter, fade, grainAt, HALF, Live, sparse, WAY, emit, fieldAt, TRAIL,
+  Emitter, fade, grainAt, HALF, Live, sparse, emit, fieldAt, TRAIL,
 } from "./field";
-import { BIAS, count, pace, shortfall } from "./gravity";
+import {
+  annihilation, BIAS, coherence, count, pace, shortfall,
+} from "./gravity";
 import { CYCLE, SPIN, TAU } from "./lattice";
 import {
-  AMBER, BACKGROUND, CYAN, decadesFor, ground, legend, lift, shown, source,
-  trail,
+  AMBER, BACKGROUND, CYAN, decadesFor, ground, legend, lift, NEUTRAL, rgba,
+  shown, source, trail,
 } from "./paint";
-import { cancelling, closing } from "./physics";
+import { cancelling } from "./physics";
 
 /**
  * Gravity as a shortage of space, which is what the lattice actually does.
  *
- * `continuous.tsx` is the other account, and it is the one this article was
- * written with: measure where annihilation is happening, turn that into a
- * velocity for the space itself, give the velocity a wave equation, carry
- * each source by the flow it is standing in, and turn it by how steeply that
- * flow falls away. It works, and every step of it is a thing added.
+ * There used to be another account beside this one — gravity as a FLOW —
+ * and it is worth saying what it was, because this file is what replaced it
+ * and the reason is the whole argument. It measured where annihilation was
+ * happening, turned that into a velocity for the space itself, gave the
+ * velocity a wave equation, carried each source by the flow it was standing
+ * in, and turned it by how steeply that flow fell away. It worked, and every
+ * step of it was a thing ADDED.
  *
  * None of which the lattice does. `annihilate` pushes nothing. It removes two
  * points and splices what was behind each onto what was behind the other, and
@@ -126,6 +134,85 @@ import { cancelling, closing } from "./physics";
  */
 export type Space = {
   phi: Float32Array;
+
+  /**
+   * And the same thing kept one moment further out: not how much folding there
+   * is at a place but WHICH WAY it went, as the three parts of a symmetric
+   * 2×2.
+   *
+   * `phi` is the trace of this and nothing more. Which is the whole point of
+   * having it: a scalar can say a place has had space taken out of it, and it
+   * cannot say that the space taken out was taken RADIALLY and not across.
+   * Those are different statements about the same place and general relativity
+   * needs the second one — the metric it wants is
+   *
+   *     ds² = −A dt² + B(dx² + dy² + dz²)
+   *
+   * and A alone, which is all a scalar can be, gives Newton's law, one sixth
+   * of Mercury's perihelion advance, and half of the deflection of light. The
+   * other five sixths and the other half are B, and B is a statement about
+   * direction.
+   *
+   * The counting argument this whole file rests on was always about direction.
+   * `BIAS` says a place that has taken an annihilation has more ways of going
+   * the way it went "while every other way out of the point still weighs
+   * exactly what it always did" — which is a count PER WAY OUT, twenty-six of
+   * them in three dimensions, and what has been kept until now is only how big
+   * it is and, per body, where it pointed. The direction was being computed
+   * and thrown away on the same line.
+   *
+   * So this keeps it. Nothing new is measured: `shortfall` already walks the
+   * line between every pair and already knows which way it is walking, so
+   * every meeting it counts can say where it happened and along what for
+   * nothing (see its `onto`). It is fed from there and NOT from `eaten`,
+   * which measures the same physical thing off the drawn field in the
+   * drawing's units — a count that is going to be read against `SHEET` has to
+   * be in the units `GRAVITY` was derived in.
+   *
+   * AND IT ACCUMULATES, which `phi` explicitly does not (see `spaceStep`).
+   * That is the whole of what makes it a field rather than a snapshot, and it
+   * is worth being exact about why it does not do what the old accumulating
+   * `phi` did, which was to eat the frame:
+   *
+   *  - it is BOUNDED IN SPACE by construction. `shortfall` only ever walks
+   *    between two bodies, so nothing is ever deposited outside the segment,
+   *    and there is no far tail to creep outwards.
+   *
+   *  - it is BOUNDED IN EFFECT by the counting argument itself. The count
+   *    grows without limit and what a count DOES saturates: `n/(SHEET + n)`
+   *    goes to one and stops, because a direction cannot take more than all
+   *    the paths. Measured on a held pair twelve cells apart, the count at a
+   *    body goes 0.41 → 4.5 → 49 → 123 over 200, 2200, 24 000 and 60 000
+   *    ticks while the bias goes 0.049 → 0.36 → 0.86 → 0.94. That is the
+   *    saturation in `drawn` finally doing the job it was written for.
+   *
+   * WHAT IT IS FOR. A snapshot of this is a strand along one pair's line, and
+   * that was the reason for thinking it could not be a metric. It was the
+   * wrong thing to look at. Accumulated over an orbit the line SWEEPS, and
+   * wherever it passes through a place the line IS the radius there — so what
+   * builds up round the middle of a system is radial and very nearly
+   * axisymmetric. Measured on Sun and Mercury over the panel's own run: every
+   * one of 72 bearings lit at every radius out to 20 cells, the axis within
+   * 0.4° to 2.7° of radial, and `spread` at 0.995 to 1.000 — folded radially
+   * and not at all across, which is the shape general relativity's B has.
+   *
+   * WHAT IS WRONG WITH IT, stated plainly because it is not small. The count
+   * that builds up at planetary mass ratios is about 1e−10, so the bias is
+   * 1e−11 where the effect being chased is 1e−3. And worse than small, it is
+   * not scale-free: `shortfall` goes as m_a·m_b and a mass in cells is
+   * `gm·cells³/ticks²/GRAVITY`, so drawing the same system twice as large
+   * folds space twice as hard. The pairwise law has no such problem because
+   * the response divides by the body's own mass, which is the equivalence
+   * principle; a count at a place has nothing to divide by. So `SHEET` is
+   * probably not what this should be read against, and what it should be is
+   * the open question.
+   *
+   * IT DRIVES NOTHING. What a body does is still settled pairwise in `spend`.
+   * This is here to be looked at and measured against, and it is behind
+   * `folded` so that nothing pays for it unless it is being looked at.
+   */
+  nxx: Float32Array; nxy: Float32Array; nyy: Float32Array;
+
   n: number; x0: number; y0: number; step: number;
 };
 
@@ -144,6 +231,9 @@ export const space = (span: number, sources = 2): Space => {
 
   return {
     phi: new Float32Array(n * n),
+    nxx: new Float32Array(n * n),
+    nxy: new Float32Array(n * n),
+    nyy: new Float32Array(n * n),
     n, x0: -span, y0: -span, step: (2 * span) / n,
   };
 };
@@ -166,29 +256,37 @@ export const phiAt = (w: Space, x: number, y: number): number => {
 /**
  * How much space is being destroyed at a place, per tick.
  *
- * The one thing both accounts read off the field, and the whole of what
- * annihilation is: two charges cancel where they are opposite in charge AND
- * opposed in direction. One without the other is a crossing rather than a
- * collision, so both factors are in it, and both are readable on the spot
+ * The whole of what annihilation is: two charges cancel where they are
+ * opposite in charge and IN THE SAME PLACE. Both are readable on the spot,
  * without knowing which sources exist or which two of them are meant.
+ *
+ * There used to be a `closing` factor here as well — nought unless the two
+ * were coming at each other within a right angle — and it is gone, on the
+ * lattice's own authority. `discrete.ts` has two ways for charges to meet,
+ * and arriving together is the one that matters in three dimensions: two
+ * shells sweeping through each other are made of rays coming in at all
+ * angles, converging on the same cell from different directions, never
+ * neighbours and never pointed at each other. What happens when they land
+ * together is `outcome(a.polarity, b.polarity)`, with no angular factor
+ * anywhere in it. Being in the same place is the event. See `annihilation`
+ * in `gravity.ts`, which is the same correction on the dynamics side.
+ *
+ * This is the DRAWING's measure of it, and its scale is the drawing's — see
+ * the `gain` in `spaceStep`. The folding grid is fed from `annihilation`
+ * instead, which is the same physical quantity in the units the dynamics are
+ * actually in. A number that is going to be compared against `SHEET` cannot
+ * come from here.
  */
 const eaten = (live: Live[], x: number, y: number, t: number) => {
-  const val: number[] = [], dx: number[] = [], dy: number[] = [];
+  const val: number[] = [];
 
-  for (let i = 0; i < live.length; i++) {
-    val[i] = emit(live[i], live[i], x, y, t);
-    dx[i] = WAY[0]; dy[i] = WAY[1];
-  }
+  for (let i = 0; i < live.length; i++) val[i] = emit(live[i], live[i], x, y, t);
 
   let total = 0;
 
   for (let i = 0; i < live.length; i++)
-    for (let j = i + 1; j < live.length; j++) {
-      const closes = closing([dx[i], dy[i]], [dx[j], dy[j]]);
-      if (closes <= 0) continue;                  // crossing, not meeting
-
-      total += cancelling(val[i], val[j]) * Math.abs(val[i] * val[j]) * closes;
-    }
+    for (let j = i + 1; j < live.length; j++)
+      total += cancelling(val[i], val[j]) * Math.abs(val[i] * val[j]);
 
   return total;
 };
@@ -263,6 +361,81 @@ export const spaceStep = (
     }
 };
 
+/**
+ * One tick's worth of folding, added everywhere it happened.
+ *
+ * SAMPLED, not binned, and the difference is the whole of what this pass is
+ * for. `annihilation` is a density per lattice cell at a position — a field,
+ * with no grid anywhere in it — so what is stored at a grid place is the value
+ * of that field THERE, times how long has passed. Halve the grid spacing and
+ * every stored number is unchanged; the picture gets finer and the physics
+ * does not move. The first version of this binned a line walk into the grid
+ * and therefore said space was folded harder when the canvas had more pixels
+ * in it, which is the same class of mistake as `phi`'s `gain` and worse, since
+ * that one only ever changed the shading.
+ *
+ * `share` is settled once per pair, as it is in `shortfall`: it is a fact
+ * about how two things are keeping time against each other, and not about any
+ * place in particular.
+ */
+const foldStep = (w: Space, live: Live[], dt: number) => {
+  const { n, step } = w;
+
+  for (let a = 0; a < live.length; a++)
+    for (let b = a + 1; b < live.length; b++) {
+      const dx = live[b].at[0] - live[a].at[0];
+      const dy = live[b].at[1] - live[a].at[1];
+
+      const R = Math.hypot(dx, dy);
+      if (R < 1e-9) continue;
+
+      const share = coherence(live[a], live[b], R);
+
+      for (let j = 0; j < n; j++)
+        for (let i = 0; i < n; i++) {
+          const f = annihilation(
+            live[a], live[b], w.x0 + i * step, w.y0 + j * step, share);
+
+          if (f[0] <= 0) continue;
+
+          const k = j * n + i;
+
+          w.nxx[k] += f[1] * dt;
+          w.nxy[k] += f[2] * dt;
+          w.nyy[k] += f[3] * dt;
+        }
+    }
+};
+
+/**
+ * What the folding at a place comes to: how one-sided it is, and which way.
+ *
+ * The eigen-decomposition of a symmetric 2×2, which is short enough to write
+ * out. `spread` is (λ₁ − λ₂)/(λ₁ + λ₂) — nought where the place has been
+ * folded the same amount every way, one where it has been folded along a
+ * single axis and not at all across it. `turn` is where that axis points, and
+ * it is a direction modulo π rather than a bearing, because an axis is.
+ *
+ * This is the number the whole exercise is about. A scalar account can only
+ * ever report the trace, which is `size`; if `spread` is nought everywhere
+ * then the model's folding is isotropic and there is no B in it to find. If it
+ * is not, there is, and what it looks like is the next question.
+ */
+export const AXIS: [number, number, number] = [0, 0, 0];   // size, spread, turn
+
+export const folding = (w: Space, k: number) => {
+  const a = w.nxx[k], b = w.nxy[k], c = w.nyy[k];
+
+  const size = a + c;
+  const gap = Math.hypot((a - c) / 2, b) * 2;
+
+  AXIS[0] = size;
+  AXIS[1] = size > 1e-30 ? gap / size : 0;
+  AXIS[2] = 0.5 * Math.atan2(2 * b, a - c);
+
+  return AXIS;
+};
+
 /**
  * How far apart two places are, in the metric rather than in the picture.
  *
@@ -389,6 +562,7 @@ export const MetricField = ({
   rate = 10,
   cycle = 200,
   summary,
+  folded,
 }: {
   sources: Emitter[];
   span?: number;
@@ -396,9 +570,22 @@ export const MetricField = ({
   cycle?: number;
   height?: number;
   summary?: boolean;
+
+  /**
+   * Draw which WAY the space is being folded, over the top of everything else.
+   *
+   * Off everywhere by default, because it is a second picture on one canvas
+   * and most of these panels are about the first one. On, it strokes the
+   * principal axis of `folding` on a coarse grid — the direction the
+   * annihilation at each place came together along, with the length of the
+   * stroke saying how one-sided it is.
+   *
+   * It drives nothing. See `Space.nxx`.
+   */
+  folded?: boolean;
 }) => <CanvasView
   height={height}
-  deps={[sources, span, rate, cycle, summary]}
+  deps={[sources, span, rate, cycle, summary, folded]}
   paint={() => {
     const buf = document.createElement("canvas");
     const bufCtx = buf.getContext("2d")!;
@@ -586,8 +773,14 @@ export const MetricField = ({
           if ((b.mass ?? 1) / rr < NOTHING * most[i]
             && (a.mass ?? 1) / rr < NOTHING * most[j]) continue;
 
+          // Nothing to spend, and NOT "less than some small number": what
+          // `shortfall` returns is in units of `GRAVITY`, and `GRAVITY` scales
+          // with `GRAIN` — so an absolute floor here is a floor on the drawing
+          // scale, and at a grain of a trillion it silently swallowed every
+          // pair in the system. The relative test above (`NOTHING`) is what
+          // decides whether a pair is worth walking.
           const deficit = shortfall(a, b, live, dt);
-          if (deficit <= 1e-12) continue;
+          if (deficit <= 0) continue;
 
           dx /= coord; dy /= coord;
 
@@ -675,6 +868,11 @@ export const MetricField = ({
         spaceStep(world, live, t, dt);
         wake(world, live, going, dt);
       }
+
+      // And the folding, which is wanted whenever it is being looked at and
+      // never otherwise. Unlike the two above it accumulates, so it is a time
+      // integral and has to be handed the same `dt` the step was taken with.
+      if (folded) foldStep(world, live, dt);
     }
 
     function draw({ ctx, width: w, height: h }: Surface) {
@@ -723,6 +921,68 @@ export const MetricField = ({
             { halo: 14, dot: 2.2 });
       };
 
+      /**
+       * And which way the folding went, as a stroke per place.
+       *
+       * A director field rather than arrows, because what is stored is an axis
+       * (see `eaten`): each stroke lies along the principal direction of
+       * `folding` and is drawn through its place rather than from it, so a
+       * stroke has two ends and no head.
+       *
+       * Two things are being said at once and they are separated on purpose.
+       * The LENGTH is `spread` — how one-sided the folding is, nought to one —
+       * and it is the whole question this overlay exists to answer, so it is
+       * on the axis the eye reads first. The OPACITY is the size of the
+       * folding, log-scaled off the largest in the frame, and it is there only
+       * so that the empty corners do not shout as loudly as the middle. A
+       * place where nothing is happening but what little happens is one-sided
+       * still draws a long faint stroke, which is correct and is exactly the
+       * case a linear scale would have hidden.
+       */
+      const strokes = () => {
+        const { n } = world;
+
+        let top = 0;
+
+        for (let k = 0; k < n * n; k++)
+          top = Math.max(top, world.nxx[k] + world.nyy[k]);
+
+        if (top <= 0) return;
+
+        // Every other place, so the strokes have room to be seen as strokes.
+        const skip = Math.max(Math.round(n / 28), 1);
+        const reach = world.step * scale * skip * 0.45;
+
+        ctx.save();
+        ctx.lineCap = "round";
+        ctx.lineWidth = 1.1;
+
+        for (let j = 0; j < n; j += skip)
+          for (let i = 0; i < n; i += skip) {
+            const [size, spread, turn] = folding(world, j * n + i);
+            if (size <= 0 || spread < 0.02) continue;
+
+            // Three decades of it, which is what the field itself is drawn
+            // over — see `decadesFor`.
+            const lit = Math.max(0, 1 + Math.log10(size / top) / 3);
+            if (lit <= 0.02) continue;
+
+            const px = w / 2 + (world.x0 + i * world.step) * scale;
+            const py = h / 2 + (world.y0 + j * world.step) * scale;
+
+            const ex = Math.cos(turn) * reach * spread;
+            const ey = Math.sin(turn) * reach * spread;
+
+            ctx.strokeStyle = rgba(NEUTRAL, 0.15 + 0.65 * lit);
+            ctx.beginPath();
+            ctx.moveTo(px - ex, py - ey);
+            ctx.lineTo(px + ex, py + ey);
+            ctx.stroke();
+          }
+
+        ctx.restore();
+      };
+
       /**
        * And where it cannot be resolved at all, it is not drawn.
        *
@@ -746,8 +1006,11 @@ export const MetricField = ({
       if (brief) {
         ground(ctx, w, h);
 
-        legend(ctx, w, h,
-          `too far out to resolve a band — showing the path each has taken`);
+        legend(ctx, w, h, folded
+          ? `too far out to resolve a band — path taken, and which way space folded`
+          : `too far out to resolve a band — showing the path each has taken`);
+
+        if (folded) strokes();
 
         paths();
         dots();
@@ -886,7 +1149,12 @@ export const MetricField = ({
 
       legend(ctx, w, h, `field 1/r², log over ${decades} decades · ${
         grain < 0.05 ? 'drawn continuous'
-          : grain > 0.95 ? 'shells' : 'fading to shells'}`);
+          : grain > 0.95 ? 'shells' : 'fading to shells'}${
+        folded ? ' · strokes: which way space is folding' : ''}`);
+
+      // Which way each place is being folded, under the paths and over the
+      // field — it is a statement about the field, so it belongs on top of it.
+      if (folded) strokes();
 
       // And where each has been, over the field it laid down getting there.
       // Both, now, rather than one or the other: the waves are what the model
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
index 980fe5d..428cf49 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
@@ -61,14 +61,21 @@ export type Model = {
   /** The lattice run, or `false` where there is nothing to run. */
   lattice?: false | Lattice;
 
-  /** The closed form, or `false` where there is nothing to write down. */
-  closed?: false | Closed;
-
   /**
-   * And the same closed form again, with gravity read as a shortage of space
-   * rather than as a flow — see `metric.tsx`. Off unless asked for, because
-   * it is a third heavy picture on a page that already has two, and because
-   * the point of it is the comparison rather than the coverage.
+   * The closed form: the same claim written down instead of run, with gravity
+   * read as a shortage of space — see `metric.tsx`.
+   *
+   * There used to be a second one beside it that read gravity as a FLOW:
+   * measure where annihilation is happening, turn that into a velocity for
+   * the space itself, give the velocity a wave equation, carry each source by
+   * the flow it is standing in. It worked, and every step of it was a thing
+   * ADDED — a mechanism laid on top of the lattice rather than read off it.
+   *
+   * The metric reading is what the lattice actually does. `annihilate` pushes
+   * nothing; it removes two points and splices what was behind each onto the
+   * other, and afterwards there is simply less space between the two things
+   * than there was. Nothing moved. So there is one closed form now, and it is
+   * that one.
    */
   metric?: Closed;
 
@@ -237,29 +244,16 @@ export const latticeOf = (model: Model): Lattice | undefined =>
     return () => Graph.sources(at);
   });
 
-/** And how it is written down, if it can be. */
-export const closedOf = (model: Model): Closed | undefined =>
-  reading<Closed, 'sources'>(model.closed, 'sources', () => {
-    const world = model.world;
-    if (!world) return undefined;
-
-    return sized(world, (model.closed || {}).scale ?? 1).sources.map(emitterOf);
-  });
-
 /**
- * And the same, read as a metric.
+ * And how it is written down, if it can be.
  *
- * Framed exactly as the flow reading is unless told otherwise — same scale,
- * same span, same run length — because the whole purpose of it is that the
- * two are looked at side by side, and two pictures of the same arrangement at
- * different sizes are not a comparison. So enabling it is `metric: {}`, and
- * anything set on it is a deliberate departure.
+ * Enabling it is `metric: {}`; anything set on it is a deliberate departure
+ * from what the arrangement would otherwise be drawn at.
  */
 export const metricOf = (model: Model): Closed | undefined => {
   if (!model.metric) return undefined;
 
-  const like = model.closed === false ? {} : (model.closed ?? {});
-  const given = { ...like, ...model.metric };
+  const given = { ...model.metric };
 
   return reading<Closed, 'sources'>(given, 'sources', () => {
     const world = model.world;
@@ -273,14 +267,13 @@ export const metricOf = (model: Model): Closed | undefined => {
  * And what the two classical accounts make of it, neither of which is a
  * reading of this model at all.
  *
- * Framed like the closed form unless told otherwise, for the same reason the
- * metric reading is: panels of the same arrangement at different sizes are not
- * a comparison.
+ * Framed like the model's own reading unless told otherwise: panels of the
+ * same arrangement at different sizes are not a comparison.
  */
 const against = (model: Model, own: Closed | undefined): Closed | undefined => {
   if (!own) return undefined;
 
-  const like = model.closed === false ? {} : (model.closed ?? {});
+  const like = model.metric ?? {};
   const given = { ...like, ...own };
 
   return reading<Closed, 'sources'>(given, 'sources', () => {
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
index 118a050..46045d2 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -140,9 +140,8 @@ const flatAndRound = (model: Model): Model => ({
     name: `${model.name}, in three dimensions`,
     note: undefined,
     world: { ...model.world!, dims: 3 },
-    // The closed form is flat and has no round version to offer, so both
-    // readings of it stay with the flat run they are the closed form of.
-    closed: false,
+    // The closed form is flat and has no round version to offer, so it stays
+    // with the flat run it is the closed form of.
     metric: undefined,
     alongside: undefined,
   }],
@@ -151,22 +150,25 @@ const flatAndRound = (model: Model): Model => ({
 /**
  * A source that turns: it has an axis, and the axis comes round. What it lays
  * down is a spiral, which belongs to a whole train of shells and to none of
- * them separately — so it is drawn as the field rather than pulse by pulse,
- * and it must not wander, since wandering is each pulse going somewhere
- * slightly else on the way and that is exactly the information an arm is made
- * of, rubbed out.
+ * them separately — so it is drawn as the field rather than pulse by pulse.
+ *
+ * It used to be held to `wander: 0` as well, on the reasoning that wandering
+ * is each pulse going somewhere slightly else on the way, and that is exactly
+ * the information an arm is made of, rubbed out. That reasoning was right
+ * about what wandering does and wrong about whether it can be done without.
+ *
+ * A turning source emits into the plane it turns in — its poles are in that
+ * plane and the axis it turns about sits on the permanently silent equator.
+ * So without wandering the field is a disk made of eight spokes, and it never
+ * thins as anything: what a fixed number of rays does as it goes out is get
+ * further apart, not fainter. The inverse square is the emission SPREADING
+ * over a shell that grows as r², and the only thing here that spreads it is
+ * the wander. So the arm is drawn through a wandering field now, and what
+ * blurs it is the same thing that makes it fall off correctly.
  */
-type Draw = { mode: RenderMode, fanAt?: number, wander?: number };
-
-const asField: Draw = {
-  mode: 'field',
-  // Out where there is room for it, rather than at the first opportunity.
-  // Fanning close in crowds the few cells near the source and thickens the
-  // shells there; fanning out where a shell has already grown puts the extra
-  // charges exactly where the gaps between them have opened.
-  fanAt: 5,
-  wander: 0,
-};
+type Draw = { mode: RenderMode, wander?: number };
+
+const asField: Draw = { mode: 'field' };
 
 // A source that only flips: the same charge in every direction, reversed and
 // reversed again, so what it lays down is shells and a shell is the object.
@@ -256,7 +258,7 @@ const worlds: Model[] = ([
   .map(({ name, note, sources, alone, metric, draw }) => flatAndRound({
     name,
     note,
-    world: { sources, wander: draw.wander, fanAt: draw.fanAt },
+    world: { sources, wander: draw.wander },
     lattice: {
       scale: NEAR,
       ticks: LATTICE_FOR,
@@ -268,7 +270,7 @@ const worlds: Model[] = ([
       // is drawn from.
       density: false,
     },
-    closed: {
+    metric: metric ? {
       // A lone source is already at the middle and has nothing to be apart
       // from, so there is nothing to scale it against.
       //
@@ -280,9 +282,7 @@ const worlds: Model[] = ([
       scale: alone ? 1 : CLOSE,
       span: ARM,
       cycle: alone ? ALONE_FOR : PAIR_FOR,
-    },
-    // Framed like the flow reading, so the two can be read against each other.
-    metric: metric ? {} : undefined,
+    } : undefined,
   }));
 
 /**
@@ -313,8 +313,7 @@ const closedOnly: Model[] = [
       + 'from, and the source has gone on.',
     world: { sources: [{ at: [-12, 0], turning: 1, drift: [PACE, 0] }] },
     lattice: false,
-    metric: {},
-    closed: { span: 14, cycle: ALONE_FOR },
+    metric: { span: 14, cycle: ALONE_FOR },
   },
 
   /**
@@ -346,8 +345,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
-    metric: {},
-    closed: { span: APART * ROOM, cycle: PAIR_FOR },
+    metric: { span: APART * ROOM, cycle: PAIR_FOR },
   },
 
   /**
@@ -380,8 +378,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
-    metric: {},
-    closed: { span: WIDE, cycle: PAIR_FOR },
+    metric: { span: WIDE, cycle: PAIR_FOR },
   },
 
   /**
@@ -420,8 +417,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
-    metric: {},
-    closed: { span: 34, cycle: PAIR_FOR },
+    metric: { span: 34, cycle: PAIR_FOR },
   },
 
   /**
@@ -489,8 +485,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
-    metric: {},
-    closed: { span: 34, cycle: 320 },
+    metric: { span: 34, cycle: 320 },
   },
 
   /**
@@ -533,8 +528,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
-    metric: {},
-    closed: { span: 40, cycle: 320 },
+    metric: { span: 40, cycle: 320 },
   },
 
   /**
@@ -575,8 +569,7 @@ const closedOnly: Model[] = [
       }),
     },
     lattice: false,
-    metric: {},
-    closed: { span: WIDE, cycle: PAIR_FOR },
+    metric: { span: WIDE, cycle: PAIR_FOR },
   },
 
   /**
@@ -610,8 +603,7 @@ const closedOnly: Model[] = [
       }),
     },
     lattice: false,
-    metric: {},
-    closed: { span: WIDE, cycle: PAIR_FOR },
+    metric: { span: WIDE, cycle: PAIR_FOR },
   },
 
   /**
@@ -646,8 +638,7 @@ const closedOnly: Model[] = [
       + 'Nothing moves them but the space between them going.',
     world: { sources: triangle({ lobed: true }) },
     lattice: false,
-    metric: {},
-    closed: { span: WIDE, cycle: PAIR_FOR },
+    metric: { span: WIDE, cycle: PAIR_FOR },
   },
 
   /**
@@ -696,8 +687,7 @@ const closedOnly: Model[] = [
       ],
     },
     lattice: false,
-    metric: {},
-    closed: { span: WIDE, cycle: PAIR_FOR },
+    metric: { span: WIDE, cycle: PAIR_FOR },
   },
 ];
 
@@ -716,7 +706,6 @@ const blocks: Model[] = [
     note: 'Every point charged at random and set going at random. From there '
       + 'the rules alone: cancel, turn around, or move.',
     lattice: { seed: () => Graph.grid({ dims: 3 }), autoplay: false },
-    closed: false,
   },
 
   ...([
@@ -734,7 +723,6 @@ const blocks: Model[] = [
       seed: () => Graph.blocks({ charge: bySide(left, right) }),
       ticks: 15, height: 140, density: false,
     },
-    closed: false,
   })),
 
   {
@@ -746,7 +734,6 @@ const blocks: Model[] = [
       seed: () => Graph.blocks({ charge: perPoint() }),
       ticks: 5, filmstrip: true, runs: 3, height: 90, density: false,
     },
-    closed: false,
   },
 
   ...([
@@ -765,7 +752,6 @@ const blocks: Model[] = [
       seed: () => Graph.emitters({ left, right }),
       ticks: 18, height: 140,
     },
-    closed: false,
   })),
 
   ...([
@@ -782,7 +768,6 @@ const blocks: Model[] = [
       seed: () => Graph.emitters({ left, right, gap: 20, every: 1, spin: true }),
       ticks: 22, height: 140,
     },
-    closed: false,
   })),
 ];
 
@@ -794,7 +779,6 @@ const asGroup = (
   const of = (line: Parameters<typeof Graph.line>[0]): Model => ({
     name: '',
     lattice: { seed: () => Graph.line(line), ...(lattice || {}) },
-    closed: false,
   });
 
   return {
@@ -837,7 +821,6 @@ const lines: Model[] = [
       seed: () => Graph.line(alternatingIntoRandom(size, inner)),
       ticks: size * 2, runs: 2, height: 60, density: false,
     },
-    closed: false,
   }))),
 ];
 
@@ -889,8 +872,38 @@ const lines: Model[] = [
  */
 const UNIT = 36;                          // cells per unit of the published solutions
 
-// And so the pace, solved rather than chosen — see above.
-const SWING = Math.sqrt(GRAVITY / UNIT);  // cells a tick per unit of their velocity
+/**
+ * How fast they are drawn, in cells a tick per unit of the published velocity.
+ *
+ * The similarity transform has two freedoms and only one equation. A published
+ * solution has `G = m = extent = 1`, and putting it on a length `S` and a speed
+ * `V` needs `G·m = S·V²` — so given the model's own `G`, one of the mass and
+ * the pace is chosen and the other is solved for.
+ *
+ * THE PACE IS THE ONE TO CHOOSE, and this had it the other way round. It used
+ * to fix the mass at one and solve `V = √(G/S)`, which was fine while `G` was
+ * a number near a half. It is no longer: `GRAVITY` now carries the grain (see
+ * `gravity.ts`), so it is of order 1e11, and solving for the pace asked these
+ * three bodies to travel fifty-nine thousand cells a tick — past light by six
+ * orders, and every one of the six benchmarks flew apart on the first frame.
+ *
+ * A mass is a free choice of units here and a pace is not: it decides whether
+ * a period fits in a run and whether the picture can be watched at all. So the
+ * pace is fixed at what these panels were always drawn at, and the mass is
+ * what gets solved. Which is also what `system()` does for the solar bodies —
+ * their masses are `gm·cells³/ticks²/GRAVITY` — so the two halves of the
+ * article now scale the same way.
+ */
+const SWING = 0.10951;                    // cells a tick per unit of their velocity
+
+/**
+ * And so what each of them weighs, solved from `G·m = S·V²`.
+ *
+ * Not a stated mass: `UNIT` and `SWING` are the two scaling choices, `GRAVITY`
+ * is the model's own, and this is the only value that leaves the published
+ * orbit the orbit it was published as.
+ */
+const TRIO = SWING * SWING * UNIT / GRAVITY;
 
 // Three equal masses: two out at ±1 and one at the middle, the outer pair
 // given the same velocity and the middle one twice it the other way, so the
@@ -979,13 +992,14 @@ const KNOWN_SPAN = UNIT * 3;
 const known: Model[] = KNOWN.map(({ name, note, sources }) => ({
   name: `three bodies: ${name}`,
   note,
-  world: { sources: sources.map(s => ({ ...s, settled: true })) },
+  // Every one of them weighing what the transform says — see `TRIO`. Set here
+  // rather than in each seed so no benchmark can be given a different one.
+  world: { sources: sources.map(s => ({ ...s, mass: TRIO, settled: true })) },
   lattice: false,
 
   // Only the metric reading, and the two classical ones beside it — the flow
   // account is a fourth picture of the same thing and would only crowd the
   // comparison these are here for.
-  closed: false,
 
   // Newton and Einstein, both given the model's OWN gravitational constant —
   // so all three panels are the same strength and the only question left is
@@ -1090,9 +1104,10 @@ const SUN = 39.4784176;                  // GM in AU^3/yr^2, for the Sun
  *
  * The mass conversion is the other piece worth reading. GM has units of
  * length³ over time², so in cells and ticks it is `gm·cells³/ticks²` — and a
- * mass here is that over `GRAVITY`, the constant this model was measured to
- * have (see `gravity.ts`). Nothing is fitted. Feed it the Sun and it works out
- * what the Sun weighs on a lattice.
+ * mass here is that over `GRAVITY`, the constant this model HAS (see
+ * `gravity.ts`, where it is a closed form rather than a calibration). Nothing
+ * is fitted. Feed it the Sun and it works out what the Sun weighs on a
+ * lattice.
  *
  * WHAT IS 1:1 HERE, checked rather than asserted. Every conversion above is
  * one constant applied to everything, so every ratio survives it exactly. At
@@ -1148,7 +1163,7 @@ type Body = [
  * only where they are COHERENT — equal rates — and averages it away otherwise;
  * beyond a wavelength the coherent answer converges to the same half anyway.
  * Given a spread of rates (below) no two bodies here are coherent, so every
- * pair uses the half exactly, which is what `GRAVITY` was measured against.
+ * pair uses the half exactly, which is what `GRAVITY` is derived against.
  * Measured: identical orbits to six figures before and after.
  */
 const SLOW = 96;
@@ -1396,7 +1411,6 @@ const systems: Model[] = ([
     // there are anything. And no flow reading, for the same reason as the
     // benchmarks — three panels is already the comparison.
     lattice: false,
-    closed: false,
 
     newton: { ...framed, gm: GRAVITY },
     relativity: { ...framed, gm: GRAVITY },
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
index e874ddf..d25b3d3 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
@@ -6,8 +6,23 @@
  *   alike(a,b)     = max(agreement, 0)            ... how much turns around
  *   cancelling(a,b)= max(−agreement, 0)           ... and how much annihilates
  *   outcome(a,b)   = cancelling > 0 ? annihilate : turn      the same, at ±1
- *   closing(u,v)   = max(−u·v, 0)                 meeting rather than crossing
+ *
+ *   MEETING IS BEING IN THE SAME CELL, at any angle. `closing` and `HEAD_ON`
+ *   below are the LINE's test — two things next to each other pointed the
+ *   opposite way — and on a line that is the only way to meet. In three
+ *   dimensions it is the exceptional way: two shells sweeping through each
+ *   other converge on the same cell from all angles, never neighbours and
+ *   never pointed at each other. So `outcome` decides it on polarity alone,
+ *   and what the angle sets is not WHETHER but HOW MUCH:
+ *
+ *   closing(u,v)   = max(−u·v, 0)                 still used by the drawing
  *   HEAD_ON        = 1/√2                         past which it is a crossing
+ *   splice(u,v)    = |û − v̂| = 2 sin(θ/2)         how much a meeting shortens:
+ *                                                 two cells head-on, nothing
+ *                                                 for two going the same way
+ *
+ *   alike charges leave along each other's headings — `^` in, `v` out, a full
+ *   reversal only when they met head-on. See `Graph.scatter`.
  *
  *   LIGHT          = 1 cell / tick                nothing goes faster
  *   BITE           = 2 LIGHT                      cells a meeting destroys
@@ -502,10 +517,13 @@ export type World = {
   // the direction itself. See `Graph.wander`.
   wander?: number;
 
-  // How many moves a charge lasts before it is space again, how far round the
-  // front counts as ahead when it fans, and how far out it waits before
-  // fanning at all. See `Graph.sources`.
+  // How many moves a charge lasts before it is space again. See
+  // `Graph.sources`.
+  //
+  // `spread` and `fanAt` used to sit here, tuning a fan that copied a charge
+  // into the ring of directions across its path so a pulse stayed a filled
+  // surface however far out it got. It is gone: a fixed count per shell does
+  // not thin, and the thinning IS the inverse square. See the note where the
+  // fan used to be.
   range?: number;
-  spread?: number;
-  fanAt?: number;
 };
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
index e47c0a9..3a86b22 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
@@ -2,12 +2,11 @@ import { Button } from "@blueprintjs/core";
 import { Fragment, useMemo, useRef, useState } from "react";
 
 import { Row } from "../../../lib/post/Post";
-import { ContinuousField } from "./continuous";
 import { Graph } from "./discrete";
 import { GraphCanvas } from "./GraphCanvas";
 import { MetricField } from "./metric";
 import {
-  Closed, closedOf, Lattice, latticeOf, metricOf, Model, newtonOf, relativityOf,
+  Closed, Lattice, latticeOf, metricOf, Model, newtonOf, relativityOf,
 } from "./model";
 import { NewtonField, RelativityField } from "./newton";
 
@@ -193,9 +192,6 @@ const LatticeFilmstrip = ({
 const LatticeView = ({ filmstrip, ...rest }: Lattice) =>
   filmstrip ? <LatticeFilmstrip {...rest} /> : <LatticePlayer {...rest} />;
 
-const ClosedView = ({ sources = [], span, cycle, rate, height = 320 }: Closed) =>
-  <ContinuousField sources={sources} span={span} cycle={cycle} rate={rate} height={height} />;
-
 const MetricView = ({ sources = [], span, cycle, rate, summary, height = 320 }: Closed) =>
   <MetricField
     sources={sources} span={span} cycle={cycle} rate={rate}
@@ -236,13 +232,12 @@ const Label = ({ children }: { children: any }) => (
  */
 export const ModelView = ({ model }: { model: Model }) => {
   const lattice = latticeOf(model);
-  const closed = closedOf(model);
   const metric = metricOf(model);
   const newton = newtonOf(model);
   const einstein = relativityOf(model);
 
   const readings =
-    [lattice, closed, newton, einstein, metric].filter(Boolean).length;
+    [lattice, newton, einstein, metric].filter(Boolean).length;
   const many = readings > 1;
 
   // A run repeated, where the arrangement is a draw rather than a case.
@@ -260,11 +255,6 @@ export const ModelView = ({ model }: { model: Model }) => {
         {runs.map(i => <LatticeView key={i} {...lattice} />)}
       </div> : null}
 
-      {closed ? <div>
-        {many ? <Label>written down — gravity as a flow</Label> : null}
-        <ClosedView {...closed} />
-      </div> : null}
-
       {newton ? <div>
         {many ? <Label>what Newton expects</Label> : null}
         <NewtonView {...newton} />
@@ -276,7 +266,7 @@ export const ModelView = ({ model }: { model: Model }) => {
       </div> : null}
 
       {metric ? <div>
-        {many ? <Label>written down — gravity as a metric</Label> : null}
+        {many ? <Label>written down</Label> : null}
         <MetricView {...metric} />
       </div> : null}
     </div>

From a3e60be7fb2a6daca19c7c4f2f41a98f3cb46c69 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sun, 9 Aug 2026 18:44:28 +0200
Subject: [PATCH 21/47] Sketch of what writing about the law would look like
 (temporary) - till I phrase it on my own

---
 .../2026.RayCalculiAndPhysics/gravity.ts      |  72 +-
 .../2026.RayCalculiAndPhysics/index.tsx       |   8 +
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 769 ++++++++++++++++++
 3 files changed, 815 insertions(+), 34 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index 3648fee..310f9ef 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -13,16 +13,16 @@
  *
  *   the pull, and it is an integral along ONE line — the line whose length is
  *   the distance between them, which is the line annihilation shortens:
- *     met(R)      = ∫₀^R dx / (max(x,CORE)²·max(R−x,CORE)²)   exactly:
- *                 = 2/(CORE·R(R−CORE))                the two cores
- *                 + (2/R²)(1/CORE − 1/(R−CORE))       their outsides
- *                 + (4/R³)·ln((R−CORE)/CORE)          the open middle
+ *     met(R)      = ∫₀^R dx / (max(x,c)²·max(R−x,c)²)     the line, exactly:
+ *                 = 4/(c·R²) · ( 1 + (c/R)·ln((R−c)/c) )
+ *                    ╰─────╯     ╰────────────────────╯
+ *                     Newton       what the middle adds
  *     S(a,b)      = BITE·share·screen·m_a·m_b·EMIT²·met(R)     meetings a tick
  *
- *   The first two terms are the inverse square and go as 1/CORE. The third is
- *   a RUNNING of the constant with separation, and it carries no CORE at all —
- *   so the ratio between them is CORE/R, and how many core radii apart two
- *   things are is the only thing that has ever moved it. See `GRAIN`.
+ *   One inverse square times one bracket that goes to one. The bracket is the
+ *   whole of the model's departure from Newton at a distance, its size is the
+ *   ratio of a source's core to the separation, and how many core radii apart
+ *   two things are is the only thing that has ever moved it. See `GRAIN`.
  *
  *   what a count of annihilations does to a body:
  *     BIAS        = LIGHT / WAYS                   what one of them buys, and
@@ -90,33 +90,37 @@ export const GRAIN = 1e12;
 const CORE = HALF / GRAIN;
 
 /**
- * The line between two things, integrated — exactly, with no walk.
- *
- * There used to be a numerical walk here: a few hundred samples along the
- * line, crowded into the ends by `x = R(1 − cos θ)/2` because that is where
- * the integrand lives. It is gone, and not because the integral is gone —
- * because `∫₀^R dx / (max(x,h)²·max(R−x,h)²)` has a closed form, and sampling
- * something you can write down buys nothing but a sample count.
- *
- * It buys nothing and it COSTS the thing that matters: a walk can only resolve
- * a core it puts samples inside, and the innermost sample of that substitution
- * lands at about `R·π²/16N²`. Resolving a core a trillionth of a cell across
- * would have taken ten million samples a pair a step. Done exactly, the core
- * can be as small as it physically is rather than as small as an integrator
- * can afford.
- *
- *     ends    2 / (h·R·(R−h))                    the two half-cells
- *     near    (2/R²)(1/h − 1/(R−h))              their outsides
- *     middle  (4/R³)·ln((R−h)/h)                 the open line, and the log
- *
- * The first two are the inverse square and go as `1/h`. The third is the
- * running, and it carries no `h` at all — which is why the ratio between them
- * is `h/R` and why shrinking the core is the only thing that ever moved it.
+ * The line between two things, integrated — exactly, and it is Newton times a
+ * bracket.
+ *
+ * `∫₀^R dx / (max(x,c)²·max(R−x,c)²)` has a closed form, and the closed form
+ * collapses: the two core terms and the two outside them differ by `(R − c)`,
+ * which cancels, leaving
+ *
+ *     met(R) = 4/(c R²) · ( 1 + (c/R)·ln((R−c)/c) )
+ *                ╰──────╯   ╰────────────────────╯
+ *                 Newton      what the middle adds
+ *
+ * — one inverse square, times one bracket that goes to one. Which says the
+ * whole thing at a glance: the model IS Newton, with a correction whose entire
+ * size is the ratio of a source's core to the separation, log-enhanced. At a
+ * core of half a lattice step and Mercury's separation the bracket is 1.08; at
+ * the grain a real lattice would have, it is 1 + 10⁻³⁸.
+ *
+ * There used to be a numerical walk here — a few hundred samples along the
+ * line, crowded into the ends by `x = R(1 − cos θ)/2` because that is where the
+ * integrand lives. Sampling something you can write down buys nothing, and it
+ * COSTS the thing that matters: a walk can only resolve a core it puts samples
+ * inside, and the innermost sample of that substitution lands at about
+ * `R·π²/16N²`. Resolving a core a trillionth of a cell across would have taken
+ * ten million samples a pair a step. Written down, the core can be as small as
+ * it physically is rather than as small as an integrator can afford.
+ *
+ * It is also better conditioned than the form it replaces, which had two large
+ * terms of opposite construction to add.
  */
-const met = (R: number, h: number) =>
-  2 / (h * R * (R - h))
-  + (2 / (R * R)) * (1 / h - 1 / (R - h))
-  + (4 / (R * R * R)) * Math.log((R - h) / h);
+const met = (R: number, c: number) =>
+  4 / (c * R * R) * (1 + (c / R) * Math.log((R - c) / c));
 
 /** What a source of unit mass puts on the line, per unit of it. */
 const EMIT = SHEET / (4 * Math.PI);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
index e6de5e6..d9675a2 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
@@ -3,6 +3,7 @@ import Post, {
   useCounter,
 } from "../../../lib/post/Post";
 import { RAY_CALCULI_AND_PHYSICS } from "../../references";
+import { Law } from "./law";
 import { MODELS } from "./models";
 import { Models } from "./views";
 
@@ -19,6 +20,12 @@ import { Models } from "./views";
  * an arrangement MEANS, edit `discrete.ts` and `metric.tsx`, which are the
  * two readings, and which share their vocabulary through `lattice.ts` and
  * `physics.ts` so that neither can drift from the other by redefining a term.
+ *
+ * The one thing that is not an arrangement is `law.tsx`, which states the
+ * whole model as an equation before any of them — and, more to the point,
+ * says which of its constants are put in and which come out. It reads its
+ * numbers from `gravity.ts` rather than restating them, so there is no second
+ * copy to drift.
  */
 const RayCalculiAndPhysics = () => {
   const referenceCounter = useCounter();
@@ -35,6 +42,7 @@ const RayCalculiAndPhysics = () => {
   return <Post {...paper}>
     <Arc head="">
       <Section head="">
+        <Law />
         <Models models={MODELS} />
       </Section>
     </Arc>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
new file mode 100644
index 0000000..28d9e74
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -0,0 +1,769 @@
+import { Fragment, ReactNode, useEffect, useRef, useState } from "react";
+
+import { GRAIN } from "./gravity";
+
+/**
+ * The law, on the page — and behind each equation, where it came from.
+ *
+ * It is also in the headers of `gravity.ts` and `metric.tsx`, and the reason it
+ * is here as well is that a reader of the article is not a reader of the
+ * source. `GRAIN` is read from `gravity.ts` rather than restated, so there is
+ * no second copy of a number to drift.
+ *
+ * Set rather than drawn: there is no maths library in this repository and the
+ * article has a PDF path, so the notation is built out of flex boxes and a
+ * border for the rule. Which is enough — a fraction is a numerator over a
+ * denominator with a line between. Variables lean, the lattice's own counts
+ * stand upright and are coloured, so a reader can see at a glance which
+ * symbols are quantities and which are the model's constants.
+ *
+ * EVERY DERIVED EQUATION OPENS. Which is the point of the section: a model
+ * whose constants are all counts and a model with six fitted parameters look
+ * identical once they are drawn, and the only way to tell them apart is to be
+ * able to ask any line where it came from and get an answer.
+ */
+
+const INK = '#c6c9d4';
+const DIM = '#8a8d99';
+const FAINT = '#6c7080';
+const RULE = '#1c1e27';
+const NAMED = '#e0a878';        // a count the lattice fixes
+const DERIVED = '#7fb8d4';      // something that came out
+
+const SERIF = 'Georgia, "Times New Roman", serif';
+
+// —— notation ————————————————————————————————————————————————————————————
+
+/** A quantity. Leans, as a variable should. */
+const V = ({ children }: { children: ReactNode }) => (
+  <span style={{ fontStyle: 'italic' }}>{children}</span>
+);
+
+/** One of the lattice's own counts. Upright, and coloured. */
+const K = ({ children }: { children: ReactNode }) => (
+  <span style={{ color: NAMED, fontStyle: 'normal' }}>{children}</span>
+);
+
+/** A vector. Upright and bold, the way a vector is set. */
+const B = ({ children }: { children: ReactNode }) => (
+  <span style={{ fontWeight: 700, fontStyle: 'normal' }}>{children}</span>
+);
+
+const Sub = ({ children }: { children: ReactNode }) => (
+  <sub style={{ fontSize: '0.72em', fontStyle: 'italic' }}>{children}</sub>
+);
+
+const Sup = ({ children }: { children: ReactNode }) => (
+  <sup style={{ fontSize: '0.72em' }}>{children}</sup>
+);
+
+/** A fraction, which is the only thing here that needs building. */
+const Frac = ({ over, under }: { over: ReactNode, under: ReactNode }) => (
+  <span style={{
+    display: 'inline-flex', flexDirection: 'column', alignItems: 'center',
+    verticalAlign: 'middle', margin: '0 0.35em', lineHeight: 1.25,
+  }}>
+    <span style={{ padding: '0 0.4em' }}>{over}</span>
+    <span style={{
+      borderTop: '1px solid currentColor', padding: '0.12em 0.4em 0',
+      marginTop: '0.12em', width: '100%', textAlign: 'center',
+    }}>{under}</span>
+  </span>
+);
+
+/**
+ * Brackets big enough for what is inside them.
+ *
+ * By making the GLYPH bigger, not by stretching one. `scaleY` on a parenthesis
+ * smears a small bracket's stroke weight upward — thin at the ends, heavy in
+ * the middle, baseline in the wrong place. A larger glyph scales its strokes
+ * along with its height, which is what a bigger bracket IS. Centred by flex so
+ * it sits on the middle of whatever it contains, however tall that is.
+ */
+const Paren = ({ children }: { children: ReactNode }) => (
+  <span style={{ display: 'inline-flex', alignItems: 'center', verticalAlign: 'middle' }}>
+    <span style={{ fontSize: '2.2em', lineHeight: 0.72, fontStyle: 'normal', fontWeight: 300 }}>(</span>
+    <span style={{ padding: '0 0.12em' }}>{children}</span>
+    <span style={{ fontSize: '2.2em', lineHeight: 0.72, fontStyle: 'normal', fontWeight: 300 }}>)</span>
+  </span>
+);
+
+/** A hat, for a direction. */
+const Hat = ({ children }: { children: ReactNode }) => (
+  <span style={{ position: 'relative', display: 'inline-block', fontStyle: 'italic' }}>
+    <span style={{
+      position: 'absolute', left: 0, right: 0, top: '-0.62em',
+      textAlign: 'center', fontSize: '0.85em', fontStyle: 'normal',
+    }}>^</span>
+    {children}
+  </span>
+);
+
+const Note = ({ children }: { children: ReactNode }) => (
+  <div style={{ color: DIM, fontSize: '0.88em', lineHeight: 1.6, paddingTop: '0.5em' }}>
+    {children}
+  </div>
+);
+
+// —— the derivations, and the panel they open in —————————————————————————
+
+type Derivation = { title: ReactNode; label: string; body: ReactNode };
+
+/** A step of working: the line, then why. */
+const Step = ({ eq, children }: { eq?: ReactNode, children: ReactNode }) => (
+  <div style={{ padding: '0 0 1.4em' }}>
+    {eq ? <div style={{
+      fontFamily: SERIF, fontSize: '1.05em', color: INK,
+      overflowX: 'auto', padding: '0.3em 0 0.6em',
+    }}><div style={{ display: 'inline-block', whiteSpace: 'nowrap' }}>{eq}</div></div> : null}
+    <div style={{ color: DIM, fontSize: '0.87em', lineHeight: 1.62 }}>{children}</div>
+  </div>
+);
+
+const Because = ({ children }: { children: ReactNode }) => (
+  <div style={{
+    color: FAINT, fontSize: '0.68em', letterSpacing: '0.09em',
+    textTransform: 'uppercase', padding: '0.6em 0 0.5em',
+  }}>{children}</div>
+);
+
+/**
+ * The panel itself.
+ *
+ * Dismissed three ways, because a thing that covers half the screen has to be
+ * easy to be rid of: the backdrop, Escape, and a control that says so. Focus
+ * moves into it on open and back to whatever opened it on close, so a reader
+ * who arrived by keyboard is not stranded at the top of the document.
+ */
+const Panel = ({ of, onClose }: { of: Derivation, onClose: () => void }) => {
+  const panel = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const key = (e: KeyboardEvent) => { if (e.key === 'Escape') onClose(); };
+
+    document.addEventListener('keydown', key);
+    panel.current?.focus();
+
+    return () => document.removeEventListener('keydown', key);
+  }, [onClose]);
+
+  return <>
+    <div
+      onClick={onClose}
+      style={{
+        position: 'fixed', inset: 0, zIndex: 60,
+        background: 'rgba(4,5,9,0.6)',
+      }}
+    />
+    <div
+      ref={panel}
+      role="dialog"
+      aria-modal="true"
+      aria-label={`Where ${of.label} comes from`}
+      tabIndex={-1}
+      className="law-panel"
+      style={{
+        position: 'fixed', top: 0, right: 0, bottom: 0, zIndex: 61,
+        width: 'min(38rem, 94vw)', overflowY: 'auto', outline: 'none',
+        background: '#080910', borderLeft: `1px solid ${RULE}`,
+        boxShadow: '-24px 0 60px rgba(0,0,0,0.5)',
+        padding: '2.2rem 2rem 4rem',
+      }}
+    >
+      <style>{`
+        .law-panel { animation: lawIn 180ms ease-out }
+        @keyframes lawIn { from { transform: translateX(2rem); opacity: 0 } }
+        @media (prefers-reduced-motion: reduce) {
+          .law-panel { animation: none }
+        }
+      `}</style>
+
+      <div style={{
+        display: 'flex', alignItems: 'baseline', justifyContent: 'space-between',
+        gap: '1rem', paddingBottom: '1.4rem', borderBottom: `1px solid ${RULE}`,
+        marginBottom: '1.6rem',
+      }}>
+        <div>
+          <div style={{
+            color: FAINT, fontSize: '0.68em', letterSpacing: '0.09em',
+            textTransform: 'uppercase',
+          }}>where it comes from</div>
+          <div style={{
+            fontFamily: SERIF, fontSize: '1.35em', color: INK, paddingTop: '0.25em',
+          }}>{of.title}</div>
+        </div>
+
+        <button
+          onClick={onClose}
+          aria-label="Close"
+          style={{
+            background: 'none', border: `1px solid ${RULE}`, borderRadius: 2,
+            color: DIM, cursor: 'pointer', fontSize: '0.75em',
+            padding: '0.35em 0.7em', flexShrink: 0,
+          }}
+        >esc</button>
+      </div>
+
+      {of.body}
+    </div>
+  </>;
+};
+
+/**
+ * A displayed equation. Clickable when there is working behind it, and looking
+ * clickable — a derived line and a stated one must not be the same object.
+ */
+const Eq = (
+  { children, note, derive, open }:
+    { children: ReactNode, note?: ReactNode, derive?: Derivation, open?: (d: Derivation) => void },
+) => {
+  const inner = <>
+    <div style={{
+      overflowX: 'auto', textAlign: 'center', color: INK,
+      fontFamily: SERIF, fontSize: '1.18em', padding: '0.2em 0',
+    }}>
+      <div style={{ display: 'inline-block', whiteSpace: 'nowrap' }}>{children}</div>
+    </div>
+    {note ? <div style={{
+      textAlign: 'center', color: FAINT, fontSize: '0.72em',
+      letterSpacing: '0.04em', paddingTop: '0.5em',
+    }}>{note}</div> : null}
+  </>;
+
+  if (!derive || !open) return <div style={{ margin: '1.5em 0' }}>{inner}</div>;
+
+  return (
+    <button
+      onClick={() => open(derive)}
+      style={{
+        display: 'block', width: '100%', margin: '1.5em 0',
+        background: 'none', border: '1px solid transparent', borderRadius: 3,
+        padding: '0.9em 0.5em 0.7em', cursor: 'pointer', font: 'inherit',
+        color: 'inherit', textAlign: 'inherit', position: 'relative',
+        transition: 'background 120ms, border-color 120ms',
+      }}
+      onMouseEnter={e => {
+        e.currentTarget.style.background = 'rgba(127,184,212,0.05)';
+        e.currentTarget.style.borderColor = RULE;
+      }}
+      onMouseLeave={e => {
+        e.currentTarget.style.background = 'none';
+        e.currentTarget.style.borderColor = 'transparent';
+      }}
+      onFocus={e => { e.currentTarget.style.borderColor = DERIVED; }}
+      onBlur={e => { e.currentTarget.style.borderColor = 'transparent'; }}
+    >
+      {inner}
+      <span style={{
+        position: 'absolute', right: '0.7em', top: '0.45em',
+        color: DERIVED, fontSize: '0.6em', letterSpacing: '0.1em',
+        textTransform: 'uppercase', opacity: 0.75,
+      }}>derived ›</span>
+    </button>
+  );
+};
+
+const Head = ({ children }: { children: ReactNode }) => (
+  <div style={{
+    color: FAINT, fontSize: '0.7em', letterSpacing: '0.09em',
+    textTransform: 'uppercase', padding: '2.2em 0 0.1em',
+    borderTop: `1px solid ${RULE}`, marginTop: '2em',
+  }}>{children}</div>
+);
+
+/** symbol → what it is, laid out so the symbols line up down the page. */
+const Rows = ({ of }: { of: [ReactNode, ReactNode][] }) => (
+  <div style={{
+    display: 'grid', gridTemplateColumns: 'minmax(6.5em, max-content) 1fr',
+    gap: '0.75em 1.4em', alignItems: 'baseline', padding: '1em 0 0.2em',
+  }}>
+    {of.map(([sym, what], i) => <Fragment key={i}>
+      <div style={{
+        fontFamily: SERIF, fontSize: '1.02em', color: INK, whiteSpace: 'nowrap',
+      }}>{sym}</div>
+      <div style={{ color: DIM, fontSize: '0.86em', lineHeight: 1.55 }}>{what}</div>
+    </Fragment>)}
+  </div>
+);
+
+// —— what is behind each line ————————————————————————————————————————————
+
+const LAW: Derivation = {
+  label: 'the law',
+  title: 'the law',
+  body: <>
+    <Because>the rule</Because>
+    <Step>
+      An annihilation removes the two points its charges were on and joins what
+      was behind each onto what was behind the other. So the place it happened
+      is left with more space folded into it than its neighbours have.
+    </Step>
+
+    <Because>what that does to a path through it</Because>
+    <Step eq={<>
+      <Frac over={<>1 + <V>n</V></>} under={<>1, and there are <K>WAYS</K> of them</>} />
+    </>}>
+      A path arriving there has more ways of going the way the annihilation
+      went than of going any other. One makes it two to one, a second three to
+      one, a third four — the direction accumulates weight one annihilation at
+      a time, while every other way out of the point still weighs exactly what
+      it always did. There are <K>WAYS</K> = 26 of those.
+    </Step>
+
+    <Step eq={<><K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>WAYS</K>} /></>}>
+      So the net lean is <K>LIGHT</K>·<V>n</V>/<K>WAYS</K> — linear in the
+      count, with no ceiling in it — and one annihilation is worth <K>BIAS</K>.
+      This is the only constant in the dynamics, and it is a ratio of two
+      counts.
+    </Step>
+
+    <Because>per tick of whose clock</Because>
+    <Step eq={<>
+      <B>v</B> = <Frac over={<B>u</B>}
+        under={<>√(1 + |<B>u</B>|<Sup>2</Sup>/<K>LIGHT</K><Sup>2</Sup>)</>} />
+    </>}>
+      The counting happens on the body’s own worldline, so{' '}
+      <K>LIGHT</K>·<V>n</V>/<K>WAYS</K> is cells per tick of <i>its</i> clock —
+      a proper velocity, not a coordinate one. Turning that into what the
+      picture shows is one line of arithmetic the model does not get to choose.
+      Nothing is clamped: the ceiling at <K>LIGHT</K> is the one arithmetic
+      already has.
+    </Step>
+
+    <Because>and so</Because>
+    <Step eq={<>
+      <Frac over={<>d</>} under={<>d<V>t</V></>} />
+      ( <V>m</V><Sub>a</Sub> <B>u</B><Sub>a</Sub> ) &nbsp;=&nbsp;
+      <K>BIAS</K> · <V>S</V><Sub>ab</Sub>
+    </>}>
+      A body’s count grows by <K>BIAS</K>·<V>S</V> divided by its own mass —
+      the <i>fraction</i> of its paths that were bent, since its path count is
+      its mass. Multiply back through and the mass cancels out of the statement
+      entirely. And <V>m</V><B>u</B> = <V>γm</V><B>v</B> is momentum, so what
+      the equation says is that <b style={{ color: INK }}>momentum gained is{' '}
+        <K>BIAS</K> times annihilations taken part in</b>.
+    </Step>
+
+    <Because>what falls out of it</Because>
+    <Step>
+      Dividing by <V>m</V><Sub>a</Sub> leaves{' '}
+      <V>a</V><Sub>a</Sub> ∝ <V>m</V><Sub>b</Sub>/<V>R</V><Sup>2</Sup> — the
+      equivalence principle as a counting statement rather than a postulate.
+      And differentiating <B>v</B>(<B>u</B>) gives 1/<V>γ</V><Sup>3</Sup> along
+      the way a thing is going and 1/<V>γ</V> across it: special relativity’s
+      own response, out of a count of ways out of a point.
+    </Step>
+  </>,
+};
+
+const MEETINGS: Derivation = {
+  label: 'the meeting rate',
+  title: <>the meeting rate <V>S</V><Sub>ab</Sub></>,
+  body: <>
+    <Because>what a source puts on a place</Because>
+    <Step eq={<>
+      chance(<V>m</V>,<V>r</V>) =
+      <Frac over={<><V>m</V> · <K>SHEET</K></>} under={<>shell(<V>r</V>)</>} />
+    </>}>
+      A source lets go of <K>SHEET</K> charges per pulse and they spread over
+      the shell they have grown to, so the chance any one cell holds one is
+      that count over how much shell there is.{' '}
+      <b style={{ color: INK }}>This is where the inverse square is</b> — a
+      shell in three dimensions goes as <V>r</V><Sup>2</Sup>, and no distance
+      law was ever written down. Send the waves out differently and the
+      exponent changes with nothing else touched.
+    </Step>
+
+    <Because>two of them in the same cell</Because>
+    <Step eq={<>
+      chance(<V>m</V><Sub>a</Sub>, <V>x</V>) ·
+      chance(<V>m</V><Sub>b</Sub>, <V>R</V> − <V>x</V>)
+    </>}>
+      Meeting means being in the same place — not travelling toward each other.
+      Two shells sweeping through one another converge on the same cell from
+      all angles, never neighbours and never pointed at each other, so the
+      chance of a meeting is simply the chance both are there.
+    </Step>
+
+    <Because>along which line</Because>
+    <Step>
+      The one whose length is the distance between them, because that is the
+      line annihilation shortens. This is load-bearing rather than convenient:
+      integrating the same quantity over <i>space</i> gives{' '}
+      <V>R</V><Sup>−1</Sup> instead of <V>R</V><Sup>−2</Sup> — measured. In one
+      dimension the cores dominate and you get Newton; in three the bulk
+      dominates and you do not.
+    </Step>
+
+    <Because>and the factors in front</Because>
+    <Step eq={<>
+      <V>S</V><Sub>ab</Sub> = <K>BITE</K> · share · screen ·
+      <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> · EMIT<Sup>2</Sup> · met(<V>R</V>)
+    </>}>
+      <K>BITE</K> = 2 is what the rule says one meeting costs — a point for
+      each charge. <i>share</i> is how much of what meets is opposite rather
+      than alike, which is a half unless two sources keep time together.{' '}
+      <i>screen</i> is what a third body standing in the way blocks, and it is
+      a genuine prediction: Newton has no such term, and neither does
+      relativity at this order.
+    </Step>
+  </>,
+};
+
+const MET: Derivation = {
+  label: 'met(R)',
+  title: <>met(<V>R</V>)</>,
+  body: <>
+    <Because>what is being integrated</Because>
+    <Step eq={<>
+      met(<V>R</V>) = ∫<Sub>0</Sub><Sup><V>R</V></Sup>
+      <Frac over={<>d<V>x</V></>}
+        under={<>max(<V>x</V>,<V>c</V>)<Sup>2</Sup> ·
+          max(<V>R</V>−<V>x</V>,<V>c</V>)<Sup>2</Sup></>} />
+    </>}>
+      The two densities multiplied together, summed along the line. The masses
+      and EMIT come straight out of the integral, leaving only this. The{' '}
+      <i>max</i> is there because a shell is never smaller than the cell its
+      source sits in.
+    </Step>
+
+    <Because>the max makes it piecewise — so cut it in three</Because>
+    <Step eq={<span style={{ fontFamily: 'ui-monospace, Menlo, monospace', fontSize: '0.8em' }}>
+      a ●━━━━━━━━━━━━━━━━━━━━━━━● b<br />
+      &nbsp;&nbsp;╰c╯╰──── middle ────╯╰c╯
+    </span>}>
+      Inside <V>c</V> of either body its own field is capped and flat. Between
+      them, nothing is capped.
+    </Step>
+
+    <Because>the two cores</Because>
+    <Step eq={<>
+      ∫<Sub>0</Sub><Sup><V>c</V></Sup>
+      <Frac over={<>d<V>x</V></>}
+        under={<><V>c</V><Sup>2</Sup>(<V>R</V>−<V>x</V>)<Sup>2</Sup></>} />
+      &nbsp;=&nbsp;
+      <Frac over={<>1</>} under={<><V>c R</V>(<V>R</V> − <V>c</V>)</>} />
+    </>}>
+      Dense — <V>a</V>’s field at its highest anywhere — but only <V>c</V> long,
+      and <V>b</V>’s field across it flat at 1/<V>R</V><Sup>2</Sup>. The far
+      core is the same integral mirrored, contributing the same again.
+    </Step>
+
+    <Because>the middle, by partial fractions</Because>
+    <Step eq={<>
+      <Frac over={<>1</>}
+        under={<><V>x</V><Sup>2</Sup>(<V>R</V>−<V>x</V>)<Sup>2</Sup></>} /> =
+      <Frac over={<>2</>} under={<><V>R</V><Sup>3</Sup></>} />
+      <Frac over={<>1</>} under={<V>x</V>} /> +
+      <Frac over={<>1</>} under={<><V>R</V><Sup>2</Sup></>} />
+      <Frac over={<>1</>} under={<><V>x</V><Sup>2</Sup></>} />
+      &nbsp;+&nbsp; mirror
+    </>}>
+      Matching the <V>x</V><Sup>2</Sup> coefficient is what forces the{' '}
+      2/<V>R</V><Sup>3</Sup>. Integrating from <V>c</V> to <V>R</V>−<V>c</V>,
+      the 1/<V>x</V><Sup>2</Sup> terms give another core-like piece — and{' '}
+      <b style={{ color: INK }}>the 1/<V>x</V> terms give a logarithm</b>.
+    </Step>
+
+    <Because>add the three regions</Because>
+    <Step eq={<>
+      <Frac over={<>2</>} under={<><V>cR</V>(<V>R</V>−<V>c</V>)</>} /> +
+      <Frac over={<>2</>} under={<><V>R</V><Sup>2</Sup></>} />
+      <Paren>
+        <Frac over={<>1</>} under={<V>c</V>} /> −
+        <Frac over={<>1</>} under={<><V>R</V>−<V>c</V></>} />
+      </Paren> +
+      <Frac over={<>4</>} under={<><V>R</V><Sup>3</Sup></>} />
+      ln <Frac over={<><V>R</V>−<V>c</V></>} under={<V>c</V>} />
+    </>}>
+      Three terms. And then the first two collapse.
+    </Step>
+
+    <Because>over a common denominator, the (R − c) cancels</Because>
+    <Step eq={<>
+      <Frac over={<>2<V>R</V> + 2(<V>R</V>−2<V>c</V>)</>}
+        under={<><V>cR</V><Sup>2</Sup>(<V>R</V>−<V>c</V>)</>} /> =
+      <Frac over={<>4(<V>R</V>−<V>c</V>)</>}
+        under={<><V>cR</V><Sup>2</Sup>(<V>R</V>−<V>c</V>)</>} /> =
+      <Frac over={<>4</>} under={<><V>cR</V><Sup>2</Sup></>} />
+    </>}>
+      Which is the whole reason the expression is as short as it is.
+    </Step>
+
+    <Because>so</Because>
+    <Step eq={<>
+      met(<V>R</V>) = <Frac over={<>4</>} under={<><V>c R</V><Sup>2</Sup></>} />
+      <Paren>
+        1 + <Frac over={<V>c</V>} under={<V>R</V>} /> ln
+        <Frac over={<><V>R</V>−<V>c</V></>} under={<V>c</V>} />
+      </Paren>
+    </>}>
+      An inverse square times a bracket that goes to one. The 1/<V>c</V> is the
+      cores — dense, but only <V>c</V> long. The logarithm is the middle —
+      thin, but <V>R</V> long, accumulating equally per octave of distance,
+      because that 1/<V>x</V> came from the <i>gradient</i> of each body’s
+      field across the other’s near zone.
+    </Step>
+
+    <Because>checked</Because>
+    <Step>
+      Against brute-force numerical integration, at every separation and core
+      size tried, to eight significant figures.
+    </Step>
+  </>,
+};
+
+const CONSTANTS: Derivation = {
+  label: 'BIAS and c',
+  title: <><K>BIAS</K> and <V>c</V></>,
+  body: <>
+    <Because>BIAS</Because>
+    <Step eq={<>
+      <K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>WAYS</K>} /> =
+      <Frac over={<>1</>} under={<>26</>} />
+    </>}>
+      What one annihilation buys a path. <K>WAYS</K> = 3<Sup>3</Sup> − 1 is how
+      many ways out of a point there are — the alternatives the biased path did
+      not take. Note this is <i>not</i> <K>SHEET</K>, which is how many charges
+      a source emits in one pulse: a different question, and the same constant
+      was doing both jobs until it was noticed.
+    </Step>
+
+    <Because>c</Because>
+    <Step eq={<><V>c</V> = <Frac over={<K>HALF</K>} under={<K>GRAIN</K>} /></>}>
+      A source’s core, in drawn cells. <K>HALF</K> is half a lattice step — a
+      shell is never smaller than the cell its source sits in — and{' '}
+      <K>GRAIN</K> is how many lattice steps a drawn cell stands for.
+    </Step>
+
+    <Because>why the second one has to exist</Because>
+    <Step>
+      Because the bracket in met(<V>R</V>) depends on <V>c</V>/<V>R</V>, and
+      that ratio was being read off the <i>drawing</i>. The article draws
+      twenty-eight cells to the astronomical unit so that a wave is visible, so
+      Mercury sat eight cells from the Sun and the correction came out at 16% —
+      a picture’s zoom setting the force law. A lattice step is a length, not a
+      pixel. If it is anything like a fundamental one, Sun and Mercury are an
+      astronomical number of them apart and the bracket is{' '}
+      1 + 10<Sup>−38</Sup>.
+    </Step>
+  </>,
+};
+
+const FULL: Derivation = {
+  label: 'the law in full',
+  title: 'the law in full',
+  body: <>
+    <Because>put the pieces together</Because>
+    <Step eq={<>
+      <Frac over={<>d<V>p</V></>} under={<>d<V>t</V></>} /> = <K>BIAS</K> ·
+      <K>BITE</K> · share · <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> ·
+      EMIT<Sup>2</Sup> · met(<V>R</V>)
+    </>}>
+      Momentum gained is <K>BIAS</K> times the meetings, and the meetings are
+      the two densities integrated along the line.
+    </Step>
+
+    <Because>substitute met, with share = ½ and BITE = 2</Because>
+    <Step eq={<>
+      <Frac over={<>d<V>p</V></>} under={<>d<V>t</V></>} /> =
+      <Frac over={<><K>SHEET</K><Sup>2</Sup></>}
+        under={<>4<V>π</V><Sup>2</Sup><V>c</V> <K>WAYS</K></>} /> ·
+      <Frac over={<><V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub></>}
+        under={<><V>R</V><Sup>2</Sup></>} />
+      <Paren>1 + <Frac over={<V>c</V>} under={<V>R</V>} /> ln
+        <Frac over={<><V>R</V>−<V>c</V></>} under={<V>c</V>} /></Paren>
+    </>}>
+      The 4 from met, the 2 from <K>BITE</K> and the ½ from <i>share</i> fold
+      into the (4<V>π</V>)<Sup>2</Sup> in EMIT<Sup>2</Sup>, and everything left
+      standing is a count.
+    </Step>
+
+    <Because>which is a gravitational constant</Because>
+    <Step eq={<>
+      <V>G</V> = <Frac over={<><K>SHEET</K><Sup>2</Sup></>}
+        under={<>4<V>π</V><Sup>2</Sup><V>c</V> <K>WAYS</K></>} />
+    </>}>
+      Not measured off a run and not fitted — the far limit of met, in closed
+      form, out of charges per pulse, ways out of a point, and the size of a
+      source’s own cell.
+    </Step>
+
+    <Because>and so</Because>
+    <Step>
+      <b style={{ color: INK }}>Newton, times a bracket that goes to one.</b>{' '}
+      The whole of the model’s departure from Newton at a distance is that
+      bracket, and its size is the ratio of a source’s core to the separation.
+    </Step>
+  </>,
+};
+
+// —— the law —————————————————————————————————————————————————————————————
+
+export const Law = () => {
+  const [open, setOpen] = useState<Derivation | null>(null);
+  const from = useRef<HTMLElement | null>(null);
+
+  const show = (d: Derivation) => {
+    from.current = document.activeElement as HTMLElement;
+    setOpen(d);
+  };
+
+  const hide = () => {
+    setOpen(null);
+    from.current?.focus();
+  };
+
+  return <div style={{ marginBottom: '3rem' }}>
+
+    <div style={{
+      color: FAINT, fontSize: '0.7em', letterSpacing: '0.09em',
+      textTransform: 'uppercase', paddingBottom: '0.1em',
+    }}>the law</div>
+
+    <Note>
+      One rule. Two charges arriving at the same point annihilate if they are
+      opposite — both points go, and what was behind each is joined onto what
+      was behind the other — and if they are alike they leave along each
+      other’s headings. Nothing is pushed. There is simply less space between
+      two things than there was, and everything below is what that comes to.{' '}
+      <span style={{ color: DERIVED }}>
+        Every equation marked <i>derived</i> opens its own working.
+      </span>
+    </Note>
+
+    <Eq derive={LAW} open={show}
+      note="the momentum a body gains is BIAS times the annihilations it took part in">
+      <Frac over={<>d</>} under={<>d<V>t</V></>} />
+      ( <V>γ</V> <V>m</V><Sub>a</Sub> <B>v</B><Sub>a</Sub> )
+      &nbsp;=&nbsp; <K>BIAS</K> · <span style={{ fontSize: '1.3em' }}>Σ</span>
+      <Sub>b ≠ a</Sub> &nbsp;<V>S</V><Sub>ab</Sub> <Hat>r</Hat><Sub>ab</Sub>
+    </Eq>
+
+    <Eq derive={MEETINGS} open={show}>
+      <V>S</V><Sub>ab</Sub> &nbsp;=&nbsp; <K>BITE</K> ·
+      <Paren><Frac over={<K>SHEET</K>} under={<>4<V>π</V></>} /></Paren><Sup>2</Sup>
+      · share · screen · <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> ·
+      met(<V>R</V>)
+    </Eq>
+
+    <Eq derive={MET} open={show} note="one inverse square, times one bracket that goes to one">
+      met(<V>R</V>) &nbsp;=&nbsp;
+      <Frac over={<>4</>} under={<><V>c R</V><Sup>2</Sup></>} />
+      <Paren>
+        1 &nbsp;+&nbsp; <Frac over={<V>c</V>} under={<V>R</V>} /> ln
+        <Frac over={<><V>R</V> − <V>c</V></>} under={<V>c</V>} />
+      </Paren>
+    </Eq>
+
+    <Eq derive={CONSTANTS} open={show}>
+      <K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>WAYS</K>} /> =
+      <Frac over={<>1</>} under={<>26</>} />
+      <span style={{ padding: '0 1.6em' }} />
+      <V>c</V> = <Frac over={<K>HALF</K>} under={<K>GRAIN</K>} />
+    </Eq>
+
+    <Head>what is put in</Head>
+    <Note>Six countable facts about the lattice, and nothing else is assumed.</Note>
+
+    <Rows of={[
+      [<><K>WAYS</K> = 3<Sup>3</Sup> − 1 = 26</>,
+        <>ways out of a point — the 3×3×3 block around it, minus itself</>],
+      [<><K>SHEET</K> = 3<Sup>2</Sup> − 1 = 8</>,
+        <>charges in one pulse: the plane a source emits into, which turns with it</>],
+      [<><K>BITE</K> = 2</>,
+        <>points an annihilation removes — one for each charge</>],
+      [<><K>LIGHT</K> = 1</>,
+        <>points per tick, and nothing goes faster</>],
+      [<><K>HALF</K> = ½</>,
+        <>a shell is never smaller than the cell its source sits in</>],
+      [<V>m</V>,
+        <>mass is how <i>often</i> a thing emits. Not a property it has.</>],
+    ]} />
+
+    <Head>what is derived</Head>
+    <Note>
+      None of this is stated. It is what those six come to, and it is the
+      difference between a model and a fit.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>chance(<V>m</V>,<V>r</V>)</span>,
+        <><b style={{ color: INK }}>The inverse square.</b> One pulse spread
+          over the shell it has grown to — and a shell in three dimensions goes
+          as <V>r</V><Sup>2</Sup>. No distance law was ever written down.</>],
+      [<span style={{ color: DERIVED }}>met(<V>R</V>)</span>,
+        <>The line between two bodies, integrated — and it collapses to an
+          inverse square times a bracket. What the bracket adds is{' '}
+          <V>c</V>/<V>R</V>, log-enhanced.</>],
+      [<span style={{ color: DERIVED }}><V>G</V></span>,
+        <>The far limit of met. Every symbol a count. Nothing fitted, and not
+          measured off a run.</>],
+      [<span style={{ color: DERIVED }}>
+        <V>a</V><Sub>a</Sub> ∝ <V>m</V><Sub>b</Sub>/<V>R</V><Sup>2</Sup></span>,
+      <><b style={{ color: INK }}>The equivalence principle.</b> What bends a
+        body is the <i>fraction</i> of its paths that were biased, and its path
+        count is its mass. The extra divides straight back out.</>],
+      [<span style={{ color: DERIVED }}><V>u̇</V> ∝ <V>ṅ</V></span>,
+        <>Gravity is an <i>acceleration</i> and not a speed, because what
+          accumulates is the count and what drifts is a function of it.</>],
+      [<span style={{ color: DERIVED }}>1/<V>γ</V><Sup>3</Sup>, 1/<V>γ</V></span>,
+        <>Along the way a thing is going, and across it — special relativity’s
+          own response, out of the count being a count on the body’s own
+          worldline.</>],
+      [<span style={{ color: DERIVED }}>screen</span>,
+        <>Three bodies in a row do not simply add. Newton has no such term and
+          neither does relativity at this order.</>],
+    ]} />
+
+    <Head>what is a choice</Head>
+
+    <Rows of={[
+      [<><K>GRAIN</K> = {GRAIN.toExponential(0)}</>,
+        <>lattice steps a drawn cell stands for</>],
+      [<>cells per AU</>, <>how large the picture is</>],
+      [<>ticks per year</>, <>how fast it is played</>],
+    ]} />
+
+    <Note>
+      Statements about the <i>picture</i>. Every physical ratio survives them,
+      and none is free to change what the law says.
+    </Note>
+
+    <Head>and so, in full</Head>
+
+    <Eq derive={FULL} open={show}
+      note={<>the bracket is 1.08 at a core of half a lattice step and Mercury’s
+        separation — and 1 + 10⁻³⁸ at the grain a real lattice would have</>}>
+      <Frac over={<>d<V>p</V></>} under={<>d<V>t</V></>} /> &nbsp;=&nbsp;
+      <V>G</V> ·
+      <Frac over={<><V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub></>}
+        under={<><V>R</V><Sup>2</Sup></>} />
+      <Paren>
+        1 &nbsp;+&nbsp; <Frac over={<V>c</V>} under={<V>R</V>} /> ln
+        <Frac over={<><V>R</V> − <V>c</V></>} under={<V>c</V>} />
+      </Paren>
+      <Hat>r</Hat>
+      <span style={{ padding: '0 1.4em' }} />
+      <V>G</V> =
+      <Frac over={<><K>SHEET</K><Sup>2</Sup></>}
+        under={<>4<V>π</V><Sup>2</Sup> <V>c</V> <K>WAYS</K></>} />
+    </Eq>
+
+    <Note>
+      <b style={{ color: INK }}>Newton, times a bracket that goes to one</b> —
+      and a constant written entirely in counts. The whole of the model’s
+      departure from Newton at a distance is that bracket, and its size is the
+      ratio of a source’s core to the separation. The <V>γ</V> on the left is
+      worth <b style={{ color: INK }}>+1.67°</b> of Mercury’s perihelion an
+      orbit where Schwarzschild gives <b style={{ color: INK }}>+10.41°</b> —
+      the right sign, and a sixth of the size. The missing five sixths, and the
+      whole of light’s deflection, are the part of a metric that says how
+      lengths differ radially against transversely. This keeps one number per
+      place, and cannot say it.
+    </Note>
+
+    {open ? <Panel of={open} onClose={hide} /> : null}
+
+  </div>;
+};

From 43ae489bb3164aed0248edd0050dc0843ce66250 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Tue, 11 Aug 2026 00:04:28 +0200
Subject: [PATCH 22/47] Partially assuming GR. Space creation from neutral
 points.

---
 .../2026.RayCalculiAndPhysics/gravity.ts      | 527 ++++++++++++++++--
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 468 ++++++++++++++--
 .../2026.RayCalculiAndPhysics/metric.tsx      | 196 ++++++-
 .../2026.RayCalculiAndPhysics/models.ts       | 483 ++++++++++++----
 .../2026.RayCalculiAndPhysics/newton.tsx      |  17 +
 .../2026.RayCalculiAndPhysics/physics.ts      |  31 +-
 6 files changed, 1503 insertions(+), 219 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index 310f9ef..c2dfcd2 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -17,7 +17,8 @@
  *                 = 4/(c·R²) · ( 1 + (c/R)·ln((R−c)/c) )
  *                    ╰─────╯     ╰────────────────────╯
  *                     Newton       what the middle adds
- *     S(a,b)      = BITE·share·screen·m_a·m_b·EMIT²·met(R)     meetings a tick
+ *     S(a,b)      = BITE·share·screen·m_a·m_b·EMIT²·met(R·GRAIN)·GRAIN³
+ *                                                  meetings a tick
  *
  *   One inverse square times one bracket that goes to one. The bracket is the
  *   whole of the model's departure from Newton at a distance, its size is the
@@ -27,22 +28,59 @@
  *   what a count of annihilations does to a body:
  *     BIAS        = LIGHT / WAYS                   what one of them buys, and
  *                                                  the only constant here
- *     u̇_a         = BIAS · S(a,b) / m_a            ÷ its OWN mass, which is
+ *     u̇_a         = BIAS · S(a,b) / m_a · carry    ÷ its OWN mass, which is
  *                                                  the equivalence principle
- *     pace(u)     = u / √(1 + |u|²/LIGHT²)         and what a count comes to
- *                                                  as a speed in the picture
+ *
+ *   AND WHERE THE SPACE COMES FROM, which is a second rule and is the whole
+ *   of B. Three rewrites, and everything after is their arithmetic:
+ *
+ *     neutral   →  +  −      one point becomes the two a pair needs    +1
+ *     +  −      →  neutral   a meeting merges them back — this is BITE −1
+ *     a move    →  consume ahead, emit behind                           0
+ *
+ *   A body emitting m·SHEET charges a tick therefore MAKES SPACE, at its own
+ *   place, at that rate — a point source, not a field. The moves carry it, and
+ *   a carried point source has a steady state, which is a Green's function:
+ *
+ *     S           = m·SHEET                        what a body makes a tick
+ *     D           = π·WAYS·c/(3·BITE·SHEET) = 3.4  how fast a move spreads it
+ *     δ(r)        = S/(4π·D·r) = 3u                STATIC, and 1/r
+ *     ⇒  u        = G·m/(r c²)                     the metric's own potential,
+ *                                                  out of a rate and a spread
+ *
+ *   which then reads as a metric:
+ *     A(s)        = ((1−s)/(1+s))²   s = u/2      how much slower its own
+ *                 = 1 − 2u + 2u² − ...                ticks go
+ *     B(s)        = (1+s)⁴                        how many steps a drawn cell
+ *                 = 1 + 2u + 1.5u² + ...              holds
+ *     pace(u,f)   = A·u / (B·√(A(1 + |u|²/B c²)))  what a count comes to as a
+ *                                                  speed in the picture
+ *     carry       = −(A' + (A/B)'|u|²/c²) / 2H     what one meeting is worth
+ *                                                  where it happened
  *
  *   Everything below falls out of those and none of it is stated: at rest,
  *   Newton; differentiated, 1/γ³ along the way a thing is going and 1/γ
  *   across it, which is special relativity's own response; and ÷ m_a leaves
  *   a_a ∝ m_b/R², so a feather and a hammer fall together.
  *
- *   G           = SHEET² / (4π²·CORE·WAYS)         the far limit of `met`, in
- *                                                  closed form. Every symbol
- *                                                  is a count. Nothing fitted.
- *
- *   what it still owes: at v = c the count is already infinite, so one more
- *   annihilation turns it by nothing — light does not fall here. See `pace`.
+ *   G           = BITE·SHEET²·c / (8π²·HALF·WAYS)  the far limit of `met`, in
+ *                                                  closed form, and IN THE
+ *                                                  LATTICE'S OWN UNITS — a
+ *                                                  step, a tick, half a step
+ *                                                  of core. Every symbol a
+ *                                                  count; nothing fitted, and
+ *                                                  no GRAIN in it. `GRAIN` is
+ *                                                  the drawing's scale and
+ *                                                  enters once, in `shortfall`,
+ *                                                  turning cells into steps.
+ *
+ *   And reading the count the second way is worth the rest of relativity:
+ *   Mercury 6.07/6 of Schwarzschild's perihelion advance where the pull alone
+ *   gave 1/6, and a ray 4GM/bc² where the pull alone gave half of it.
+ *
+ *   what it still owes: `fold` is only defined AT a body, because `shortfall`
+ *   is a fact about a pair and a thickness is a fact about a place. See
+ *   `settle` in `metric.tsx`.
  *
  */
 
@@ -86,8 +124,22 @@ import { BITE, LIGHT } from "./physics";
  */
 export const GRAIN = 1e12;
 
-/** And so the core, in drawn cells. */
-const CORE = HALF / GRAIN;
+/**
+ * And the core is half a step — a LATTICE step, which is the whole point.
+ *
+ * This used to be `HALF/GRAIN`: the core expressed in drawn cells, so that the
+ * law could be evaluated on drawn separations. It gave the right answer and it
+ * read as though the picture's zoom were part of the physics, which it is not.
+ * A source is one lattice point across whatever anything is drawn at.
+ *
+ * So the law below is stated in the lattice's own units — c = 1 step a tick,
+ * the core half a step — and `shortfall` converts a drawn separation into
+ * steps before asking it anything. That is the only place the two scales meet,
+ * and `GRAIN` appears nowhere else in the physics. It is exact rather than a
+ * rearrangement: `met(R, HALF/G) = G³·met(G·R, HALF)`, because the bracket
+ * depends only on `c/R` and the prefactor on `c·R²`.
+ */
+const CORE = HALF;
 
 /**
  * The line between two things, integrated — exactly, and it is Newton times a
@@ -234,33 +286,299 @@ export const BIAS = LIGHT / WAYS;
  * What comes out, unstated and unfitted, is the rest of it. Differentiating
  * the line above gives `dv/du = 1/γ³` along the way a thing is going and
  * `1/γ` across it — the longitudinal and transverse response of special
- * relativity, exactly, arrived at from a count of ways out of a point. And the
- * perihelion advance that leaves on Mercury is +0.56° an orbit against
- * Schwarzschild's +3.21°: prograde, same sign, and 0.176 of it, which is the
- * one sixth that relativistic momentum alone has always given.
- *
- * WHAT IT STILL OWES, stated here rather than buried. At v = c the count is
- * infinite, so a finite one more does not turn it: light does not fall, and it
- * bends round the sun. What that costs is one identifiable thing rather than
- * the whole account — `shortfall` couples to the rest masses, and an emission
- * rate standing for ENERGY rather than for rest mass would deflect light by
- * 2GM/bc². Which is half of what was measured, and getting the other half
- * needs a metric's spatial part that a model counting one number per place
- * does not have.
+ * relativity, exactly, arrived at from a count of ways out of a point.
+ *
+ * WHAT THIS IS WORTH ON ITS OWN, and it is exactly a sixth. With `fold` held
+ * at nought — the pull alone, which is all this file used to have — Mercury's
+ * perihelion advances +0.56° an orbit on the Sun and Mercury panel and +1.66°
+ * on the inner solar system, against a 6πGM/c²a(1−e²) of +3.36° and +9.93°.
+ * Prograde, same sign, and 0.167 of it in both — and 0.167 again for Venus,
+ * Earth and Mars, which is the one sixth that relativistic momentum alone has
+ * always given and is not a coincidence of one orbit.
+ *
+ * The other five sixths are NOT in here. They are in the same count read a
+ * second time — see `slowing`, `thickness` and `carry` below — and with that
+ * read the same five bodies come out at 6.05 to 6.20 sixths, and what is over
+ * six is first order in how deep the orbit sits — see the table there.
+ *
+ * The `fold` argument is what carries it, and it defaults to nought, at which
+ * these two functions are identically what they were.
  */
-export const pace = (ux: number, uy: number): [number, number] => {
-  const g = Math.sqrt(1 + (ux * ux + uy * uy) / (LIGHT * LIGHT));
+export const pace = (
+  ux: number, uy: number, fold = 0,
+): [number, number] => {
+  const A = slowing(fold), B = thickness(fold);
+
+  // Nothing moves at all where A has gone to nought, and saying so is finite
+  // where dividing by it is not.
+  if (!(A > 0)) return [0, 0];
+
+  const g = Math.sqrt(A * (1 + (ux * ux + uy * uy) / (LIGHT * LIGHT * B)));
 
-  return [ux / g, uy / g];
+  return [A * ux / (B * g), A * uy / (B * g)];
 };
 
-/** And back: what a stated course is, as a count. See `pace`. */
-export const count = (vx: number, vy: number): [number, number] => {
-  const g = 1 / Math.sqrt(Math.max(1 - (vx * vx + vy * vy) / (LIGHT * LIGHT), 1e-12));
+/**
+ * And back: what a stated course is, as a count. See `pace`.
+ *
+ * With the one thing this direction has to answer for and the other does not.
+ * `pace` is handed a count, and any count whatever is allowed — that is the
+ * whole of why the ceiling is arithmetic rather than a rule. This is handed a
+ * SPEED, and a speed has a ceiling where it is being stated: `c√(A/B)`, which
+ * is light in flat space and less than light anywhere folded. Above it there is
+ * no count to return, because there is no such course to be on.
+ *
+ * So it is held just under, rather than allowed to divide by nought. That is
+ * not a fudge covering a physical case — it is a caller handing this a course
+ * that does not exist where it put it, and the honest answers are the fastest
+ * one that does, and nothing at all where nothing can move.
+ */
+export const count = (
+  vx: number, vy: number, fold = 0,
+): [number, number] => {
+  const A = slowing(fold), B = thickness(fold);
+
+  const top = A / B;                                 // (c√(A/B))², over c²
+  if (!(top > 0)) return [0, 0];
+
+  const of = Math.min(
+    (vx * vx + vy * vy) / (LIGHT * LIGHT * top), 1 - 1e-12);
+
+  const g = B / Math.sqrt(A * (1 - of));
 
   return [vx * g, vy * g];
 };
 
+/**
+ * THE SECOND THING THE COUNT SAYS, which was being computed and thrown away.
+ *
+ * `BIAS` above reads the count as a RATIO: the way that took an annihilation
+ * weighs `1 + n` against the `WAYS` out that weigh one each, so a path leans by
+ * `LIGHT·n/WAYS`. That is the first moment of the count — WHICH WAY the extra
+ * weight points — and it is the whole of the pull, and it is worth exactly one
+ * sixth of Mercury's perihelion advance and nothing at all of light.
+ *
+ * What is thrown away is the TOTAL. The ways out of that point no longer number
+ * `WAYS`; they number `WAYS + n`. The line above this one used to say "while
+ * every other way out of the point still weighs exactly what it always did",
+ * and that is true and is not the point: every other way weighs one, and there
+ * are now more of them. A point with more ways out of it holds more space, so a
+ * neighbourhood of such points contains more places than the drawn cell it
+ * occupies, so crossing it takes more steps.
+ *
+ * Which is the spatial part, out of the same count, with nothing new measured
+ * and no second field:
+ *
+ *     A = 1 − 2u + 2u²        how much slower a body's own ticks go
+ *     B = 1 + 2u              how many steps a drawn cell holds
+ *
+ * — and `u` is one scalar, read twice. It is NOT a tensor and does not need to
+ * be. The claim in `metric.tsx` that a scalar cannot say space was taken out
+ * radially rather than across is a fact about SCHWARZSCHILD coordinates; the
+ * form written down two lines beneath it, `−A dt² + B(dx² + dy² + dz²)`, has a
+ * scalar B, and the spatial part of the metric at this order is `(1 + 2u)δᵢⱼ`
+ * for any arrangement of masses whatever. The tensor buys radiation, later.
+ *
+ * WHAT IT COSTS, and this is the one thing in the file that is BORROWED rather
+ * than counted: that A and B carry the same u with the same coefficient. That
+ * is γ = 1, Cassini has γ at 1 ± 2·10⁻⁵, and it is the sharpest thing here to
+ * be wrong about — so it wants deriving, and it has not been.
+ *
+ * The rest of this comment is the record of trying, because the failures are
+ * more informative than the assertion is, and because nobody should have to
+ * repeat them. See the note under `carry`.
+ *
+ * MEASURED. Every body of both solar panels, as a fraction of that body's own
+ * 6πGM/c²a(1−e²) — the pull alone, and the same pull read as a metric:
+ *
+ *                     Mars    Earth   Mercury   Venus   Mercury
+ *                                        (65)             (28)
+ *     u at perihelion  0.0025  0.0035   0.0038  0.0048   0.0112
+ *     pull alone        1.00    1.00     1.00    1.00     1.00   sixths
+ *     as a metric       6.05    6.08     6.07    6.10     6.20
+ *
+ * — five orbits over two panels at two scales. The first row does not move off
+ * a sixth by a part in a hundred. The second is six plus about 3.3·u, ordered
+ * by how deep the orbit sits and by nothing else, which is what a theory right
+ * to first order in the field and not beyond it is supposed to do: the next
+ * term is there and it is the size it should be. Nothing is fitted in either.
+ *
+ * And light, which the pull could not touch at all, traced through `√(B/A)` at
+ * 12.5 to 200 cells:
+ *
+ *     u = GM/bc²   6.0e−3  3.0e−3  1.5e−3  7.5e−4  3.8e−4
+ *     A alone      0.5048  0.5024  0.5011  0.5004  0.4997   of 4GM/bc²
+ *     A and B      1.0181  1.0089  1.0043  1.0019  0.9998
+ *
+ * — exactly a half and exactly one in the limit, with the same 3·u on the way
+ * in. One coefficient, two completely different measurements.
+ *
+ * AND THE ORBIT IS THE ORBIT ASKED FOR, which it was not at first and is
+ * worth recording, because the failure looked like the law and was not.
+ * `models.ts` used to hand every body a Newtonian vis-viva speed at
+ * perihelion, and in a metric the same stated speed is a different COUNT (see
+ * `count`) — so Mercury opened out to 14.7 cells where the ellipse it had been
+ * asked for goes to 13.1, and the panels showed a law that precessed correctly
+ * round a visibly wrong ellipse.
+ *
+ * Solving the turning points in the metric instead — `folded` in `models.ts`,
+ * which is exact and closed form — puts every one of them back:
+ *
+ *                  a wanted   a drawn      e wanted   e drawn
+ *     Mercury       10.839     10.84        0.20563    0.2055
+ *     Venus         20.253     20.25        0.00677    0.0068
+ *     Earth         28.000     28.00        0.01671    0.0167
+ *     Mars          42.664     42.66        0.09341    0.0934
+ *
+ * — four figures on all eight, with the perihelion advance unmoved. Nothing
+ * about the law changed; what changed is that the body is started in the space
+ * that is there rather than in Newton's.
+ */
+/**
+ * WRITTEN CLOSED RATHER THAN AS THE SERIES, and that is not tidiness.
+ *
+ * `1 − 2u + 2u²` and `1 + 2u` are the first terms of an expansion, and an
+ * expansion used outside where it converges does not merely lose accuracy — it
+ * loses the facts that made it a metric. At `u = 1` the series for A comes back
+ * up through one, so a place deep enough to stop a clock reads as though
+ * nothing were there; and since the coordinate speed of light is `c√(A/B)`,
+ * A rising and B not rising fast enough puts the ceiling ABOVE light. Measured
+ * on a panel whose masses put `u` at 1.8e9, that ceiling was forty thousand
+ * times light and two bodies left the frame at seventeen hundred cells a tick.
+ *
+ * The closed form these are the first terms of is the isotropic one, in
+ * `s = u/2`:
+ *
+ *     A = ((1 − s)/(1 + s))²        = 1 − 2u + 2u² − ...
+ *     B = (1 + s)⁴                  = 1 + 2u + 1.5u² + ...
+ *
+ * — same to the order anything here is worked to, and honest everywhere else.
+ * `A/B = (1 − s)²/(1 + s)⁶` is at most one for any `s ≥ 0`, so `c√(A/B) ≤ c`
+ * and LIGHT IS THE CEILING AGAIN, as a fact about the functions rather than a
+ * clamp. A goes to nought at `s = 1` and is held there beyond it, which is a
+ * horizon and is the honest thing for a place that deep to do.
+ *
+ * Nothing measured moves: the solar panels sit at `u ~ 10⁻³` where the series
+ * and the closed form agree to ten figures.
+ */
+const S_OF = (fold: number) => Math.max(fold, 0) / 2;
+
+export const slowing = (fold: number) => {
+  const s = S_OF(fold);
+  if (s >= 1) return 0;                              // at or past the horizon
+
+  const q = (1 - s) / (1 + s);
+
+  return q * q;
+};
+
+export const thickness = (fold: number) => {
+  const s = S_OF(fold);
+
+  return Math.pow(1 + s, 4);
+};
+
+/**
+ * And what a folded place does to the pull itself — the factor the count
+ * accumulates at, which is one where there is no folding.
+ *
+ * A count is still a count of annihilations and still goes up by `BIAS` each
+ * one. What changes is that a step is no longer worth a step: `dp/dt` is the
+ * gradient of the metric rather than of a potential, so the same meeting buys
+ * more where the place is thick and where the body is already fast.
+ *
+ * At leading order this is `1 + 2v²/c²`, which is the whole of the difference
+ * between one sixth and six sixths, and it is NOT something that could have
+ * been reached by patching a velocity factor onto the force: `1 + 2v²/c²` on
+ * its own gets the perihelion and overshoots light by half again. The rest of
+ * it is in `pace` and `count` above, where the same folding decides what a
+ * count is worth in cells. The two have to move together or neither is right.
+ */
+export const carry = (px: number, py: number, fold: number) => {
+  const A = slowing(fold), B = thickness(fold);
+  const p2 = px * px + py * py;
+
+  // H, in units of c². One where there is nothing going on.
+  const H = Math.sqrt(A * (1 + p2 / (LIGHT * LIGHT * B)));
+  if (!(H > 1e-12)) return 0;                        // nothing left to turn
+
+  // Differentiated against the fold, and these are the closed forms' own
+  // derivatives rather than the series' — −2 and +2 at the origin, as they
+  // have to be. See `slowing`.
+  const s = S_OF(fold);
+
+  const dA = s >= 1 ? 0 : -2 * (1 - s) / Math.pow(1 + s, 3);
+  const dB = 2 * Math.pow(1 + s, 3);
+
+  const dAB = (dA * B - A * dB) / (B * B);
+
+  return -(dA + dAB * p2 / (LIGHT * LIGHT)) / (2 * H);
+};
+
+/**
+ * WHERE B WOULD HAVE TO COME FROM — the record of ten attempts, and the one
+ * fact underneath all of them.
+ *
+ * `slowing` and `thickness` are the isotropic Schwarzschild functions of a `u`
+ * that `settle` reads off the pull. They work — 6.07 sixths and the whole of
+ * light's deflection — and they are general relativity's functions, borrowed.
+ * What follows is what happened when the lattice was asked to produce them.
+ *
+ * THE ONE FACT. General relativity sources the metric from MASS: `∇²u = 4πGρ`,
+ * and for a body ρ is concentrated, so the solution is `1/r`. This model has
+ * nothing concentrated to source from. `physics.ts` says it outright — mass
+ * here IS the emission rate — so every quantity attached to a body is attached
+ * to its FIELD, and a field around a point goes as `1/r²`. One integration
+ * apart, and no coefficient closes it.
+ *
+ * Measured, and each of these was run rather than argued:
+ *
+ *   annihilations tallied at a place        n ∝ r^−1.997     wrong power
+ *   the same, integrated outward            1/r, but ∝ 1/R²  a pair, not a place
+ *   A-B-C merging into Y                    C/r rises        deficit radius
+ *   emission carried with the charge        1/r²             deflection ∝ 1/b²
+ *   emission laid down as it passes         1/r  ✓           coefficient unfound
+ *   creation at the source, static Poisson  —                a rate is not a source
+ *   annihilation as a Painlevé flow         v ∝ r^−0.956     GR needs r^−0.5
+ *   sheet-confined creation                 1/r  ✓           anisotropic 100:1
+ *   the same, sheet tumbling                1/r²             averaging undoes it
+ *   creation per charge per tick            1/r  ✓           lattice has no transport
+ *
+ * Everything that fails, fails because it is built from `chance ∝ 1/r²`. The
+ * three that pass the shape test do it by an integration or a dimensional
+ * reduction, and neither has a mechanism behind it.
+ *
+ * WHAT DOES WORK, and it is one idea: put the source AT THE BODY. If making a
+ * charge converts one neutral point into the two a ± pair needs, the body is a
+ * point source of space at a rate proportional to its mass — a delta function,
+ * which is the thing the model did not have. Measured on Lagrangian shells,
+ * the deviation `1 − C/2πr` comes out flat in `×r` to every digit across a
+ * factor of eight in radius. That is `1/r`, and it is the only mechanism here
+ * that produced it without an integration put in by hand.
+ *
+ * WHAT IT STILL OWES: it is a rate, so it accumulates. `deviation = m·SHEET·t/r`
+ * passes GR's `G·m/r` at `t = G/SHEET ≈ 0.008` ticks and keeps going. Having
+ * annihilation give the point back (see `BITE`) conserves the total but not the
+ * distribution — space is made at the body and unmade where the charges get to,
+ * so the distortion between still accumulates. Nothing static has been found.
+ *
+ * AND TWO CONSTRAINTS ON ANYTHING THAT TRIES NEXT.
+ *
+ * An ambient field SCREENS. If the vacuum carries charge at density Φ₀ then a
+ * body's charges annihilate against it too, and only reach `λ = 1/(BITE·share·Φ₀)`.
+ * Gravity becomes Yukawa with that range. Working at cluster scale needs
+ * `Φ₀ ≲ 10⁻⁵⁸` per lattice cell, which is no vacuum at all — so a vacuum dense
+ * enough to do anything is dense enough to switch gravity off at seven steps.
+ *
+ * And BITE is not free either. If every created point emits a ± pair, then one
+ * meeting consumes one creation's worth of charge and must return one point, so
+ * `BITE = 1`. It costs nothing measured — `accel ∝ BITE·m_b` while `models.ts`
+ * sets `m ∝ 1/GRAVITY ∝ 1/BITE`, so every orbit is identical — but it is a
+ * change to the lattice rule (annihilation MERGING two points rather than
+ * deleting both), and that rule has not been established, so `physics.ts` still
+ * says two.
+ */
+
 /**
  * How many places along the line between two things are looked at.
  *
@@ -576,7 +894,8 @@ export const shortfall = (
   if (R <= 2 * CORE) return 0;
 
   return BITE * share * screen
-    * (one.mass ?? 1) * (two.mass ?? 1) * EMIT * EMIT * met(R, CORE) * dt;
+    * (one.mass ?? 1) * (two.mass ?? 1) * EMIT * EMIT
+    * met(R * GRAIN, CORE) * GRAIN ** 3 * dt;
 };
 
 /**
@@ -804,5 +1123,145 @@ export const annihilation = (
  * FRACTION of your paths that got biased, and a heavier thing brought
  * proportionally more paths to the meeting.
  */
-export const GRAVITY =
-  SHEET * SHEET / (4 * Math.PI * Math.PI * CORE * WAYS);
+export const G_LATTICE =
+  BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+
+/**
+ * And the same constant in the units a panel is drawn in, which is the only
+ * thing `GRAIN` is for.
+ *
+ * A drawn cell is `GRAIN` steps across and a drawn tick is `GRAIN` ticks, and
+ * `G` has units of length³/time²/mass — so the conversion is one factor of
+ * `GRAIN` and nothing else. Every panel divides its masses by this, so it
+ * cancels out of every orbit and nothing measured depends on it.
+ */
+export const GRAVITY = G_LATTICE * GRAIN;
+
+/**
+ * WHAT B WOULD COST, IF SPACE WERE MADE — the surviving account, stated in
+ * code because it is a claim about a number, and not wired in because it does
+ * not yet produce a static one.
+ *
+ * `slowing` and `thickness` above are general relativity's functions, borrowed.
+ * The account below is the only one of ten that survives being measured, and it
+ * is short: SPACE IS MADE, and a body's charges are what make it.
+ *
+ *   every created point emits a ± pair, so creation and annihilation are exact
+ *   inverses and `BITE = 1` (see `physics.ts`). The vacuum's pairs are made
+ *   WITH their point and take it back when they meet, so they are net nothing;
+ *   a body's charges are emitted WITHOUT one, and the space they make as they
+ *   go is the part that is not already accounted for.
+ *
+ * Requiring that to come to `B = 1 + 2u` fixes the rate outright:
+ *
+ *     δ(r)  = ε·m·SHEET / (4π r c)          what the flux leaves at r
+ *     δ     = B^(3/2) − 1 = 3u,  u = GM/rc²
+ *     ⇒ ε   = 12π·G/(SHEET·c) = 3·BITE·SHEET/(π·WAYS)
+ *
+ * — a pure count, no `GRAIN` in it, and about a third of a point per charge
+ * per tick. That is the whole of the prediction, and it is the number a lattice
+ * rule would have to produce on its own for γ = 1 to be derived rather than
+ * assumed.
+ *
+ * WHY IT IS NOT WIRED IN. Three things were measured and two of them work:
+ *
+ *   the sign     right. Space made near a mass gives C/r < 2π, excess radius,
+ *                which is what general relativity has and what every earlier
+ *                mechanism got backwards.
+ *   the profile  right, but only with the source AT THE BODY — one neutral
+ *                point becoming the two a pair needs. Measured on Lagrangian
+ *                shells the deviation is flat in ×r to every digit over a
+ *                factor of eight in radius, which is 1/r. Sourced from the
+ *                charges instead it is 1/r², because `chance` is.
+ *   static       no. It is a rate, so it accumulates: `m·SHEET·t/r` passes
+ *                `G·m/r` at t = G/SHEET ≈ 0.008 ticks and keeps going. Letting
+ *                annihilation give the point back conserves the total and not
+ *                the distribution — made at the body, unmade wherever the
+ *                charges get to — so the distortion between still grows.
+ *
+ * AND ONE CONSTRAINT ON WHATEVER FIXES THAT. An ambient field SCREENS: a
+ * body's charges annihilate against it too, so they reach only
+ * `λ = c/(BITE·share·Φ₀)` and gravity becomes Yukawa with that range. Working
+ * out to cluster scale needs `Φ₀ ≲ 10⁻⁵⁸` charges a lattice cell — which is no
+ * vacuum worth the name. A vacuum dense enough to carry anything is dense
+ * enough to switch gravity off within about seven steps.
+ */
+export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
+
+/**
+ * HOW FAST THE SURPLUS SPREADS — and with it, the whole of B, derived.
+ *
+ * `MADE` above says a body makes space. This says what happens to it, and the
+ * two together are what turn a rate into a metric.
+ *
+ * THE REWRITE RULES, in full, because everything below is just their arithmetic:
+ *
+ *     neutral            →  +  −          one point becomes the two a pair
+ *                                         needs. NET +1 POINT.
+ *     +  −               →  neutral       a meeting merges them back. NET −1.
+ *                                         This is `BITE` = 1, and it is what
+ *                                         makes the two exact inverses.
+ *     charge moves       →  consume ahead, emit behind      NET 0. A point is
+ *                                         unmade in one place and remade in
+ *                                         the next, which is how a surplus
+ *                                         gets carried without anything
+ *                                         travelling.
+ *
+ * A body emits `m·SHEET` charges a tick and each costs one neutral point, so a
+ * body is a POINT SOURCE of space of strength `S = m·SHEET`. That is the whole
+ * of the difference from every earlier attempt, which sourced from `chance` and
+ * so from the field — spread as 1/r², and a spread source gives a logarithm.
+ * A point source gives a Green's function.
+ *
+ * The third rule then carries it, and carrying is what makes it settle. Write
+ * that as a diffusivity and the steady state is immediate:
+ *
+ *     ∂δ/∂t = D∇²δ + S·δ³(x)      ⇒      δ(r) = S / (4π D r)
+ *
+ * — STATIC, because the flux carries the surplus away exactly as fast as it is
+ * made, and 1/r, because that is what ∇⁻² of a point is. Measured on a radial
+ * solve: δ·r settles to five figures and stops moving over a sixfold longer
+ * run, matching (S/4πD)(1 − r/R) with the 1−r/R being the box and not the
+ * physics. Every accumulating version of this failed on exactly those two
+ * counts, and they close together rather than one at a time.
+ *
+ * WHAT D HAS TO BE. Setting `δ = 3u` (a volume excess is three times the u in
+ * B = 1 + 2u) and `u = GM/rc²`:
+ *
+ *     D = SHEET·c² / (12π·G) = π·WAYS·c / (3·BITE·SHEET) = 3.403
+ *
+ * — a pure count, no GRAIN, and order one. For a lattice whose things move a
+ * step a tick that is a mean free path of about three steps, which is an
+ * ordinary number for a medium that scatters.
+ *
+ * IT IS NOT INDEPENDENT OF `MADE`, and saying so matters: D = c/MADE exactly.
+ * Both are the same requirement — how much space has to end up at radius r —
+ * written once as a rate per charge and once as a diffusivity. One constraint,
+ * not two agreeing, and the second decimal place is not a confirmation.
+ */
+export const SPREAD = Math.PI * WAYS * LIGHT / (3 * BITE * SHEET);
+
+/**
+ * And so what a body puts at a distance, as a fold — which is `settle`'s whole
+ * job, done from the SOURCE rather than from the force.
+ *
+ * `δ = S/(4πDr)` with `S = m·SHEET` and `δ = 3u` comes to `u = G·m/(r c²)`,
+ * which is the same number `settle` used to get by reading an acceleration off
+ * `shortfall` and multiplying by R. The difference is not the value, it is what
+ * it is a statement ABOUT:
+ *
+ *   - it goes as m_b ALONE. `shortfall` goes as m_a·m_b, so what came out of it
+ *     was a fact about a PAIR, and a thickness is a fact about a PLACE. That
+ *     objection has stood in `settle` since the folding was put in, and this
+ *     is what answers it.
+ *   - it can be asked ANYWHERE, not only at a body, because there is no second
+ *     mass in it. `Space.nxx` wanted that and could not have it.
+ *   - and it is a derivation rather than a reading. The old line took the pull
+ *     and called its potential `u`, which is true and is not an argument.
+ *
+ * In the drawing's units, because that is where the panels live — `GRAVITY` is
+ * `G` times `GRAIN` (see there), and the lattice statement above is what it is
+ * a conversion of.
+ */
+export const foldAt = (mass: number, R: number) =>
+  GRAVITY * mass / (R * LIGHT * LIGHT);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 28d9e74..c5f31b3 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -21,6 +21,21 @@ import { GRAIN } from "./gravity";
  * whose constants are all counts and a model with six fitted parameters look
  * identical once they are drawn, and the only way to tell them apart is to be
  * able to ask any line where it came from and get an answer.
+ *
+ * THE NUMBERS ON THIS PAGE ARE MEASURED and every one of them is reproducible
+ * from `models.ts` — the sixths, the deflection, the a and e of each orbit.
+ * They are quoted here rather than computed here, which is a second copy and
+ * therefore a thing that can drift; `GRAIN` is imported instead, and the rest
+ * would be too if the panels were cheap enough to run at render.
+ *
+ * WHAT CHANGED, since a reader who saw this page before will notice. It used
+ * to end by owning up: a sixth of Mercury's perihelion, half of light's
+ * deflection, and the missing part named as a spatial metric "this keeps one
+ * number per place, and cannot say it". That was wrong twice over. The one
+ * sixth was the FORCE LAW's, not A's — A alone, taken as a metric, gives four
+ * sixths — and one number per place says it perfectly well, because the
+ * spatial part at this order is a scalar. What was missing was not a second
+ * field but the second READING of the count already being taken. See `METRIC`.
  */
 
 const INK = '#c6c9d4';
@@ -317,31 +332,64 @@ const LAW: Derivation = {
       counts.
     </Step>
 
-    <Because>per tick of whose clock</Because>
+    <Because>that is a ratio, and a ratio is not all of it</Because>
+    <Step eq={<>
+      <Frac over={<>1 + <V>n</V></>} under={<K>WAYS</K>} />
+      &nbsp;the lean&nbsp;&nbsp;·&nbsp;&nbsp;
+      <K>WAYS</K> + <V>n</V>&nbsp; the total
+    </>}>
+      The line above compares one direction against the others and throws away
+      how many there are. But the ways out of that point no longer{' '}
+      number <K>WAYS</K> — they number <K>WAYS</K> + <V>n</V>, and{' '}
+      <b style={{ color: INK }}>a point with more ways out of it holds more
+        space</b>. The lean is the first moment of the count; the total is the
+      zeroth. Both are the same annihilations, read twice.
+    </Step>
+
+    <Step eq={<>
+      <V>A</V> = <Paren><Frac over={<>1 − <V>s</V></>} under={<>1 + <V>s</V></>} /></Paren><Sup>2</Sup>
+      <span style={{ padding: '0 1.2em' }} />
+      <V>B</V> = (1 + <V>s</V>)<Sup>4</Sup>
+      <span style={{ padding: '0 1.2em' }} />
+      <V>s</V> = <V>u</V>/2
+    </>}>
+      Which is a metric: <V>A</V> is how much slower a clock there runs and{' '}
+      <V>B</V> is how many steps a drawn cell holds. To first order they are
+      1 − 2<V>u</V> + 2<V>u</V><Sup>2</Sup> and 1 + 2<V>u</V>, and they carry
+      the <i>same</i> <V>u</V> with the same coefficient — which is not a
+      choice, it is the statement that a point’s lean and a point’s thickness
+      are one event seen twice. Written closed rather than as the series
+      because <V>A</V>/<V>B</V> is then at most one, so the ceiling{' '}
+      <V>c</V>√(<V>A</V>/<V>B</V>) is light and stays light.
+    </Step>
+
+    <Because>per tick of whose clock, and in whose space</Because>
     <Step eq={<>
-      <B>v</B> = <Frac over={<B>u</B>}
-        under={<>√(1 + |<B>u</B>|<Sup>2</Sup>/<K>LIGHT</K><Sup>2</Sup>)</>} />
+      <B>v</B> = <Frac
+        over={<><V>A</V> <B>u</B></>}
+        under={<><V>B</V> √(<V>A</V>(1 + |<B>u</B>|<Sup>2</Sup>/<V>B</V><K>LIGHT</K><Sup>2</Sup>))</>} />
     </>}>
       The counting happens on the body’s own worldline, so{' '}
       <K>LIGHT</K>·<V>n</V>/<K>WAYS</K> is cells per tick of <i>its</i> clock —
       a proper velocity, not a coordinate one. Turning that into what the
-      picture shows is one line of arithmetic the model does not get to choose.
-      Nothing is clamped: the ceiling at <K>LIGHT</K> is the one arithmetic
-      already has.
+      picture shows is one line of arithmetic the model does not get to choose,
+      and how many cells it is worth depends on how thick the place is. Flat, it
+      is <B>u</B>/√(1 + |<B>u</B>|<Sup>2</Sup>) exactly as before. Nothing is
+      clamped: the ceiling is the one arithmetic already has.
     </Step>
 
     <Because>and so</Because>
     <Step eq={<>
       <Frac over={<>d</>} under={<>d<V>t</V></>} />
       ( <V>m</V><Sub>a</Sub> <B>u</B><Sub>a</Sub> ) &nbsp;=&nbsp;
-      <K>BIAS</K> · <V>S</V><Sub>ab</Sub>
+      <K>BIAS</K> · <V>S</V><Sub>ab</Sub> · carry
     </>}>
       A body’s count grows by <K>BIAS</K>·<V>S</V> divided by its own mass —
       the <i>fraction</i> of its paths that were bent, since its path count is
       its mass. Multiply back through and the mass cancels out of the statement
-      entirely. And <V>m</V><B>u</B> = <V>γm</V><B>v</B> is momentum, so what
-      the equation says is that <b style={{ color: INK }}>momentum gained is{' '}
-        <K>BIAS</K> times annihilations taken part in</b>.
+      entirely. <i>carry</i> is what one meeting is worth where it happened,
+      and it is one wherever nothing is going on; at leading order it is
+      1 + 2<V>v</V><Sup>2</Sup>/<V>c</V><Sup>2</Sup>.
     </Step>
 
     <Because>what falls out of it</Because>
@@ -349,9 +397,222 @@ const LAW: Derivation = {
       Dividing by <V>m</V><Sub>a</Sub> leaves{' '}
       <V>a</V><Sub>a</Sub> ∝ <V>m</V><Sub>b</Sub>/<V>R</V><Sup>2</Sup> — the
       equivalence principle as a counting statement rather than a postulate.
-      And differentiating <B>v</B>(<B>u</B>) gives 1/<V>γ</V><Sup>3</Sup> along
-      the way a thing is going and 1/<V>γ</V> across it: special relativity’s
-      own response, out of a count of ways out of a point.
+      Differentiating <B>v</B>(<B>u</B>) at <V>u</V> = 0 gives
+      1/<V>γ</V><Sup>3</Sup> along the way a thing is going and 1/<V>γ</V>{' '}
+      across it: special relativity’s own response, out of a count of ways out
+      of a point. And the two readings together give general relativity’s, to
+      first order in the field and with the next term the size it should be.
+    </Step>
+  </>,
+};
+
+const METRIC: Derivation = {
+  label: 'A and B',
+  title: <>the count, read a second time</>,
+  body: <>
+    <Because>what the lean threw away</Because>
+    <Step eq={<>
+      <Frac over={<>1 + <V>n</V></>} under={<>1 each, <K>WAYS</K> of them</>} />
+    </>}>
+      <K>BIAS</K> compares the direction that took an annihilation against the
+      others. Every other way out still weighs one — which is true, and is a{' '}
+      <i>ratio</i>, and a ratio has no opinion about how many there are. That
+      was the whole of the pull, and on its own it is worth exactly{' '}
+      <b style={{ color: INK }}>one sixth</b> of Mercury’s perihelion advance
+      and <b style={{ color: INK }}>none at all</b> of light’s deflection.
+    </Step>
+
+    <Because>the total, which is the other reading</Because>
+    <Step eq={<><K>WAYS</K> + <V>n</V>&nbsp;&nbsp;ways out, not <K>WAYS</K></>}>
+      A point that has taken <V>n</V> annihilations has more ways out of it
+      than its neighbours do, so it{' '}
+      <b style={{ color: INK }}>holds more space</b> — and a neighbourhood of
+      such points contains more places than the drawn cell it occupies, so
+      crossing it takes more steps. Nothing new is measured. It is the same{' '}
+      <V>n</V>, and it is a fact about the <i>place</i> rather than about the
+      direction.
+    </Step>
+
+    <Because>which is a metric, and needs no tensor</Because>
+    <Step eq={<>d<V>s</V><Sup>2</Sup> = −<V>A</V> d<V>t</V><Sup>2</Sup> +
+      <V>B</V> (d<V>x</V><Sup>2</Sup> + d<V>y</V><Sup>2</Sup> + d<V>z</V><Sup>2</Sup>)</>}>
+      <V>A</V> is the lean — how much slower a clock there runs — and{' '}
+      <V>B</V> is the total. <V>B</V> is a <i>scalar</i> here, and that is not
+      an approximation: radial-against-transverse is a fact about a choice of
+      radial coordinate, and at this order the spatial part is
+      (1 + 2<V>u</V>)δ for any arrangement of masses whatever. A lattice has no
+      coordinates to choose between, so the question never arises for it.
+    </Step>
+
+    <Because>written closed rather than as the series</Because>
+    <Step eq={<>
+      <V>A</V> = <Paren><Frac over={<>1 − <V>s</V></>} under={<>1 + <V>s</V></>} /></Paren><Sup>2</Sup>
+      = 1 − 2<V>u</V> + 2<V>u</V><Sup>2</Sup> − …
+      <span style={{ padding: '0 1em' }} />
+      <V>B</V> = (1 + <V>s</V>)<Sup>4</Sup> = 1 + 2<V>u</V> + …
+    </>}>
+      A series used outside where it converges stops being a metric: at{' '}
+      <V>u</V> = 1 the series for <V>A</V> comes back up through one, and since
+      the coordinate speed of light is <V>c</V>√(<V>A</V>/<V>B</V>), that puts
+      the ceiling <i>above</i> light. Closed,{' '}
+      <V>A</V>/<V>B</V> = (1 − <V>s</V>)<Sup>2</Sup>/(1 + <V>s</V>)<Sup>6</Sup>{' '}
+      is at most one for any <V>s</V> ≥ 0, so light is the ceiling again as a
+      property of the functions rather than a clamp.
+    </Step>
+
+    <Because>and the coefficient is not free</Because>
+    <Step>
+      <V>A</V> and <V>B</V> carry the same <V>u</V> with the same coefficient,
+      which is the statement that a point’s lean and a point’s thickness are
+      one event seen twice. That fixes{' '}
+      <V>γ</V><Sub>PPN</Sub> = 1, and Cassini has{' '}
+      <V>γ</V><Sub>PPN</Sub> at 1 ± 2·10<Sup>−5</Sup> — so it is the sharpest
+      thing here to be wrong about, and it is a prediction rather than a knob.
+    </Step>
+
+    <Because>measured</Because>
+    <Step eq={<>6.05 … 6.20 sixths&nbsp;&nbsp;=&nbsp;&nbsp;6 + 3.3<V>u</V></>}>
+      Five orbits over two panels at two scales, each against its own
+      6π<V>GM</V>/<V>c</V><Sup>2</Sup><V>a</V>(1−<V>e</V><Sup>2</Sup>): Mars
+      6.05, Earth 6.08, Mercury 6.07, Venus 6.10, Mercury on the closer panel
+      6.20 — ordered by how deep the orbit sits and by nothing else. Light,
+      traced through √(<V>B</V>/<V>A</V>), goes 1.0181 → 0.9998 of
+      4<V>GM</V>/<V>bc</V><Sup>2</Sup> as the ray is taken out from 12.5 cells
+      to 200, with the same 3<V>u</V> on the way in. One coefficient, two
+      unrelated measurements, nothing fitted in either.
+    </Step>
+  </>,
+};
+
+const SPACE: Derivation = {
+  label: 'where space comes from',
+  title: <>the three rewrites, and what they buy</>,
+  body: <>
+    <Because>the rules, in full</Because>
+    <Step eq={<>neutral &nbsp;→&nbsp; + &nbsp; −</>}>
+      One point becomes the two a ± pair needs. <b style={{ color: INK }}>Net
+        +1 point</b> — making a charge <i>makes space</i>, and that is the
+      whole of where <V>B</V> comes from.
+    </Step>
+
+    <Step eq={<>+ &nbsp; − &nbsp;→&nbsp; neutral</>}>
+      A meeting merges them back. <b style={{ color: INK }}>Net −1</b>, which
+      is <K>BITE</K> = 1 — and it has to be one, because a meeting consumes
+      exactly one creation’s worth of charge. At two, a perfectly paired
+      universe would leave itself a point smaller every cycle and contract for
+      free.
+    </Step>
+
+    <Step eq={<>a move &nbsp;→&nbsp; consume ahead, emit behind</>}>
+      <b style={{ color: INK }}>Net 0.</b> A point is unmade in one place and
+      remade in the next. Nothing travels — but a <i>surplus</i> can be carried,
+      and that is what makes the rest settle.
+    </Step>
+
+    <Because>a worked example — one body, one tick</Because>
+    <Step>
+      A body of mass <V>m</V> lets go of <V>m</V>·<K>SHEET</K> charges. Each
+      costs a neutral point, so the body makes <V>m</V>·<K>SHEET</K> points, at
+      its own place. Not in its field — <i>at the body</i>. That is a point
+      source, and it is the one thing every earlier account of <V>B</V> did not
+      have: they all sourced from chance ∝ 1/<V>r</V><Sup>2</Sup>, and a source
+      spread like that gives a logarithm, not a potential.
+    </Step>
+
+    <Because>and what the moves then do with it</Because>
+    <Step eq={<>
+      <Frac over={<>∂<V>δ</V></>} under={<>∂<V>t</V></>} /> =
+      <V>D</V>∇<Sup>2</Sup><V>δ</V> + <V>S</V>·<V>δ</V><Sup>3</Sup>(<V>x</V>)
+      &nbsp;&nbsp;⇒&nbsp;&nbsp;
+      <V>δ</V>(<V>r</V>) = <Frac over={<V>S</V>} under={<>4<V>π D r</V></>} />
+    </>}>
+      <b style={{ color: INK }}>Static</b>, because the flux carries the
+      surplus away as fast as it is made — every version of this that did not
+      carry it grew without bound instead. And{' '}
+      <b style={{ color: INK }}>1/<V>r</V></b>, because that is what the
+      inverse Laplacian of a point is. Solved on a radial grid, <V>δ</V>·<V>r</V>{' '}
+      stops moving to five figures over a sixfold longer run.
+    </Step>
+
+    <Because>which fixes D</Because>
+    <Step eq={<>
+      <V>D</V> = <Frac over={<><K>SHEET</K> <V>c</V><Sup>2</Sup></>}
+        under={<>12<V>π</V> <V>G</V></>} /> =
+      <Frac over={<><V>π</V> <K>WAYS</K> <V>c</V></>}
+        under={<>3 <K>BITE</K> <K>SHEET</K></>} /> = 3.403
+    </>}>
+      From <V>δ</V> = 3<V>u</V> and <V>u</V> = <V>GM</V>/<V>rc</V><Sup>2</Sup>.
+      A pure count, no <K>GRAIN</K>, and order one: for a lattice whose things
+      move a step a tick, 3.4 steps² a tick is a mean free path of about three
+      steps. <b style={{ color: INK }}>It is not independent of ε</b> —{' '}
+      <V>D</V> = <V>c</V>/<V>ε</V> exactly. Both are the same requirement,
+      written as a rate and as a spread, so the agreement is bookkeeping.
+    </Step>
+
+    <Because>and what falls out</Because>
+    <Step eq={<><V>u</V> = <Frac over={<V>Gm</V>}
+      under={<><V>r c</V><Sup>2</Sup></>} /></>}>
+      Linear in the <i>other</i> mass alone, so a fact about the place rather
+      than the pair — which is what the folding could never say before. It can
+      be asked anywhere, not only at a body. And every number it produces is
+      identical to the old reading that took the pull and called its potential{' '}
+      <V>u</V>: same orbits, same 1/6, same deflection. What changed is that it
+      is now derived.
+    </Step>
+  </>,
+};
+
+const MADE_FROM: Derivation = {
+  label: 'ε',
+  title: <>what a charge would have to make</>,
+  body: <>
+    <Because>the rule</Because>
+    <Step>
+      Space is made, and every created point emits a ± pair. The vacuum’s pairs
+      are made <i>with</i> their point and take it back when they meet, so they
+      are net nothing. A body’s charges are emitted <i>without</i> one, and the
+      space they make as they go is the part not already accounted for.
+    </Step>
+
+    <Because>what that leaves at a distance</Because>
+    <Step eq={<>
+      <V>δ</V>(<V>r</V>) =
+      <Frac over={<><V>ε m</V> <K>SHEET</K></>}
+        under={<>4<V>π r c</V></>} />
+    </>}>
+      Creation spread as the charges are, which is{' '}
+      chance ∝ 1/<V>r</V><Sup>2</Sup>, integrated over the shell it sits on —
+      and the <V>r</V><Sup>2</Sup> cancels, so the flux goes as <V>r</V> and
+      what it leaves per unit volume goes as 1/<V>r</V>.
+    </Step>
+
+    <Because>and a metric wants</Because>
+    <Step eq={<><V>δ</V> = <V>B</V><Sup>3/2</Sup> − 1 = 3<V>u</V></>}>
+      A spatial metric <V>g</V><Sub>ij</Sub> = <V>B</V><V>δ</V><Sub>ij</Sub>{' '}
+      makes proper volume go as <V>B</V><Sup>3/2</Sup>, so a <i>volume</i>{' '}
+      excess is three times the <V>u</V> in <V>B</V> = 1 + 2<V>u</V>.
+    </Step>
+
+    <Because>so</Because>
+    <Step eq={<>
+      <V>ε</V> =
+      <Frac over={<>3 <K>BITE</K> <K>SHEET</K></>}
+        under={<><V>π</V> <K>WAYS</K></>} /> = 0.2938
+    </>}>
+      About a third of a point per charge per lattice tick. Every symbol a
+      count, no <K>GRAIN</K> in it, and order one — which is what a fundamental
+      rule should look like. <b style={{ color: INK }}>No rule produces it.</b>{' '}
+      It is solved for, not derived, and that is exactly the gap.
+    </Step>
+
+    <Because>one constraint on whatever closes it</Because>
+    <Step>
+      An ambient field <i>screens</i>. A body’s charges annihilate against it
+      too, so they reach only <V>λ</V> = <V>c</V>/(<K>BITE</K>·share·<V>Φ</V><Sub>0</Sub>),
+      and gravity becomes Yukawa with that range. Working out to cluster scale
+      needs <V>Φ</V><Sub>0</Sub> ≲ 10<Sup>−58</Sup> charges a lattice cell — so
+      a vacuum dense enough to carry anything is dense enough to switch gravity
+      off within about seven steps.
     </Step>
   </>,
 };
@@ -400,8 +661,10 @@ const MEETINGS: Derivation = {
       <V>S</V><Sub>ab</Sub> = <K>BITE</K> · share · screen ·
       <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> · EMIT<Sup>2</Sup> · met(<V>R</V>)
     </>}>
-      <K>BITE</K> = 2 is what the rule says one meeting costs — a point for
-      each charge. <i>share</i> is how much of what meets is opposite rather
+      <K>BITE</K> = 1 is what the rule says one meeting costs. It used to be
+      two — a point for each charge — and one is what makes creation and
+      annihilation exact inverses: a ± pair is made by one point becoming the
+      two a pair needs, and a meeting consumes exactly one creation’s worth. <i>share</i> is how much of what meets is opposite rather
       than alike, which is a half unless two sources keep time together.{' '}
       <i>screen</i> is what a third body standing in the way blocks, and it is
       a genuine prediction: Newton has no such term, and neither does
@@ -530,10 +793,12 @@ const CONSTANTS: Derivation = {
     </Step>
 
     <Because>c</Because>
-    <Step eq={<><V>c</V> = <Frac over={<K>HALF</K>} under={<K>GRAIN</K>} /></>}>
-      A source’s core, in drawn cells. <K>HALF</K> is half a lattice step — a
-      shell is never smaller than the cell its source sits in — and{' '}
-      <K>GRAIN</K> is how many lattice steps a drawn cell stands for.
+    <Step eq={<><V>c</V> = <K>HALF</K></>}>
+      A source’s core — half a <i>lattice</i> step, because a shell is never
+      smaller than the cell its source sits in. The law is stated in the
+      lattice’s own units throughout: a step, a tick, half a step of core.{' '}
+      <K>GRAIN</K> is not in it. That is the drawing’s scale, and it enters
+      once, where a drawn separation is turned into steps.
     </Step>
 
     <Because>why the second one has to exist</Because>
@@ -564,7 +829,7 @@ const FULL: Derivation = {
       the two densities integrated along the line.
     </Step>
 
-    <Because>substitute met, with share = ½ and BITE = 2</Because>
+    <Because>substitute met, with share = ½ and BITE = 1</Because>
     <Step eq={<>
       <Frac over={<>d<V>p</V></>} under={<>d<V>t</V></>} /> =
       <Frac over={<><K>SHEET</K><Sup>2</Sup></>}
@@ -574,7 +839,7 @@ const FULL: Derivation = {
       <Paren>1 + <Frac over={<V>c</V>} under={<V>R</V>} /> ln
         <Frac over={<><V>R</V>−<V>c</V></>} under={<V>c</V>} /></Paren>
     </>}>
-      The 4 from met, the 2 from <K>BITE</K> and the ½ from <i>share</i> fold
+      The 4 from met, the <K>BITE</K> and the ½ from <i>share</i> fold
       into the (4<V>π</V>)<Sup>2</Sup> in EMIT<Sup>2</Sup>, and everything left
       standing is a count.
     </Step>
@@ -592,8 +857,21 @@ const FULL: Derivation = {
     <Because>and so</Because>
     <Step>
       <b style={{ color: INK }}>Newton, times a bracket that goes to one.</b>{' '}
-      The whole of the model’s departure from Newton at a distance is that
-      bracket, and its size is the ratio of a source’s core to the separation.
+      The whole of the model’s departure from Newton AT A DISTANCE is that
+      bracket, and its size is the ratio of a source’s core to the separation —
+      which at the grain a real lattice would have is 1 + 10<Sup>−38</Sup>, and
+      could not move a perihelion if it tried.
+    </Step>
+
+    <Because>so where does relativity come from</Because>
+    <Step>
+      Not from that bracket, and not from anything short-range. It comes from
+      the two places the count is read. Read as a <i>direction</i>, on the
+      body’s own worldline, it gives special relativity’s response and one
+      sixth of Mercury. Read as a <i>size</i> — <K>WAYS</K> + <V>n</V> ways out
+      of a point rather than <K>WAYS</K> — it gives the spatial part of a
+      metric, and with it the other five sixths and the whole of light’s
+      deflection. Same annihilations, same constant, counted twice.
     </Step>
   </>,
 };
@@ -633,11 +911,22 @@ export const Law = () => {
     </Note>
 
     <Eq derive={LAW} open={show}
-      note="the momentum a body gains is BIAS times the annihilations it took part in">
+      note="the momentum a body gains is BIAS times the annihilations it took part in, and what one is worth depends on where it happened">
       <Frac over={<>d</>} under={<>d<V>t</V></>} />
       ( <V>γ</V> <V>m</V><Sub>a</Sub> <B>v</B><Sub>a</Sub> )
       &nbsp;=&nbsp; <K>BIAS</K> · <span style={{ fontSize: '1.3em' }}>Σ</span>
       <Sub>b ≠ a</Sub> &nbsp;<V>S</V><Sub>ab</Sub> <Hat>r</Hat><Sub>ab</Sub>
+      &nbsp;· carry
+    </Eq>
+
+    <Eq derive={METRIC} open={show}
+      note="the same count read as a size rather than a direction — which is a metric, and is the other five sixths">
+      <V>A</V>(<V>s</V>) =
+      <Paren><Frac over={<>1 − <V>s</V></>} under={<>1 + <V>s</V></>} /></Paren><Sup>2</Sup>
+      <span style={{ padding: '0 1.4em' }} />
+      <V>B</V>(<V>s</V>) = (1 + <V>s</V>)<Sup>4</Sup>
+      <span style={{ padding: '0 1.4em' }} />
+      <V>s</V> = <Frac over={<V>u</V>} under={<>2</>} />
     </Eq>
 
     <Eq derive={MEETINGS} open={show}>
@@ -671,8 +960,9 @@ export const Law = () => {
         <>ways out of a point — the 3×3×3 block around it, minus itself</>],
       [<><K>SHEET</K> = 3<Sup>2</Sup> − 1 = 8</>,
         <>charges in one pulse: the plane a source emits into, which turns with it</>],
-      [<><K>BITE</K> = 2</>,
-        <>points an annihilation removes — one for each charge</>],
+      [<><K>BITE</K> = 1</>,
+        <>points an annihilation removes — one, so that making and unmaking
+          a ± pair are exact inverses</>],
       [<><K>LIGHT</K> = 1</>,
         <>points per tick, and nothing goes faster</>],
       [<><K>HALF</K> = ½</>,
@@ -711,6 +1001,28 @@ export const Law = () => {
         <>Along the way a thing is going, and across it — special relativity’s
           own response, out of the count being a count on the body’s own
           worldline.</>],
+      [<span style={{ color: DERIVED }}>
+        <V>A</V> = 1 − 2<V>u</V> + 2<V>u</V><Sup>2</Sup>,{' '}
+        <V>B</V> = 1 + 2<V>u</V></span>,
+      <><b style={{ color: INK }}>A metric, out of the same count.</b> The lean
+        is a <i>ratio</i> — 1 + <V>n</V> against the <K>WAYS</K> that weigh one
+        each — and a ratio throws away the total. There are{' '}
+        <K>WAYS</K> + <V>n</V> ways out of that point now, and a point with
+        more ways out holds more space. The lean is <V>A</V>; the total
+        is <V>B</V>.</>],
+      [<span style={{ color: DERIVED }}>
+        6π<V>GM</V>/<V>c</V><Sup>2</Sup><V>a</V>(1−<V>e</V><Sup>2</Sup>)</span>,
+      <><b style={{ color: INK }}>The perihelion advance, all of it.</b> Five
+        orbits over two panels come to 6.05 to 6.20 sixths of it, ordered by
+        how deep each orbit sits and by nothing else. The lean alone gives one
+        sixth, and gives it to a part in a hundred for every one of them.</>],
+      [<span style={{ color: DERIVED }}>
+        4<V>GM</V>/<V>bc</V><Sup>2</Sup></span>,
+      <><b style={{ color: INK }}>The deflection of light, all of it.</b> Which
+        the lean could not touch at all — at <V>v</V> = <V>c</V> the count is
+        already infinite, so one more annihilation turns it by nothing. A
+        thickness needs no mass to divide by: the cell in front is simply
+        longer.</>],
       [<span style={{ color: DERIVED }}>screen</span>,
         <>Three bodies in a row do not simply add. Newton has no such term and
           neither does relativity at this order.</>],
@@ -754,13 +1066,103 @@ export const Law = () => {
       <b style={{ color: INK }}>Newton, times a bracket that goes to one</b> —
       and a constant written entirely in counts. The whole of the model’s
       departure from Newton at a distance is that bracket, and its size is the
-      ratio of a source’s core to the separation. The <V>γ</V> on the left is
-      worth <b style={{ color: INK }}>+1.67°</b> of Mercury’s perihelion an
-      orbit where Schwarzschild gives <b style={{ color: INK }}>+10.41°</b> —
-      the right sign, and a sixth of the size. The missing five sixths, and the
-      whole of light’s deflection, are the part of a metric that says how
-      lengths differ radially against transversely. This keeps one number per
-      place, and cannot say it.
+      ratio of a source’s core to the separation.
+    </Note>
+
+    <Note>
+      The <V>γ</V> on the left is worth <b style={{ color: INK }}>+1.66°</b> of
+      Mercury’s perihelion an orbit where 6π<V>GM</V>/<V>c</V><Sup>2</Sup>
+      <V>a</V>(1−<V>e</V><Sup>2</Sup>) is{' '}
+      <b style={{ color: INK }}>+9.93°</b> — the right sign, and{' '}
+      <b style={{ color: INK }}>a sixth</b> of the size. Measured on Venus,
+      Earth and Mars too, and on a second panel at a different scale, it is a
+      sixth every time to a part in a hundred.
+    </Note>
+
+    <Note>
+      That sixth is the count read as a <i>direction</i>. Read a second time as
+      a <i>size</i> — the same annihilations saying how much space a point
+      holds rather than which way it leans — the same orbit advances{' '}
+      <b style={{ color: INK }}>+10.35°</b>, which is{' '}
+      <b style={{ color: INK }}>6.20 sixths</b>, and a ray grazing the sun
+      bends by the whole <V>4GM</V>/<V>bc</V><Sup>2</Sup> rather than half of
+      it. Nothing is added to get it: <V>A</V> and <V>B</V> carry the same{' '}
+      <V>u</V> with the same coefficient, which is the statement that a point’s
+      lean and a point’s thickness are one event seen twice — and is the
+      sharpest thing here to be wrong about, since it is what fixes{' '}
+      <V>γ</V><Sub>PPN</Sub> = 1, and Cassini has that to 2·10<Sup>−5</Sup>.
+    </Note>
+
+    <Head>and where the space comes from</Head>
+
+    <Note>
+      Everything above is one rule — what a meeting does to a path. <V>B</V>{' '}
+      needs a second, and it is about what a meeting does to the <i>amount</i>{' '}
+      of space rather than to its lean. Three rewrites, and nothing else:
+    </Note>
+
+    <Eq derive={SPACE} open={show}
+      note="making a charge makes space; a meeting takes it back; a move carries it">
+      neutral &nbsp;→&nbsp; + &nbsp;−
+      <span style={{ padding: '0 1.4em', color: FAINT }}>+1</span>
+      + &nbsp;− &nbsp;→&nbsp; neutral
+      <span style={{ padding: '0 1.4em', color: FAINT }}>−1</span>
+      move
+      <span style={{ padding: '0 0.8em', color: FAINT }}>0</span>
+    </Eq>
+
+    <Note>
+      A body emitting <V>m</V><K>SHEET</K> charges a tick is therefore a{' '}
+      <b style={{ color: INK }}>point source of space</b> — at the body, not in
+      its field. Every earlier attempt at <V>B</V> sourced from{' '}
+      chance ∝ 1/<V>r</V><Sup>2</Sup>, and a source spread like that gives a
+      logarithm. A point gives a potential. The moves then carry it, and a
+      carried point source settles:
+    </Note>
+
+    <Eq derive={SPACE} open={show}
+      note="static, because the flux carries the surplus away as fast as it is made">
+      <V>δ</V>(<V>r</V>) = <Frac over={<V>S</V>}
+        under={<>4<V>π D r</V></>} /> = 3<V>u</V>
+      <span style={{ padding: '0 1.6em' }} />
+      <V>D</V> = <Frac over={<><V>π</V> <K>WAYS</K> <V>c</V></>}
+        under={<>3 <K>BITE</K> <K>SHEET</K></>} /> = 3.403
+      <span style={{ padding: '0 1.6em' }} />
+      ⇒ <V>u</V> = <Frac over={<V>Gm</V>}
+        under={<><V>r c</V><Sup>2</Sup></>} />
+    </Eq>
+
+    <Note>
+      Which is the metric’s own potential, out of a rate and a spread. It is
+      linear in the <i>other</i> mass alone — a fact about the place rather
+      than the pair, which the folding could never say before — and it gives
+      every number the old reading gave, to the digit. The difference is that
+      the old one took the pull and called its potential <V>u</V>, and this one
+      is derived.
+    </Note>
+
+    <Head>and what is still owed</Head>
+
+    <Note>
+      <b style={{ color: INK }}>One thing, and it is in the lattice rather than
+        here.</b> The third rewrite is what carries the surplus, and on the
+      lattice that is consume-ahead-emit-behind — measured, an exact swap that
+      displaces nothing net. Whether it can carry a surplus outward at{' '}
+      <V>D</V> ≈ 3.4 steps² a tick is a question about that rule, not a new
+      one. Until it is answered, <V>D</V> is a number the continuum needs and
+      the lattice has not been shown to supply.
+    </Note>
+
+    <Note>
+      Two things bound whatever answers it. An ambient charge{' '}
+      <b style={{ color: INK }}>screens</b>: a body’s charges annihilate
+      against it too, so they reach only{' '}
+      <V>λ</V> = <V>c</V>/(<K>BITE</K>·share·<V>Φ</V><Sub>0</Sub>) and gravity
+      becomes Yukawa with that range — cluster scale needs{' '}
+      <V>Φ</V><Sub>0</Sub> ≲ 10<Sup>−58</Sup> a lattice cell. And a body{' '}
+      <b style={{ color: INK }}>cannot take back</b> what it emits: measured on
+      a running lattice, at most two parts in a thousand return, because a
+      source emits into 4<V>π</V> and subtends nothing.
     </Note>
 
     {open ? <Panel of={open} onClose={hide} /> : null}
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
index 5db7a7c..140b4f2 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
@@ -14,8 +14,15 @@
  *   the density of space, which is the whole of gravity here:
  *     u_a       = own_a + pulled_a                its count, in cells a tick of
  *                                                 ITS OWN clock
- *     u̇_a      = BIAS · S(a,b) / m_a             the pull, per body, per tick
- *     ṙ_a      = pace(u_a) = u_a/√(1 + |u_a|²)   ... and what that comes to
+ *     u̇_a      = BIAS · S(a,b) / m_a · carry     the pull, per body, per tick
+ *     fold_a    = Σ_b  G·m_b / (r_ab c²)         how thick the place it stands
+ *                                                 in is — the steady state of
+ *                                                 a point source of space at
+ *                                                 each body, carried. Linear
+ *                                                 in the OTHER mass alone, so
+ *                                                 a fact about the place. See
+ *                                                 `settle` and `foldAt`.
+ *     ṙ_a      = pace(u_a, fold_a)               ... and what that comes to
  *                                                 as a speed in the picture
  *
  *   An annihilation leaves the space where it happened denser: the next path
@@ -24,6 +31,12 @@
  *   weighs 1 + n against the WAYS out that weigh one each, and what that leans
  *   a path by is LIGHT·n/WAYS — linear, with no ceiling in it.
  *
+ *   THAT IS A RATIO, and a ratio is not all a count says. The ways out of that
+ *   point no longer number WAYS; they number WAYS + n. The lean is the first
+ *   moment of the count and is the whole of the pull; the total is the zeroth,
+ *   and is how much space the point holds. One scalar, read twice — the pull
+ *   for A and the thickness for B. See `slowing` and `thickness`.
+ *
  *   Everything else here falls out of that, and none of it is stated:
  *
  *     BIAS        one annihilation buys LIGHT/WAYS, whatever else is going on
@@ -35,14 +48,16 @@
  *     at speed    the count is per tick of the BODY'S clock, so `pace` is what
  *                 the picture sees. Differentiated, that is 1/γ³ along the way
  *                 it is going and 1/γ across — special relativity's own
- *                 response, out of a count of ways out of a point, and it puts
- *                 Mercury's perihelion +0.56° an orbit against Schwarzschild's
- *                 +3.21°: same sign, one sixth the size. See `pace`.
+ *                 response, out of a count of ways out of a point. On its own
+ *                 that is Mercury's perihelion at one sixth of Schwarzschild's;
+ *                 with the count's other reading in, 6.07 sixths, and light
+ *                 deflected by the whole 4GM/bc². See `pace` and `thickness`.
  *     ÷ m_a       a_a ∝ m_b/R², a_b ∝ m_a/R²      the equivalence principle:
  *                 heavier things have proportionally more paths to bias, so
  *                 the same fraction of them bends. Inertia IS path count.
  *
- *   G           = SHEET² / (4π²·CORE·WAYS)       closed form, nothing fitted.
+ *   G           = BITE·SHEET²·c/(8π²·HALF·WAYS)  closed form, nothing fitted,
+ *                                                 and in the lattice's own units
  *                                                 `S·R²` runs above it by
  *                                                 CORE·ln(R/CORE)/R — which
  *                                                 is nothing at a separation
@@ -62,14 +77,14 @@ import {
   Emitter, fade, grainAt, HALF, Live, sparse, emit, fieldAt, TRAIL,
 } from "./field";
 import {
-  annihilation, BIAS, coherence, count, pace, shortfall,
+  annihilation, BIAS, carry, coherence, count, foldAt, pace, shortfall,
 } from "./gravity";
 import { CYCLE, SPIN, TAU } from "./lattice";
 import {
   AMBER, BACKGROUND, CYAN, decadesFor, ground, legend, lift, NEUTRAL, rgba,
   shown, source, trail,
 } from "./paint";
-import { cancelling } from "./physics";
+import { cancelling, LIGHT } from "./physics";
 
 /**
  * Gravity as a shortage of space, which is what the lattice actually does.
@@ -110,6 +125,16 @@ import { cancelling } from "./physics";
  *    same metric, so as a pair close, they begin to hear each other sooner
  *    — which the lattice does and the flow account cannot.
  *
+ *    WITH A SIGN TO WATCH, since this sentence can be read two ways and only
+ *    one of them is true. If it means the pair have got CLOSER, it is just
+ *    attraction said over again and there is nothing else in it. If it means
+ *    the same separation now costs fewer ticks, it is the wrong way round:
+ *    light near a mass is DELAYED, not hurried, and the whole of `thickness`
+ *    is that a folded place holds more steps and so takes longer to cross.
+ *    `φ` here is the drawing's own scalar and drives nothing (see
+ *    `spaceStep`), so nothing is computed off the wrong reading — but the two
+ *    are opposite, and the one the dynamics uses is the second.
+ *
  *  - Deflection is one line. A course that stays straight in the metric does
  *    not stay straight in the coordinates, and the turn is the component of
  *    ∇φ across the way it is going. No potential, no gradient of half a
@@ -140,26 +165,41 @@ export type Space = {
    * is at a place but WHICH WAY it went, as the three parts of a symmetric
    * 2×2.
    *
-   * `phi` is the trace of this and nothing more. Which is the whole point of
-   * having it: a scalar can say a place has had space taken out of it, and it
-   * cannot say that the space taken out was taken RADIALLY and not across.
-   * Those are different statements about the same place and general relativity
-   * needs the second one — the metric it wants is
+   * `phi` is the trace of this and nothing more.
+   *
+   * WHICH TURNED OUT TO BE THE PART THAT MATTERED, and this comment used to
+   * say the opposite, at length, and was wrong. What it said was that a scalar
+   * can record that a place has had space taken out of it and cannot record
+   * that the space was taken RADIALLY and not across; that general relativity
+   * needs the second statement; and that the five sixths of Mercury and the
+   * half of light's deflection this model was missing were therefore locked
+   * behind a tensor.
+   *
+   * The metric it wants was written out on the next line and refutes it:
    *
    *     ds² = −A dt² + B(dx² + dy² + dz²)
    *
-   * and A alone, which is all a scalar can be, gives Newton's law, one sixth
-   * of Mercury's perihelion advance, and half of the deflection of light. The
-   * other five sixths and the other half are B, and B is a statement about
-   * direction.
+   * B is a scalar there. Radial-against-transverse is a fact about SCHWARZSCHILD
+   * coordinates and not about the geometry — write the same spacetime in
+   * isotropic coordinates and the spatial part is conformally flat, and at the
+   * order any of this is being worked to it is `(1 + 2u)δᵢⱼ` for any
+   * arrangement of masses whatever. A lattice has no coordinates to choose
+   * between, so the question never even arises for it.
    *
-   * The counting argument this whole file rests on was always about direction.
-   * `BIAS` says a place that has taken an annihilation has more ways of going
-   * the way it went "while every other way out of the point still weighs
-   * exactly what it always did" — which is a count PER WAY OUT, twenty-six of
-   * them in three dimensions, and what has been kept until now is only how big
-   * it is and, per body, where it pointed. The direction was being computed
-   * and thrown away on the same line.
+   * What was actually missing was not a direction. It was the OTHER READING of
+   * the number already being computed. `BIAS` says a place that has taken an
+   * annihilation has more ways of going the way it went "while every other way
+   * out of the point still weighs exactly what it always did" — and that is
+   * true, and it is a RATIO, and a ratio throws away the total. There are now
+   * WAYS + n ways out of that point rather than WAYS, and a point with more
+   * ways out of it holds more space. The lean is A. The total is B. See
+   * `slowing` and `thickness` in `gravity.ts`, and `settle` below, which is
+   * the whole of the fix and is four lines.
+   *
+   * So this array is not what buys the five sixths, and it never was. What it
+   * is still for is the thing a scalar genuinely cannot do — a transverse
+   * traceless part, which is radiation — and that is a long way past anything
+   * measured here.
    *
    * So this keeps it. Nothing new is measured: `shortfall` already walks the
    * line between every pair and already knows which way it is walking, so
@@ -194,7 +234,13 @@ export type Space = {
    * axisymmetric. Measured on Sun and Mercury over the panel's own run: every
    * one of 72 bearings lit at every radius out to 20 cells, the axis within
    * 0.4° to 2.7° of radial, and `spread` at 0.995 to 1.000 — folded radially
-   * and not at all across, which is the shape general relativity's B has.
+   * and not at all across.
+   *
+   * That measurement stands; the conclusion drawn from it did not. Radial
+   * against transverse is a statement about a choice of radial coordinate, and
+   * `settle` gets the whole of B out of the trace without one. What is
+   * genuinely here is axisymmetry — which is a check that the sweep does what
+   * it was supposed to, and not a metric the model needed.
    *
    * WHAT IS WRONG WITH IT, stated plainly because it is not small. The count
    * that builds up at planetary mass ratios is about 1e−10, so the bias is
@@ -611,12 +657,73 @@ export const MetricField = ({
      * Which is why it accelerates rather than merely displaces: the count
      * persists, and what the picture shows is a function of the count.
      */
+    /**
+     * `fold` is the third thing, and it is not a ledger: it is how thick the
+     * place this body is standing in is, RIGHT NOW, and it is recomputed from
+     * scratch every step (see `settle`). `pulled` accumulates because a count
+     * of annihilations accumulates; `fold` does not, because where you are
+     * standing is not a history. That difference is the whole of A against B.
+     */
     type Carried = Live & {
       own: [number, number], pulled: [number, number], mark: number[],
+      fold: number,
     };
 
     let live: Carried[] = [];
 
+    /**
+     * How thick the place each of them stands in is — the SAME meetings the
+     * pull is counted out of, read as a size instead of as a direction.
+     *
+     * `shortfall` gives the meetings a pair has per tick; divided by a body's
+     * own mass and by the step it is the acceleration that body feels, and an
+     * acceleration times the separation is the potential it is the gradient
+     * of. So there is no new field here and no second source term — it is one
+     * scalar read twice, which is what `slowing` and `thickness` are for.
+     *
+     * WHAT THIS USED TO BE, and why it changed, because the objection it
+     * carried was the right one.
+     *
+     * This line read `BIAS·shortfall/m_a · R/c²` — an acceleration off the
+     * pull, times the separation. Which is the correct number and is not an
+     * argument: it takes a force and calls its potential `u`. Worse, it went
+     * as `m_a·m_b`, so what came out was a fact about a PAIR, and a thickness
+     * is a fact about a PLACE. Nothing could be asked of it away from a body.
+     *
+     * `foldAt` answers both. Space is MADE — one neutral point becoming the
+     * two a ± pair needs — so a body emitting `m·SHEET` charges a tick is a
+     * point source of it. The moves carry it, and a carried point source
+     * settles to `S/(4πDr)`, which is `G·m/(r c²)` once `D` is what it has to
+     * be. That is linear in the other mass alone, it can be evaluated
+     * anywhere, and it is derived rather than read off.
+     *
+     * The value does not move — every orbit, the 1/6, the deflection, all
+     * identical to the digit. What moved is what it is a statement about.
+     *
+     * WHAT IS STILL OWED is now one thing and it is in the DISCRETE case: the
+     * third rewrite carries the surplus, and on the lattice that is
+     * `emitBehind`/`consumeAhead`, which is an exact swap that displaces
+     * nothing net. Whether it can carry a surplus outward at `D ≈ 3.4` steps²
+     * a tick is a question about the rule and not a new rule. See `SPREAD`.
+     */
+    const settle = () => {
+      for (const s of live) s.fold = 0;
+
+      for (let i = 0; i < live.length; i++)
+        for (let j = 0; j < live.length; j++) {
+          if (i === j) continue;
+
+          const a = live[i], b = live[j];
+
+          const R = Math.hypot(b.at[0] - a.at[0], b.at[1] - a.at[1]);
+          if (R < 1e-6) continue;
+
+          // what b's own source puts here — see `foldAt`. Nothing about a is
+          // in it, which is the whole difference from what this used to be.
+          a.fold += foldAt(b.mass ?? 1, R);
+        }
+    };
+
     const reset = () => {
       t = 0;
       world = space(span, sources.length);
@@ -625,20 +732,32 @@ export const MetricField = ({
         at: [...s.at] as [number, number],
         path: [s.at[0], s.at[1]],
         vel: [s.drift?.[0] ?? 0, s.drift?.[1] ?? 0] as [number, number],
-        own: count(s.drift?.[0] ?? 0, s.drift?.[1] ?? 0),
+        own: [0, 0] as [number, number],
         pulled: [0, 0] as [number, number],
         mark: [s.at[0], s.at[1]],
+        fold: 0,
       }));
+
+      // A body already going somewhere got there by having been biased, so its
+      // opening count is a ledger reading (see `count`) — and what a count
+      // comes to depends on where it is standing, so the folding has to be
+      // known before the reading can be taken.
+      settle();
+
+      for (const s of live)
+        s.own = count(s.drift?.[0] ?? 0, s.drift?.[1] ?? 0, s.fold);
+
       kept = 0;
     };
 
     // Its own count plus whatever the space around it has added to it, turned
     // into the speed the picture can show. See `pace`: the sum is a proper
-    // velocity and this is the only place it becomes a coordinate one.
+    // velocity, this is the only place it becomes a coordinate one, and how
+    // many cells it is worth depends on how thick the place is.
     const going = (s: Live): [number, number] => {
-      const { own, pulled } = s as Carried;
+      const { own, pulled, fold } = s as Carried;
 
-      return pace(own[0] + pulled[0], own[1] + pulled[1]);
+      return pace(own[0] + pulled[0], own[1] + pulled[1], fold);
     };
 
     /**
@@ -745,6 +864,10 @@ export const MetricField = ({
     const most: number[] = [];
 
     const spend = (dt: number) => {
+      // Where everything is standing, before anything is asked what a count is
+      // worth there. A snapshot and not a tally — see `settle`.
+      settle();
+
       for (let i = 0; i < live.length; i++) most[i] = 0;
 
       for (let i = 0; i < live.length; i++)
@@ -790,7 +913,20 @@ export const MetricField = ({
             // the same number however fast it is already going. See `BIAS`.
             const got = BIAS * deficit / (s.mass ?? 1);
 
-            s.pulled[0] += ux * got; s.pulled[1] += uy * got;
+            /**
+             * And what that count is worth WHERE IT IS, which is one wherever
+             * nothing is going on. See `carry`: the meetings are still
+             * counted the same way and still weigh `BIAS` each, but a step is
+             * not worth a step in a place that has been folded, and a body
+             * already moving samples the folding across its motion as well as
+             * along it. That factor is the other five sixths.
+             */
+            const worth = carry(
+              s.own[0] + s.pulled[0], s.own[1] + s.pulled[1], s.fold,
+            );
+
+            s.pulled[0] += ux * got * worth;
+            s.pulled[1] += uy * got * worth;
           }
         }
     };
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
index 46045d2..09e3ed7 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -4,7 +4,8 @@ import { bySide, Graph, perPoint } from "./discrete";
 import { Polarity, Source } from "./physics";
 import { RenderMode } from "./GraphCanvas";
 import { alternatingIntoRandom, collisionGroups, lineGroups } from "./lines";
-import { GRAVITY } from "./gravity";
+import { GRAVITY, pace, slowing, thickness } from "./gravity";
+import { emitterOf } from "./field";
 import { APART, Model, NEAR } from "./model";
 
 /**
@@ -84,6 +85,58 @@ const LATTICE_FOR = 60;
  */
 const ORBIT = 0.35 * LIGHT;
 
+/**
+ * What the sources of the small panels weigh — and until now, nothing, which
+ * meant one.
+ *
+ * These panels were written when a mass here was a number near a half and a
+ * source with no mass stated was a source weighing one of them. `GRAVITY` now
+ * carries the grain (see `gravity.ts`) and is of order 1e11, so an unstated
+ * mass is a body whose `GM/Rc²` at the separations drawn here is 1.8e9 — which
+ * is not a heavy body, it is thirty-odd cells inside a horizon. It went unseen
+ * for exactly as long as the dynamics could not tell: `pace` saturates at
+ * light whatever it is handed, so an absurd pull and a merely large one drew
+ * the same picture. Reading the count as a metric as well can tell, instantly
+ * and loudly, and that is how this was found.
+ *
+ * Solved rather than picked, by the same similarity the three-body panels use
+ * (see `TRIO`): two equal masses a distance D apart, each going round the
+ * middle at v, need `v² = Gm/2D`. Fixing D and v at what the orbit panel is
+ * drawn with leaves the mass, and every panel in this family is at the same
+ * scale, so they all take it.
+ *
+ * Which puts `GM/Rc²` between 0.1 and 0.45 across this family, and that is not
+ * a weak field. It is forced rather than chosen: these panels are drawn at a
+ * third to a half of light so that anything can be watched inside a few
+ * hundred ticks, and a pair bound at that speed needs a fold of that order —
+ * `v² ≈ GM/2D` is the same equation read either way round. There is no mass
+ * that makes them both watchable and weakly curved.
+ *
+ * SO THEY DO NOT CLOSE, and the note on `two sources, in orbit` claiming three
+ * turns is now wrong. Measured, an equal-mass pair started for a circular orbit
+ * at a separation of 48:
+ *
+ *     v/c        0.35    0.25    0.18    0.12    0.08    0.05
+ *     fold      0.245   0.125   0.065   0.029   0.013   0.005
+ *     ends at    1024     351      93      61      53      50   cells apart
+ *
+ * — unbound at the top, and still creeping out at the bottom where the field
+ * is weak enough that it should not. The first is real: a Newtonian circular
+ * condition is not a relativistic one, and at a quarter it is nowhere near.
+ * The second is not the law — it is `step` in `metric.tsx` being a forward
+ * Euler at a quarter-tick where `newton.tsx` is a velocity Verlet, which gains
+ * energy round an orbit. Both wanted before these panels say anything again.
+ *
+ * The three-body panels are unaffected: `TRIO` puts them at a fold of 0.024,
+ * and the figure eight stays inside 44.9 cells of the middle over its whole
+ * run, which is what it did before any of this.
+ */
+const PAIR = 2 * (2 * 24) * ORBIT * ORBIT / GRAVITY;
+
+/** The same, on a list of sources that did not say. */
+const weighed = (sources: Source[]): Source[] =>
+  sources.map(s => ({ ...s, mass: s.mass ?? PAIR }));
+
 // The fly-by's own scale: `FLY` is far enough that light takes a good while
 // to cross, and `MISS` is the impact parameter — the distance they would pass
 // at if nothing were eaten.
@@ -111,6 +164,9 @@ const triangle = (
     at: [RING * Math.cos(turn), RING * Math.sin(turn)],
     turning: lobed ? 1 as const : undefined,
     drift: going?.(turn),
+
+    // What they weigh, which they never used to say. See `PAIR`.
+    mass: PAIR,
   };
 });
 
@@ -311,7 +367,7 @@ const closedOnly: Model[] = [
     note: 'No second source, so nothing is eaten and nothing bends. The rings '
       + 'bunch ahead and stretch behind because each was left where it left '
       + 'from, and the source has gone on.',
-    world: { sources: [{ at: [-12, 0], turning: 1, drift: [PACE, 0] }] },
+    world: { sources: weighed([{ at: [-12, 0], turning: 1, drift: [PACE, 0] }]) },
     lattice: false,
     metric: { span: 14, cycle: ALONE_FOR },
   },
@@ -336,13 +392,14 @@ const closedOnly: Model[] = [
    */
   {
     name: 'two magnets, turning, with angular momentum',
-    note: 'Set going the same way round the middle. Nothing accelerates: what '
-      + 'brings them in is the gap being eaten while they carry on.',
+    note: 'Set going the same way round the middle. The gap between them is '
+      + 'eaten while they carry on, and here that is not enough to hold '
+      + 'them: at half of light they part.',
     world: {
-      sources: [
+      sources: weighed([
         { at: [-APART, 0], axis: POLES, turning: 1, drift: [0, PACE] },
         { at: [APART, 0], axis: POLES, turning: 1, drift: [0, -PACE] },
-      ],
+      ]),
     },
     lattice: false,
     metric: { span: APART * ROOM, cycle: PAIR_FOR },
@@ -372,10 +429,10 @@ const closedOnly: Model[] = [
     note: 'Set to miss each other by a long way. Both courses stay straight; '
       + 'it is the ground between them that goes.',
     world: {
-      sources: [
+      sources: weighed([
         { at: [-FLY, -MISS / 2], drift: [PACE, 0] },
         { at: [FLY, MISS / 2], drift: [-PACE, 0] },
-      ],
+      ]),
     },
     lattice: false,
     metric: { span: WIDE, cycle: PAIR_FOR },
@@ -411,10 +468,10 @@ const closedOnly: Model[] = [
     note: 'Nothing at all for thirty ticks, and then they close. The pause '
       + 'is light crossing to the middle and back — a force would not wait.',
     world: {
-      sources: [
+      sources: weighed([
         { at: [-26, 0], beat: 12 },
         { at: [26, 0], beat: 12 },
-      ],
+      ]),
     },
     lattice: false,
     metric: { span: 34, cycle: PAIR_FOR },
@@ -431,58 +488,50 @@ const closedOnly: Model[] = [
    * ever caught. Set slow with nothing else changed, everything is caught at
    * once.
    *
-   * Between the two there is an interval, and `ORBIT` is in it. Run for three
-   * hundred and twenty ticks the pair go round 1088 degrees — three full
-   * turns and part of a fourth — with the gap between them running from 16 at
-   * the tightest to 52 at the widest and neither of them ever leaving the
-   * frame.
+   * ALL OF WHICH DESCRIBED A DIFFERENT MODEL, and the whole of what used to be
+   * here is gone rather than patched, because none of it survives.
    *
-   * Two things hold it up and they pull opposite ways.
+   * What stood here said: that the pull gets STRONGER with distance, like a
+   * spring, because a meeting costs two cells however far apart the two things
+   * are; that such a pull has bound orbits everywhere and unbound ones nowhere;
+   * that nothing ever changes speed and only the direction comes round; and
+   * that run for three hundred and twenty ticks this pair goes round three full
+   * turns and part of a fourth, from 16 cells at the tightest to 52 at the
+   * widest.
    *
-   * The annihilation between them takes space out, and that is what draws
-   * them in. Measured with a pair held still and the field let settle, what
-   * it comes to at each of them is 0.03 cells a tick at a gap of 8, 0.16 at
-   * 24 and 0.40 at 32 — which is worth stopping on, because it goes the wrong
-   * way round. This is not Newton's pull, getting weaker with distance. It
-   * gets STRONGER with distance, like a spring, and that is a consequence of
-   * the rule rather than a choice: a meeting costs two cells however far
-   * apart the two things meeting are, so what varies with the gap is not the
-   * cost but how much of each field is in the other's way. A pull shaped like
-   * that has bound orbits everywhere and unbound ones nowhere, which is
-   * exactly what these runs do.
+   * `shortfall` is an inverse square (see `gravity.ts`) and `spend` changes
+   * speeds. The spring is gone, and with it every consequence drawn from it.
    *
-   * And the motion puts space BACK. `consumeAhead` is a swap — a cell taken
-   * in front is a cell laid down behind — so anything going anywhere is
-   * refilling the space it leaves at the rate it leaves it, and that pushes
-   * outwards against the eating. See `WAKE`. It is the smaller of the two by
-   * a long way, and it is not nothing: with it the tightest the pair get is
-   * 22 cells rather than 20, so the floor of the orbit is set by the swap and
-   * the ceiling by the eating.
+   * WHAT IT DOES NOW, measured rather than described: this pair does not come
+   * round at all. Started for a circular orbit at a separation of 48 it is
+   * unbound, and at the speeds these panels are drawn at that is not a bug to
+   * be tuned out — `v² ≈ GM/2D` says a pair held at a third of light needs a
+   * `GM/Rc²` of about a quarter, and a quarter is not a weak field. Slowing it
+   * until the field is weak leaves an orbit too slow to watch in a few hundred
+   * ticks. See `PAIR`, which has the numbers.
    *
-   * What is worth being clear about is what is NOT holding it up. Neither of
-   * these ever changes speed. There is no force here in the sense of a thing
-   * that could push something faster — each carries on at exactly the pace it
-   * was sent, for ever, and only the component of the fall ACROSS the way it
-   * is going is ever added. What comes round is the DIRECTION. An orbit here
-   * is not a balance of a pull against an inertia. It is a straight line
-   * through ground that keeps turning under it.
+   * There is also a second thing wrong that is not the law: `step` in
+   * `metric.tsx` is a forward Euler at a quarter-tick where `newton.tsx` is a
+   * velocity Verlet, and a forward Euler gains energy round an orbit. Even at
+   * a fold of 0.005, where the pair ought to close, it creeps out four per
+   * cent over three turns.
    *
-   * And that ground takes time to hear about anything, so this is an orbit
-   * with a delay in it — which is why the first thing the two do is get
-   * FURTHER apart, 48 out to 50. They are already moving when the run starts
-   * and nothing can act on them until light has crossed the gap and come
-   * back. They part first, and are caught afterwards.
+   * So this panel is honestly broken, and it is left drawing what it draws
+   * rather than given a mass that flatters it. What it needs is a slower
+   * `ORBIT` over a much longer `cycle`, and an integrator that conserves.
    */
   {
     name: 'two sources, in orbit',
-    note: 'Sent past each other at a third of light, and they go round — '
-      + 'nearly three times. Neither ever changes speed; only the direction '
-      + 'comes round, because the ground it is crossing falls away.',
+    note: 'Sent past each other at a third of light — and they are not '
+      + 'caught. A pair bound at that speed needs a fold of about a quarter, '
+      + 'which is not a weak field, and this panel is drawn fast so that it '
+      + 'can be watched at all. It used to claim three turns, under a pull '
+      + 'that grew with distance; that pull is gone.',
     world: {
-      sources: [
+      sources: weighed([
         { at: [-24, 0], drift: [0, ORBIT] },
         { at: [24, 0], drift: [0, -ORBIT] },
-      ],
+      ]),
     },
     lattice: false,
     metric: { span: 34, cycle: 320 },
@@ -516,7 +565,7 @@ const closedOnly: Model[] = [
       + 'and neither sent square to the line between them. It still goes '
       + 'round, which is the point.',
     world: {
-      sources: [
+      sources: weighed([
         {
           at: [-20, -6], axis: POLES, turning: 1,
           drift: [ORBIT * 0.34, ORBIT * 0.94],
@@ -525,7 +574,7 @@ const closedOnly: Model[] = [
           at: [26, 4], axis: POLES, turning: -1, phase: 1 / 6,
           drift: [-ORBIT * 1.5 * 0.42, -ORBIT * 1.5 * 0.91],
         },
-      ],
+      ]),
     },
     lattice: false,
     metric: { span: 40, cycle: 320 },
@@ -681,10 +730,10 @@ const closedOnly: Model[] = [
       + 'meetings, so the gap goes a fifth as fast — and the two are carried '
       + 'just as far while it does.',
     world: {
-      sources: [
+      sources: weighed([
         { at: [-FLY, -MISS / 2], drift: [PACE, 0], beat: 5 },
         { at: [FLY, MISS / 2], drift: [-PACE, 0], beat: 5 },
-      ],
+      ]),
     },
     lattice: false,
     metric: { span: WIDE, cycle: PAIR_FOR },
@@ -1042,35 +1091,59 @@ const known: Model[] = KNOWN.map(({ name, note, sources }) => ({
  * two classical accounts are visibly different curves, and this model is a
  * third — and the three come apart in an interesting way:
  *
- *     Newton         closed ellipses, by construction
- *     Schwarzschild  perihelion advancing  +3.2° an orbit for Mercury here
- *     this model     perihelion advancing  +11.5°, and the same way round
- *
- * So the model's departure is now the SAME sign as relativity's and about
- * three and a half times the size, where it used to be the opposite sign and
- * three times the size. Both of those are worth reading against what changed.
- *
- * The sign came from the velocity term, which is gone. Gravity here used to
- * weaken on a body already moving, by an amount first order in v/c and read
- * off the frame the canvas happened to be drawn in — so it retarded the
- * perihelion, opened the orbit out, and could be made to do almost anything by
- * boosting the whole picture sideways. What replaced it is the observation
- * that a count of annihilations is a count per tick of the BODY'S clock (see
- * `pace` in `gravity.ts`), which is second order, frame-stable, and worth
- * +0.56° an orbit — one sixth of Schwarzschild's, which is what relativistic
- * momentum on its own has always given.
- *
- * What is left is not a velocity effect at all. `shortfall` is not exactly
- * inverse square — the two ends of the line give the 1/R² and the middle of it
- * adds about (0.54·ln R + 0.23)/R on top — so the model pulls 8.5% harder than
- * its own far-field constant at twenty-four cells, and that is the whole of
- * the remaining +10.9°. It is a SHORT-RANGE departure rather than a fast one,
- * which is a different claim and a checkable one: drawn at the same speeds and
- * eight times the size, Mercury's advance here falls from 11.5° to 3.6° while
- * Schwarzschild's stays at 3.2°. These panels are drawn at the small end on
- * purpose — a solar system with a visible wave in it has to be — so what they
- * show is the model at its least Newtonian, and the departure they show is a
- * statement about cells and not about speed.
+ * Measured over forty orbits on the Sun and Mercury panel, in degrees of
+ * perihelion an orbit, against each run's own 6πGM/c²a(1−e²):
+ *
+ *     Newton         −0.23     closed, to the softening in `newton.tsx`
+ *     Schwarzschild  +3.18     0.94 of the closed form, at these speeds
+ *     this model     +3.41     1.01, and the same way round
+ *
+ * So the model now sits ON relativity rather than three and a half times past
+ * it, and the whole of the difference between those two rows is one reading of
+ * one number. It is worth being exact about which, because for a long time
+ * this comment blamed the wrong thing.
+ *
+ * The SIGN came from the old velocity term, which is gone: gravity here used
+ * to weaken on a body already moving, first order in v/c and read off the
+ * frame the canvas happened to be drawn in. What replaced it is that a count
+ * of annihilations is a count per tick of the BODY'S clock (see `pace`) —
+ * second order, frame-stable, and worth exactly one sixth of Schwarzschild's
+ * advance, which is what relativistic momentum on its own has always given.
+ *
+ * The SIZE was then blamed on `shortfall` not being exactly inverse square,
+ * and that was a real effect and the wrong culprit: at a `GRAIN` of a trillion
+ * the running is 1 + 10⁻³⁸ and could not move a perihelion if it tried. What
+ * was actually missing was the other five sixths, and they were never a
+ * velocity effect or a short-range one. They are the same count read as a size
+ * rather than as a direction — a point that has taken n annihilations has
+ * WAYS + n ways out of it and not WAYS, so it holds more space — which is the
+ * spatial part of a metric. See `slowing` and `thickness` in `gravity.ts` and
+ * `settle` in `metric.tsx`.
+ *
+ * Every body of both panels, as sixths of its own 6πGM/c²a(1−e²):
+ *
+ *                    Mercury  Mercury   Venus   Earth    Mars
+ *                     (65)     (28)
+ *     the pull        1.00     1.00     1.00    1.00     1.00
+ *     and the size    6.07     6.20     6.10    6.08     6.05
+ *
+ * WHAT IS SHARED, which had to be settled before any of the above could be
+ * read as a comparison at all.
+ *
+ * The three panels used to share one set of sources, and so one speed at
+ * perihelion. A speed is not a statement about an orbit until you say which
+ * space it is in — so whichever law that number had been worked out in got the
+ * ellipse this table specifies, and the other two got something else. Worked
+ * out in Newton's space the model ran out to 14.7 cells where the ellipse goes
+ * to 13.1; worked out in the metric, Newton's panel ran out to 11.9 instead.
+ * Either way a reader was being shown two curves that differ in setup and told
+ * they differ in law.
+ *
+ * So what is shared is the ELLIPSE. Each panel is handed the same two turning
+ * points, in cells, and solves for the speed that reaches them under its own
+ * law — `keplerian` for the classical pair, `folded` here. All three now draw
+ * the same orbit and the only thing left between them is where the perihelion
+ * goes, which is the whole of what the row was ever for.
  */
 const SUN = 39.4784176;                  // GM in AU^3/yr^2, for the Sun
 
@@ -1168,13 +1241,151 @@ type Body = [
  */
 const SLOW = 96;
 
-const system = ({ cells, ticks, centre, around }: {
+/**
+ * Whether a body is started in the space that is actually there, or in Newton's.
+ *
+ * The sibling of `settled` on a source, and the same idea one level in. A
+ * source with `settled` on has been emitting for ever, so the picture opens
+ * with its waves already in it rather than with a front crawling out of an
+ * empty frame — because the dynamics have no delay in them and a picture that
+ * opened empty would be showing one that is not there.
+ *
+ * This is that for MOTION. `settle` in `metric.tsx` fills in how thick the
+ * place each body stands in is before anything moves, so the space is already
+ * populated at t = 0 — but the speed each body was handed came from Newton's
+ * vis-viva, which is a statement about a space with no thickness in it. The
+ * two disagree, and the disagreement is not small: given a Newtonian speed at
+ * perihelion, Mercury on the close panel runs out to 14.7 cells where the
+ * ellipse it was asked for goes to 13.2, because the same stated speed is a
+ * different COUNT where `A/B` is not one (see `pace`).
+ *
+ * So the turning points are solved for in the metric instead, which is exact
+ * and closed form rather than an approximation of Newton's: `folded` below.
+ * Nothing about the law changes — this is what the body is HANDED, not what
+ * happens to it afterwards — and the perihelion advance is the same either
+ * way. What changes is that the ellipse drawn is the ellipse asked for:
+ *
+ *                  a wanted   a drawn      e wanted   e drawn
+ *     Mercury       10.839     10.84        0.20563    0.2055
+ *     Venus         20.253     20.25        0.00677    0.0068
+ *     Earth         28.000     28.00        0.01671    0.0167
+ *     Mars          42.664     42.66        0.09341    0.0934
+ *
+ * This decides the MODEL'S panel only. The two classical panels are handed the
+ * same two turning points and solve for themselves with `keplerian` and
+ * `precessing`, so all three draw the same ellipse whatever this is set to.
+ *
+ * Off, this panel is started the old way, which is what every measurement in
+ * this file that predates it was taken with.
+ */
+const SETTLED = true;
+
+/**
+ * The speed at perihelion that puts the far turning point at `ra` — Newton.
+ *
+ * `√(GM/a · (1+e)/(1−e))`, written in the turning points themselves so that it
+ * reads against the one below rather than against a semi-major axis.
+ */
+const keplerian = (gm: number, rp: number, ra: number) =>
+  Math.sqrt(2 * gm * ra / (rp * (rp + ra)));
+
+/**
+ * And the same thing where space has thickness in it, which is exact.
+ *
+ * A body in `−A dt² + B dx²` conserves its energy and its angular momentum,
+ * and at a turning point there is no radial momentum left to have — so `p` is
+ * across the folded line and is `L/r`. Setting the energy at the two turning
+ * points equal,
+ *
+ *     A(r)·(1 + L²/(r²c²B(r)))      equal at rp and ra
+ *
+ * is one linear equation in `L²` and solves outright:
+ *
+ *     L² = c²·(A_a − A_p) / ( A_p/(rp²B_p) − A_a/(ra²B_a) )
+ *
+ * — which collapses to Newton's `2GM·rp·ra/(rp + ra)` when A → 1 − 2u and
+ * B → 1, so this is the same statement with the thickness left in rather than
+ * a correction bolted onto it. What comes back is the COUNT at perihelion,
+ * and `pace` turns that into the speed the picture shows.
+ *
+ * The two-body part is left where it was: `gm` is `G(M + m)`, which is the
+ * relative orbit's constant, and the split about the barycentre happens at the
+ * call. That is the leading approximation rather than the two-body problem in
+ * a metric, and at the mass ratios here — a millionth for the planets, a part
+ * in eighty-one for the Moon — it is well under what the panels can show.
+ */
+/**
+ * And for the panel in between, whose law is neither of those.
+ *
+ * `newton.tsx` does relativity as a factor on the PULL — `1 + 3L²/(c²r²)` —
+ * which is the Schwarzschild orbit and is not a statement about what a
+ * velocity means, so neither of the two above solves it. Measured: handed
+ * Newton's speed it runs Mercury out to 12.3 cells where the ellipse asked for
+ * goes to 13.1, and handed the metric's, to 11.1. Both visibly wrong, in the
+ * same direction, for two different reasons.
+ *
+ * Its own solve is the same energy argument as `folded` in a flat space with
+ * the extra term carried, `Φ = −GM/r − GM·L²/c²r³`, and it is linear in L²
+ * again:
+ *
+ *     L² = GM(1/rp − 1/ra)
+ *          ────────────────────────────────────────────────
+ *          (1/2rp² − 1/2ra²) − (GM/c²)(1/rp³ − 1/ra³)
+ *
+ * which collapses to Newton's when the second bracket goes.
+ */
+const precessing = (gm: number, rp: number, ra: number) => {
+  const k = gm / (LIGHT * LIGHT);
+
+  const under = (1 / (2 * rp * rp) - 1 / (2 * ra * ra))
+    - k * (1 / (rp * rp * rp) - 1 / (ra * ra * ra));
+
+  if (!(under > 0)) return keplerian(gm, rp, ra);
+
+  return Math.sqrt(gm * (1 / rp - 1 / ra) / under) / rp;
+};
+
+const folded = (gm: number, rp: number, ra: number) => {
+  const k = gm / (LIGHT * LIGHT);                     // GM/c², in cells
+
+  const Ap = slowing(k / rp), Bp = thickness(k / rp);
+  const Aa = slowing(k / ra), Ba = thickness(k / ra);
+
+  const over = Ap / (rp * rp * Bp) - Aa / (ra * ra * Ba);
+  if (!(over > 0)) return keplerian(gm, rp, ra);      // degenerate: rp === ra
+
+  const L = Math.sqrt(LIGHT * LIGHT * (Aa - Ap) / over);
+
+  // The count at perihelion is L/rp, and what that comes to as a speed depends
+  // on how thick it is there.
+  return Math.hypot(...pace(0, L / rp, k / rp));
+};
+
+const system = ({ cells, ticks, centre, around, speed = folded }: {
   cells: number;                          // cells per unit of length
   ticks: number;                          // ticks per unit of time
   centre: number;                         // GM of the thing in the middle
   around: Body[];
+
+  /**
+   * And which law solves for the speed that reaches the far turning point.
+   *
+   * The panels share the ORBIT and not the speed. Handing all three the same
+   * number meant at most one of them could draw the ellipse it was asked for,
+   * and which one depended on whose space the number had been worked out in;
+   * handing each the turning points instead and letting it solve for itself
+   * means all three draw the same ellipse and the only thing left between them
+   * is where the perihelion goes, which is the whole of what the row is for.
+   *
+   * That is a change to what the comparison MEANS, and it is worth saying
+   * plainly. `newton.tsx` says the arrangements are shared so that a departure
+   * is a difference of law rather than of setup. It still is — the setup is
+   * the ellipse, stated in cells, identical across the three — but the setup
+   * is no longer a velocity, because a velocity is not a statement about an
+   * orbit unless you also say which space it is in.
+   */
+  speed?: (gm: number, rp: number, ra: number) => number;
 }): Source[] => {
-  const scale = cells / ticks;            // real speed to cells a tick
 
   /**
    * And every body given its own rate, a few per cent apart.
@@ -1191,7 +1402,7 @@ const system = ({ cells, ticks, centre, around }: {
   const orbiting = around.map(([, axis, e, perihelion, gm], i) => {
     const turn = perihelion * Math.PI / 180;
 
-    // At perihelion, a(1 − e) out along the apsidal line.
+    // At perihelion, a(1 − e) out along the folded line.
     const r = axis * (1 - e) * cells;
 
     /**
@@ -1213,8 +1424,10 @@ const system = ({ cells, ticks, centre, around }: {
      * the whole of it and then recoiling as well, the pair separate at
      * v(1 + m/M) and the apogee comes out long instead, which it did: 42.8.
      */
-    const v = Math.sqrt((centre + gm) / axis * (1 + e) / (1 - e))
-      * (centre / (centre + gm)) * scale;
+    const v = speed(
+      (centre + gm) * cells ** 3 / ticks ** 2,
+      axis * (1 - e) * cells, axis * (1 + e) * cells,
+    ) * (centre / (centre + gm));
 
     return {
       at: [r * Math.cos(turn), r * Math.sin(turn)] as [number, number],
@@ -1270,12 +1483,15 @@ const systems: Model[] = ([
       + 'shape is. It is also where relativity was measured: the perihelion '
       + 'advance is Mercury\u2019s, and the three panels part company on exactly '
       + 'that \u2014 Newton returns to the same perihelion, Schwarzschild carries '
-      + 'it forward by 3.2\u00b0 an orbit, and this model carries it forward the '
-      + 'same way by 11.5\u00b0 and closes the orbit in to 25.2 cells. The '
-      + 'direction is right and the size is not, and what is wrong with the '
-      + 'size is short range rather than fast: at eight times this scale and '
-      + 'the same speeds it comes down to 3.6\u00b0 while Schwarzschild\u2019s stays '
-      + 'where it is.',
+      + 'it forward by 3.18\u00b0 an orbit, and this model carries it forward the '
+      + 'same way by 3.41\u00b0, which is 1.01 of the 6\u03c0GM/c\u00b2a(1\u2212e\u00b2) '
+      + 'the advance was measured against. It used to be a sixth of that, and '
+      + 'the other five sixths are not a new force \u2014 they are the same count '
+      + 'of annihilations read as how much space a point holds rather than as '
+      + 'which way it leans. And the ellipse is the one asked for: 20.0 cells '
+      + 'to 30.3, against the 20.0 to 30.3 Mercury\u2019s real eccentricity '
+      + 'specifies, because the body is started in the space that is there '
+      + 'rather than in Newton\u2019s.',
     cells: 65, ticks: 12000, span: 44, cycle: 24000, rate: 600,
     centre: SUN,
     around: [['Mercury', 0.38710, 0.20563, 0, SUN * 1.66012e-7]],
@@ -1286,16 +1502,18 @@ const systems: Model[] = ([
       + 'eccentricities, real longitudes of perihelion, and the masses worked '
       + 'out from this model\u2019s own G. Newton traces the four ellipses and '
       + 'closes them; relativity advances each perihelion a little; this model '
-      + 'advances it the same way and too far, and pulls the orbit in. Mercury '
-      + 'departs most in all three panels \u2014 not because it is fastest, '
-      + 'which is what the velocity term this model used to have would have '
-      + 'said, but because it is CLOSEST: the departure goes as one over the '
-      + 'separation in cells, so the innermost body sees the most of it. '
-      + 'Measured over the eleven thousand ticks of this run: Mercury runs 8.6 '
-      + 'to 13.2 cells and comes round 15.1 times under Newton, 8.6 to 12.3 '
-      + 'and 16.3 times under Schwarzschild, and 8.6 to 9.5 and 21.4 times '
-      + 'here \u2014 which at 8.6 cells is the model well inside the range '
-      + 'where it agrees with anything. Venus and Earth are drawn as very '
+      + 'advances it the same way and by very nearly the same amount. Four '
+      + 'bodies is the point of this panel rather than one: measured against '
+      + 'each orbit\u2019s own 6\u03c0GM/c\u00b2a(1\u2212e\u00b2), the advance here comes to 6.20, '
+      + '6.10, 6.08 and 6.05 sixths for Mercury, Venus, Earth and Mars \u2014 '
+      + 'ordered by how deep each orbit sits and by nothing else, which is the '
+      + 'next term along being the size it should be. It is a law rather than a '
+      + 'fit to one orbit, and it was one sixth flat '
+      + 'across all four before the same annihilations were read a second '
+      + 'time. The four ellipses are also the four asked for, to four figures '
+      + 'in both the axis and the eccentricity, which they were not until the '
+      + 'starting speed was solved for in the space that is actually there '
+      + 'instead of being taken from Newton\u2019s vis-viva. Venus and Earth are drawn as very '
       + 'nearly circles because they very nearly are: their eccentricities are '
       + '0.007 and 0.017.',
     cells: 28, ticks: 3000, span: 66, cycle: 30000, rate: 600,
@@ -1318,13 +1536,20 @@ const systems: Model[] = ([
       + 'so Jupiter goes round once, Saturn a third of the way, and Neptune '
       + 'through seven degrees of the hundred and sixty-five years it takes. '
       + 'What the three panels have to disagree about is therefore all in the '
-      + 'inner four, and it is the same disagreement as above: Mercury closes '
-      + 'from 13.7 cells to 9.5 in this model and to 12.3 under '
-      + 'Schwarzschild, while Neptune — eight hundred and thirty-five cells '
-      + 'out, where this model’s short-range excess is under two parts in a '
-      + 'thousand — does not measurably differ in any of them. Which is the '
-      + 'clearest thing this frame has to say: the disagreement is with the '
-      + 'near, not with the fast.',
+      + 'inner four, and it is the same disagreement as above — but it is '
+      + 'now a small one. All three draw the same ellipse, because each is '
+      + 'handed the same two turning points and solves for its own speed to '
+      + 'reach them, so what is left between them is where the perihelion '
+      + 'goes. On this ruler that advance comes to 6.20 sixths of '
+      + '6πGM/c²a(1−e²) for Mercury and 6.05 for Mars, against a '
+      + 'relativity that would give six flat. Neptune, eight hundred and '
+      + 'thirty-five cells out, does not measurably differ in any of them. '
+      + 'Which is the clearest thing this frame has to say, and it survives '
+      + 'the reason for it having changed: what is over six goes as GM/rc², '
+      + 'so the disagreement is with the DEEP, not with the fast. It used to '
+      + 'be blamed on a short-range excess in the pull, which at the grain a '
+      + 'real lattice would have is one part in 10³⁸ and could not move a '
+      + 'perihelion if it tried.',
     cells: 28, ticks: 3000, span: 900, cycle: 60000, rate: 900, height: 420,
     centre: SUN,
     around: [
@@ -1382,7 +1607,35 @@ const systems: Model[] = ([
 }[]).map((
   { name, note, cells, ticks, span, cycle, rate, height, centre, around },
 ): Model => {
-  const sources = system({ cells, ticks, centre, around });
+  const sources = system({
+    cells, ticks, centre, around, speed: SETTLED ? folded : keplerian,
+  });
+
+  /**
+   * And the same ellipse for the two classical panels, solved in THEIR space.
+   *
+   * The three used to share one `sources`, which meant sharing one speed at
+   * perihelion — and a speed is not a statement about an orbit until you say
+   * which space it is in, so at most one panel could draw the ellipse the
+   * table above actually specifies. Whichever law the number had been worked
+   * out in got its ellipse and the other two got something else.
+   *
+   * So what is shared is the ellipse. Each panel is handed the same two
+   * turning points in cells and solves for the speed that reaches them under
+   * its OWN law — three laws, three solves, and they are three different
+   * numbers: `keplerian`, `precessing` and `folded`.
+   *
+   * `keplerian` is exact for Newton's panel up to the half-cell softening in
+   * `newton.tsx`, which leaves Mercury's aphelion 0.06 cells long out of 30.3
+   * and is well under a pixel.
+   */
+  const kepler = system({
+    cells, ticks, centre, around, speed: keplerian,
+  }).map(emitterOf);
+
+  const einstein = system({
+    cells, ticks, centre, around, speed: precessing,
+  }).map(emitterOf);
 
   /**
    * And the pace, which is now free outright.
@@ -1412,8 +1665,8 @@ const systems: Model[] = ([
     // benchmarks — three panels is already the comparison.
     lattice: false,
 
-    newton: { ...framed, gm: GRAVITY },
-    relativity: { ...framed, gm: GRAVITY },
+    newton: { ...framed, gm: GRAVITY, sources: kepler },
+    relativity: { ...framed, gm: GRAVITY, sources: einstein },
 
     /**
      * And the model's own panel draws the WAVES, not only the path.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
index 58a456a..b234f4d 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/newton.tsx
@@ -40,6 +40,23 @@ import { LIGHT } from "./physics";
  * that is known to close, and any departure in the panels beside it is a
  * difference of law rather than of setup.
  *
+ * WHICH IS STILL TRUE AND IS NO LONGER TRUE OF THE VELOCITY. It used to be:
+ * one set of sources went to all three panels, so they shared a position and a
+ * speed and there was nothing else to share. But a speed at perihelion is not
+ * a statement about an orbit until you say which space it is stated in, and
+ * the three panels do not agree about that — so whichever law the number had
+ * been worked out in got the ellipse the table asked for, and the other two
+ * quietly drew something else. Worked out in Newton's space the model ran out
+ * to 14.7 cells where the ellipse goes to 13.1; worked out in the metric's,
+ * this panel ran out to 11.9 instead.
+ *
+ * So what is shared is now the ELLIPSE — the same two turning points, in
+ * cells — and each panel solves for the speed that reaches them under its own
+ * law: `keplerian` for this one, `precessing` for the relativistic one beside
+ * it, and `folded` for the model's. See `system` in `models.ts`. The setup is
+ * identical across the three and the departure is still a difference of law;
+ * it is simply that the shared thing is a geometry rather than a number.
+ *
  * The relativistic panel matters here more than it usually would, and the
  * reason is a fact about drawing orbits on a lattice rather than about
  * gravity. An orbit worth watching has to be tens of cells across and has to
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
index d25b3d3..2a0c6c5 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
@@ -124,14 +124,31 @@ export const LIGHT = 1;
  * How much space a meeting destroys, which is the one number tying the
  * continuous rate to the discrete one.
  *
- * Two opposite charges meeting head-on cancel, and cancelling takes the point
- * each of them was on out of the world — two cells, however far apart the two
- * things meeting happen to be. On the lattice that is not a rate at all, it
- * is what `annihilate` does; in the closed form it is what the survey's
- * measured distribution is scaled to, so that the shape is measured and the
- * size is the rule's.
+ * ONE, not two, and the change is worth its paragraph because the number used
+ * to be two and the reason it is not is a piece of bookkeeping that has to
+ * close.
+ *
+ * Two opposite charges meeting cancel, and cancelling takes the point each of
+ * them was on out of the world — which is two cells, and was what this said.
+ * But a charge does not come from nowhere. A ± pair is made by one point
+ * becoming the two that a pair needs, so a creation is worth ONE point; and a
+ * meeting consumes exactly one creation's worth of charge. If a meeting gave
+ * back two, every made-and-unmade cycle would leave the world one point
+ * smaller and a perfectly paired universe would contract for free.
+ *
+ * So creation and annihilation are exact inverses only at one. On the lattice
+ * that is `annihilate` MERGING the two points into one rather than deleting
+ * both — which is the A-B-C → Y reading, and `closeUp` already keeps the
+ * lattice whole under it.
+ *
+ * IT COSTS NOTHING MEASURED, which is why it can be changed on an argument.
+ * `spend` has `accel = BIAS·shortfall/m_a ∝ BITE·m_b`, while `models.ts` sets
+ * `mass = gm·cells³/ticks²/GRAVITY` and `GRAVITY ∝ BITE`. The two cancel
+ * exactly: halving this halves G and halves every mass, the physical GM that
+ * every panel actually uses does not move, and every orbit, the 1/6 and the
+ * deflection are identical to the digit.
  */
-export const BITE = 2 * LIGHT;
+export const BITE = 1 * LIGHT;
 
 /**
  * What a step costs a source, as a multiple of the step's own length: a step

From 68e6794fc28a371978b32f883895ae025dda98fb Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Tue, 11 Aug 2026 03:40:41 +0200
Subject: [PATCH 23/47] Trying to work out conclusions of the model

---
 .../2026.RayCalculiAndPhysics/field.ts        | 429 +++++++++++
 .../2026.RayCalculiAndPhysics/gravity.ts      | 401 ++++++++++-
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 680 ++++++++++++++++++
 .../2026.RayCalculiAndPhysics/physics.ts      |  41 +-
 4 files changed, 1541 insertions(+), 10 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
index 2b5dd40..b2ece56 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
@@ -229,6 +229,24 @@ export type Emitter = {
   // Where it is, in cells.
   at: [number, number];
 
+  /**
+   * Whether this is ONE emitter or a body made of them — and it decides
+   * whether `coherence` has anything to say.
+   *
+   * `mass` here is how often a thing pulses, and once a tick is the ceiling
+   * (see `mass` in `physics.ts`), so nothing elementary weighs more than about
+   * a microgram. Everything in the panels is far past that: the Sun is 1.5e39
+   * in lattice units, which is 1.2e57 nucleons. A body like that has no single
+   * phase — it is 1e57 emitters with no reason to agree — so two such bodies
+   * are incoherent and `share` is exactly ½.
+   *
+   * That is where the ½ comes from, and it is derived rather than arranged.
+   * `models.ts` used to get the same number by spreading `flips` 3.7% a body
+   * on purpose so that no pair ever matched; the right answer for the wrong
+   * reason. Set this only on something that really is a single pulse.
+   */
+  lone?: boolean;
+
   // One if it has an axis and so has sides; nought if it puts out the same
   // thing in every direction at once.
   lobes: 0 | 1;
@@ -1072,3 +1090,414 @@ export const sparse = (beat: number | undefined, span: number) =>
  */
 export const grainAt = (turnPx: number) =>
   Math.min(Math.max((40 - turnPx) / 20, 0), 1);
+
+/**
+ * WHAT A MOVING SOURCE'S PHASE LOOKS LIKE FROM SOMEWHERE ELSE — and what is
+ * left of it when you do not know where the source IS.
+ *
+ * A source pulses at its own rate ω, which is its mass (see `mass` in
+ * `physics.ts`), and the field at a place carries the phase the source had at
+ * the RETARDED time. Moving at v, that equation has two branches, and exactly
+ * one of them is true of you:
+ *
+ *     you are AHEAD of it    t_r = (t − x/c)/(1 − β)
+ *     you are BEHIND it      t_r = (t + x/c)/(1 + β)
+ *
+ * Both are ordinary Doppler — blue ahead, red behind — and a point receives
+ * one shell, from one side, at a time. Nothing here is superposed.
+ *
+ * THE IGNORANCE IS THE OBSERVER'S. If you know how fast the thing is going but
+ * not where it is, you do not know which branch applies. Weight them `ahead`
+ * and `1 − ahead` and the expected phase is
+ *
+ *     φ = ωγ[ (1 − β + 2pβ)·t  +  (1 − β − 2p)·x/c ]
+ *     ⇒  k = ωγ(2p − 1 + β)/c
+ *
+ * and at p = ½ that is
+ *
+ *     φ = ωγ(t − vx/c²)        λ = λ_C/γβ = h/p       phase speed c²/v
+ *
+ * — the de Broglie wave, exactly. The half-difference is ωγ(βt − x/c), which
+ * is λ_C/γ with its zero at x = vt: the Compton oscillation, contracted, moving
+ * WITH the source. So the mean is the wave and the difference is the particle.
+ *
+ * IT IS NOT ROBUST, AND THAT IS THE INTERESTING PART. At p = 0.4 or 0.6 the
+ * wavelength is 20–40% off h/p, and the mean FIELD — which is
+ * `cos(φ_deBroglie)·cos(φ_Compton)` exactly at a half, to 6·10⁻¹⁵ — stops
+ * factorising at all. One number does both jobs.
+ *
+ * Tune it far enough and the wave dies outright: k = 0 at p = (1−β)/2, where
+ * the expected phase has no x in it at all and the observer holds a bare
+ * oscillation with no wavelength. Past that k turns over and the wave runs
+ * backwards. So the range is not a smooth dial with de Broglie somewhere on
+ * it — there is a zero, a sign change, and one point that gives h/p.
+ *
+ * And a half is what it has to be, for a reason that is not about radiation.
+ * Relativistic beaming puts (1+β)/2 of a moving source's output into the
+ * forward hemisphere, which would give exactly HALF the de Broglie wavelength —
+ * but beaming is the wrong quantity. What is being weighted is not how much
+ * goes each way, it is how likely YOU are to be on one side rather than the
+ * other, which is a fact about not knowing the source's POSITION. A position
+ * you know nothing about is equally likely either side of you.
+ *
+ * So: ω = m gives E = ħω from what mass is, and p = ½ gives λ = h/p from not
+ * knowing where the thing is. The bridge between them is that the ignorance is
+ * symmetric — which is the uncertainty relation doing the work, rather than
+ * being assumed.
+ *
+ * WHAT IS STILL OPEN, said plainly: in the model a point receives one efinite
+ * shell from one definite side. The ignorance is the observer's and not the
+ * lattice's. Whether that distinction is a defect or the whole content is the
+ * measurement question, and this puts it where it can be argued about dinstead
+ * of buried.
+ */
+const stretch = (v: number) => 1 / Math.sqrt(1 - (v * v) / (LIGHT * LIGHT));
+
+/** The retarded phase where the source is behind you — blue, and t_r/(1−β). */
+export const fromBehind = (x: number, t: number, v: number, omega: number) =>
+  omega * ((t - x / LIGHT) / (1 - v / LIGHT)) / stretch(v);
+
+/** And where it is in front of you — red, and t_r/(1+β). */
+export const fromAhead = (x: number, t: number, v: number, omega: number) =>
+  omega * ((t + x / LIGHT) / (1 + v / LIGHT)) / stretch(v);
+
+/**
+ * What an observer holds who knows `v` and not where the source is. `ahead` is
+ * how likely they think they are to be on the far side of it; a half is what
+ * knowing nothing comes to, and is the only value that gives h/p.
+ */
+export const expected = (
+  x: number, t: number, v: number, omega: number, ahead = 0.5,
+) =>
+  ahead * fromBehind(x, t, v, omega)
+  + (1 - ahead) * fromAhead(x, t, v, omega);
+
+/**
+ * And the wave that leaves — its wavenumber, wavelength and phase speed, as a
+ * function of how ignorant the observer is. At `ahead` = ½ this is de Broglie;
+ * anywhere else it is not, and the mean field no longer factorises.
+ */
+export const carried = (v: number, omega: number, ahead = 0.5) => {
+  const b = v / LIGHT, g = stretch(v);
+
+  const k = omega * g * (2 * ahead - 1 + b) / LIGHT;
+  const w = omega * g * (1 - b + 2 * ahead * b);
+
+  return { k, omega: w, wavelength: 2 * Math.PI / k, speed: w / k };
+};
+
+/**
+ * AND WHETHER THE LATTICE ITSELF DOES THE AVERAGING — which is what would turn
+ * the construction above into a derivation. It does not, and the obstruction
+ * turns out to be one specific thing rather than a vague worry.
+ *
+ * THREE CANDIDATES for supplying the second branch physically:
+ *
+ * a. SCATTER. Other matter turns the backward emission round, so the red phase
+ *    reaches a point that is ahead. Solving the arrival —
+ *    `t = t_e + (βt_e − X_s)/c + (x − X_s)/c` — gives
+ *    `t_e = (t − x/c + 2X_s/c)/(1 + β)`, the behind-branch with `x → 2X_s − x`.
+ *    So the scattered charge carries the RED FREQUENCY BUT TRAVELS +x, and its
+ *    k ADDS where the behind-branch's subtracts:
+ *
+ *      β     k_A        k_scattered   mean k      λ        phase speed
+ *      0.2   1.22e−2    8.17e−3       1.02e−2    615.6     1.0000
+ *      0.5   1.73e−2    5.77e−3       1.16e−2    544.1     1.0000
+ *      0.8   3.00e−2    3.33e−3       1.67e−2    377.0     1.0000
+ *
+ *    Mean k = ω₀γ/c, λ = λ_C/γ, phase speed exactly c. That is a light wave,
+ *    not de Broglie — which needs c²/v. To get k_B the red phase must ARRIVE
+ *    FROM AHEAD, and that needs the backward emission to have overtaken the
+ *    source. No scattering geometry does it. (This also sharpens the older
+ *    result that reflecting the FORWARD wave gives a plain standing wave: both
+ *    ways of turning a charge round fail, for the same reason.)
+ *
+ * b. A COMPOSITE SOURCE, which is the promising one, because it makes the
+ *    average PHYSICAL rather than epistemic. Anything above 1.36 µg is many
+ *    emitters (see `mass` in `physics.ts`), so a receiver really is ahead of
+ *    some constituents and behind others, and averaging over them is a fact
+ *    about the body rather than about anyone's knowledge.
+ *
+ * c. WHICH ONLY PUSHES THE QUESTION TO WHAT SETS THE CONSTITUENTS' PHASES —
+ *    and there the answer is sharp. With rest positions ξ and lab positions
+ *    x = vt + ξ/γ, measured as the gradient of phase across the body:
+ *
+ *      in step in the BODY's frame     k = 5.7735e−3    λ = 1088.3
+ *      in step in the LATTICE's frame  k = 0            λ = ∞, no wave
+ *      de Broglie wants                k = 5.7735e−3    λ = 1088.3
+ *
+ *    Rest-frame synchrony puts the de Broglie wavenumber straight into the
+ *    body's own internal phase pattern — no retardation, no averaging, nothing
+ *    borrowed. It is `φ_i = ω₀(t/γ − vξ_i/c²)`, and the `−vξ/c²` IS the wave.
+ *    Lattice synchrony puts nothing there at all: one global tick means one
+ *    phase, so the gradient is zero.
+ *
+ * SO THE OBSTRUCTION IS THE GLOBAL TICK, and it is the same obstruction twice.
+ * `ω₀γ(t − vx/c²)` is ω₀ times the source's proper time at the event
+ * simultaneous with (t,x) IN ITS OWN REST FRAME. Averaging the branches
+ * reconstructs rest-frame simultaneity; rest-frame synchrony assumes it. They
+ * agree to every digit because they are one statement. And `tick()` advancing
+ * everything at once is exactly the denial of it.
+ *
+ * WHICH IS A REAL STRUCTURAL REQUIREMENT, and worth more than the open question
+ * was: for de Broglie to be derived, a composite body must be IN STEP WITH
+ * ITSELF IN ITS OWN FRAME — a per-body simultaneity, not a global one. That is
+ * a statement about what the lattice's update rule would have to be, and it can
+ * be tried. It is also uncomfortable, because a global tick is most of how
+ * this model stays simple.
+ *
+ * AND (2) TWO SOURCES — the phase does interfere, at the right spacing.
+ *
+ * `φ = ω₀γ(t − v·r/c²)` has `∇φ = −ω₀γv/c²`: constant everywhere, along v,
+ * magnitude ω₀γβ/c. A genuine three-dimensional plane wave at the de Broglie
+ * wavelength, not a one-dimensional artefact. Split a path and rejoin it:
+ *
+ *      d        D         measured     λ_dB·D/d     ratio
+ *      1.0e5    4.0e6      43612.8      43531.2     1.0019
+ *      2.0e5    4.0e6      21779.2      21765.6     1.0006
+ *      1.0e5    1.2e7     130838.4     130593.6     1.0019
+ *
+ * The residual is the PARAXIAL comparison and not the model — `λ_dB·D/d` is the
+ * small-angle form, and the error halves as the angle halves. `d` must exceed
+ * λ_dB or there is no fringe at all, since the path difference saturates at d.
+ *
+ * The phase must be carried ALONG THE PATH (`φ = |k|·L`), and the model gives
+ * that without a choice being made: v in `ω₀γ(t − v·r/c²)` is the source's own
+ * velocity, so a particle that went through the upper slit has v along the
+ * upper path. Holding v fixed instead gives `|k|·L·cos θ`, both paths get the
+ * same projection, and there is no pattern whatever.
+ *
+ * WHAT IT DOES NOT GET, and this matters more than what it does: the pattern
+ * needs both paths to contribute at one screen point, and the model has one
+ * particle taking one path. So this is the fringe SPACING — geometry on top of
+ * a wavelength — and not interference. The wavelength is derived; the amplitude
+ * rule is not. Getting `λ_dB·D/d` right once λ_dB is right is close to
+ * automatic, so it confirms the wave is really three-dimensional and really
+ * travels with the particle, and it is not independent evidence.
+ */
+
+/**
+ * THE RELAXATION — one dial from the lattice's own rule to rest-frame
+ * simultaneity, so the model can be ASKED for the other theory rather than
+ * having to choose between them.
+ *
+ * The two conventions above are not two models. They are two values of the
+ * weight `ahead` already in `expected`, and everything between them is defined:
+ *
+ *     ahead = (1 − β)/2      k = 0            the global tick. No matter wave.
+ *     ahead = ½              k = ω γ β / c    rest-frame sync. de Broglie.
+ *
+ * The first is exactly where the wave was found to vanish when the weight was
+ * swept, which was recorded above as a curiosity and is not one: `k = 0` IS
+ * lattice simultaneity, because one global tick means one phase means no
+ * spatial gradient. So write the dial as
+ *
+ *     ahead = (1 − β(1 − sync))/2
+ *
+ * and the whole family collapses to one line:
+ *
+ *     k = sync · ω γ β / c          λ = λ_deBroglie / sync
+ *     Ω = ω/γ + sync · ω γ β²       at sync = 1 this is ωγ = E/ħ
+ *
+ * — linear in `sync`, with the classical particle at nought and the quantum one
+ * at one, and no discontinuity anywhere between.
+ *
+ * WHAT THE DIAL IS FOR. `sync` is how much of a body is in step with ITSELF in
+ * its OWN frame. A lone elementary emitter is trivially in step with itself, so
+ * sync = 1 and it carries a full de Broglie wave. A body of 10⁵⁷ emitters
+ * updated by one global tick is in step in the LATTICE's frame instead, so its
+ * internal phase gradient is nought and sync → 0.
+ *
+ * WHICH IS THE CLASSICAL LIMIT, and it falls out rather than being imposed:
+ * small things are quantum and big things are not, because "in step with itself
+ * in its own frame" is free for one emitter and hard for 10⁵⁷. That is a
+ * conjecture and it is testable — it predicts the matter wavelength of a
+ * composite is λ_dB/sync with sync set by how well its constituents hold a
+ * common phase, so it should degrade with internal temperature and not only
+ * with mass. Nothing here derives sync from the constituent count yet; the dial
+ * exists so that the question can be asked with numbers.
+ *
+ * AND AT sync = 1 THE PHASE IS THE ACTION. `φ = ωγ(t − vx/c²)` is `−(p·x − Et)/ħ`
+ * with `p = mγv` and `E = mγ` in lattice units where ω = m — and along the
+ * body's own worldline `x = vt` it collapses to `ωt/γ = ω·τ`, which is
+ * `−mc²∫dτ/ħ`, the relativistic free action. Not a coincidence and not put in:
+ * it is what `mass = rate` plus rest-frame simultaneity comes to. That is what
+ * makes a sum over paths meaningful at all — see the note after `wave`.
+ */
+export const relax = (v: number, sync: number) =>
+  (1 - (v / LIGHT) * (1 - sync)) / 2;
+
+/** The expected phase at a given simultaneity. `sync` = 1 is de Broglie. */
+export const synced = (
+  x: number, t: number, v: number, omega: number, sync = 1,
+) => expected(x, t, v, omega, relax(v, sync));
+
+/** And the wave that leaves, as a function of the same dial. */
+export const wave = (v: number, omega: number, sync = 1) =>
+  carried(v, omega, relax(v, sync));
+
+/**
+ * IGNORANCE OF WHICH PATH — which is the same move as `expected` made once more,
+ * and doing it properly removes the thing that was wrong with the two-slit test.
+ *
+ * That test put two openings and a screen in by hand and then measured a fringe
+ * spacing, so what came out depended on the arrangement. The arrangement is not
+ * the physics. The right object is the one that has no screen in it: a particle
+ * goes from A to B, you do not know by which path, so sum over ALL of them —
+ * each weighted `e^{iφ}` with φ its own phase.
+ *
+ * AND THAT IS ONLY MEANINGFUL BECAUSE THE PHASE IS THE ACTION. Measured, at
+ * sync = 1, to nine figures at every β:
+ *
+ *     φ = ωγ(t − vx/c²)  =  −(p·x − E·t)/ħ        p = mγv, E = mγ, ω = m
+ *     along x = vt       =  ω·τ  =  −mc²∫dτ/ħ     the relativistic free action
+ *
+ * — so summing `e^{iφ}` over paths IS `∫𝒟x e^{iS/ħ}`, with nothing inserted.
+ * The model did not have Feynman's rule put into it; it has `mass = rate` and
+ * rest-frame simultaneity, and the action is what those two come to.
+ *
+ * MEASURED, on the free propagator — paths A → midpoint y → B, summed over y
+ * with a Gaussian taper of width w (the standard regulator for an oscillatory
+ * integral, in units of the Fresnel zone √(πX/2k)):
+ *
+ *     w      X=20000   X=40000   X=80000
+ *     0.5     0.3326    0.3327    0.3328      arg(amplitude) − k·X
+ *     1.0     0.6337    0.6325    0.6319      wanting π/4 = 0.7854
+ *     2.0     0.7489    0.7473    0.7465
+ *     4.0     0.7787    0.7771    0.7763
+ *     8.0     0.7862    0.7845    0.7837
+ *
+ * and the amplitude goes as √X — ratios 1.4141 and 1.4142 against √2 = 1.4142.
+ * So the sum over paths gives the straight-line action PLUS the Fresnel phase
+ * the free propagator is known to carry. Stationary phase picks the classical
+ * path out of the ignorance, with nothing selecting it and no screen anywhere.
+ *
+ * TWO SLITS ARE THEN A COROLLARY rather than a setup — restrict the intermediate
+ * points to two openings and the same sum gives the fringes, for any geometry.
+ * Which is the answer to the objection: the pattern was never the result, the
+ * propagator is, and the pattern is one of its consequences.
+ *
+ * WHAT IS STILL ASSUMED, and it is now ONE thing rather than a gap: every path
+ * gets the SAME MODULUS. Feynman postulates it. `WAYS` looked like the obvious
+ * candidate — every way out of a point equally available — and the argument is
+ * three lines:
+ *
+ *   1. every way out of a point is equally available; that is what WAYS is
+ *   2. a charge takes exactly one step per tick, so path length ∝ time
+ *   3. so all paths from A to B in time T have N = T/τ steps and probability
+ *      (1/WAYS)^N — the same for every one of them
+ *
+ * IT DOES NOT WORK, and the reason is worth more than the argument was. Summed
+ * over every 8-neighbour lattice path of 130 steps in two dimensions, with each
+ * step weighted 1/WAYS and phased by k·|δ|:
+ *
+ *     x       |A|          arg(A)     k·x     fitted k_eff = 0.01616
+ *     40      3.17e−7      −3.036     12.0    against k = 0.30
+ *     70      4.06e−15     −2.652     21.0    ratio 0.054
+ *     100     4.69e−29     −1.956     30.0    λ_eff 389 cells, not 21
+ *
+ * The phase does not track `k·x` at all, and |A| falls twenty-two orders across
+ * that span — which is not a propagating wave but the large-deviation tail of a
+ * random walk. Most N-step paths end near the origin; the ones reaching x are
+ * exponentially rare and dominate by their own statistics instead of cancelling
+ * down to the straight line.
+ *
+ * AND THE DIAGNOSIS IS THE SAME MISTAKE TWICE. Every charge here moves at
+ * exactly c, so every step is LIGHTLIKE and every path has the same proper
+ * time: nought. A massive particle's phase is `−mc²∫dτ/ħ`, which along a
+ * lightlike path is also nought. A CHARGE'S PATH IS NOT A PARTICLE'S PATH, and
+ * `WAYS` counts a charge's options. The path integral needs the worldlines of
+ * the EMITTER, which moves at v < c and whose available directions are not
+ * WAYS at all.
+ *
+ * So the flat modulus is not derived, and it failed by exactly the error the
+ * `SHEET`/`WAYS` audit in `gravity.ts` was looking for elsewhere: a count used
+ * for a job it is not the count for. Two independent things now point at the
+ * same structural gap — the lattice has one kind of mover, and both quantum
+ * mechanics and the metric want statements about the other kind.
+ *
+ * SO THE LADDER NOW READS: mass = rate gives E = ħω; rest-frame simultaneity
+ * gives λ = h/p and makes the phase the action; ignorance over paths gives the
+ * propagator. Two things are owed — what sets `sync` for a composite, and why
+ * the modulus is flat — and neither is any longer a question about gravity.
+ */
+
+/**
+ * AND THEN THE ZIGZAG, WHICH SUPERSEDES MOST OF THE ABOVE.
+ *
+ * Everything before this got λ = h/p by averaging over what an observer does
+ * not know. This gets it from the dynamics, and it answers the modulus question
+ * the same way — so it is the better account, and the earlier one should be
+ * read as the route that found the target rather than as the derivation.
+ *
+ * THE MOVE-OR-UPDATE BUDGET. A thing has one action a tick: move, or update its
+ * own state. Light spends all of it moving and so has no clock at all, which is
+ * why it is massless. A slow thing spends most of it on itself. That is the
+ * right instinct and it has two cash-outs, only one of which survives.
+ *
+ *   IDLING   move on a fraction β of ticks, update on the other (1 − β)
+ *   ZIGZAG   move EVERY tick, always at c, and let the DIRECTION alternate;
+ *            net speed is the imbalance, and the updates ARE the reversals
+ *
+ * IDLING IS WRONG, and measurably:
+ *
+ *     β        1 − β       1/γ = √(1−β²)    ratio
+ *     0.30     0.700000    0.953939         0.7338
+ *     0.50     0.500000    0.866025         0.5774
+ *     0.95     0.050000    0.312250         0.1601
+ *
+ * It gives `(1−β)` where relativity wants `√((1−β)(1+β))` — one Doppler factor,
+ * with the other dropped. And it is not symmetric under β → −β, so a left-mover
+ * would age at 1.5 and a right-mover at 0.5. Anything that idles has a
+ * preferred frame: the one it idles in.
+ *
+ * THE ZIGZAG PUTS THE MISSING FACTOR BACK, because the `(1+β)` is carried by the
+ * backward steps, which idling has none of. Write it as the lattice rule it is:
+ *
+ *     ψ_R(x, t+1) = a·ψ_R(x−1, t) + b·ψ_L(x−1, t)
+ *     ψ_L(x, t+1) = a·ψ_L(x+1, t) + b·ψ_R(x+1, t)     a = cos m,  b = i·sin m
+ *
+ * — local, one global tick, everything at c, and `b` the amplitude to turn.
+ * The transfer matrix has determinant `a² − b² = 1` and trace `2a cos k`, so
+ *
+ *     cos Ω = cos m · cos k          exact, at every m and k
+ *
+ * and in the continuum `Ω² = k² + m²` to six figures. From that, measured:
+ *
+ *     m        k        v = dΩ/dk    mγv (want k)   mγ (want Ω)   λ/λ_dB
+ *     0.004    0.001    0.242534     0.001000       0.004123      0.999995
+ *     0.004    0.004    0.707104     0.004000       0.005657      0.999992
+ *     0.004    0.008    0.894424     0.008000       0.008944      0.999984
+ *
+ * k IS mγv, Ω IS mγ, λ IS λ_dB. And the internal rate `Ω − k·v` — the phase
+ * along the worldline x = vt — comes to `m/γ` to six figures, so TIME DILATION
+ * FALLS OUT rather than being imposed.
+ *
+ * THE REVERSAL RATE IS `CLOCK`'S OWN PULSE PERIOD. Paths with R reversals carry
+ * `(i sin m)^R` and there are C(N,R) of them, so the weighted mean gap is
+ * `1/tan(m) + 1 → 1/m` — which is X, the ticks between pulses, to the leading
+ * order everything here is worked to. So MASS-AS-PULSE-RATE AND MASS-AS-ZIGZAG-
+ * RATE ARE ONE QUANTITY, and `physics.ts` already had it.
+ *
+ * AND THE MODULUS IS DERIVED, WHICH WAS THE WHOLE QUESTION. Feynman postulates
+ * that every path counts the same. Here it does not: a path of N steps with R
+ * reversals weighs `cos^(N−R) m · sin^R m`, set entirely by how often it turns,
+ * which is set entirely by the mass. `a² + b² = 1` makes it unitary for free.
+ * The amplitude rule is the pulse rate.
+ *
+ * WHICH RETIRES A CONCLUSION DRAWN ABOVE, and it should be said plainly. The
+ * claim was that de Broglie requires per-body rest-frame simultaneity and that
+ * the GLOBAL TICK was the obstruction. This derivation uses a global tick, is
+ * local, and gets λ_dB anyway — so that claim is false as stated. What was
+ * actually shown is narrower: a composite whose constituents carry INTERNAL
+ * PHASES needs rest-frame synchrony for those phases to add up to a matter
+ * wave. The zigzag carries the phase in the AMPLITUDE OVER PATHS instead, and
+ * that needs no simultaneity convention at all. `relax`/`synced`/`wave` stay
+ * useful as a dial, but they are no longer the account.
+ *
+ * WHAT IS STILL OWED. This is 1+1 dimensions, where the checkerboard is clean;
+ * nobody has a fully satisfactory 3+1 version, so the next thing is to find out
+ * whether `WAYS` gives one — which is the emitter's-option count the audit in
+ * `gravity.ts` said was missing, now with a specific job to do. And none of it
+ * touches `SPREAD`'s factor of 3.4034, which remains a separate problem.
+ */
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index c2dfcd2..8045ace 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -543,11 +543,30 @@ export const carry = (px: number, py: number, fold: number) => {
  *   sheet-confined creation                 1/r  ✓           anisotropic 100:1
  *   the same, sheet tumbling                1/r²             averaging undoes it
  *   creation per charge per tick            1/r  ✓           lattice has no transport
+ *   point source + diffusion                1/r  ✓           needs λ = 10 cells;
+ *                                                            the vacuum gives 10⁶⁰
+ *   the same, integrated RADIALLY           1/r  ✓           G out by 3.4034
+ *                                                            exactly = πWAYS/3SHEET
  *
  * Everything that fails, fails because it is built from `chance ∝ 1/r²`. The
  * three that pass the shape test do it by an integration or a dimensional
  * reduction, and neither has a mechanism behind it.
  *
+ * AND THE TWELFTH IS THE ONE TO CHASE — the last entry. It needs no transport
+ * at all: a 1/r² density integrated radially outward IS 1/r, one integration
+ * and nothing free. It gets the shape, it is a fact about a place rather than
+ * about a pair, and it PREDICTS G instead of absorbing it — wrongly, by
+ * `π·WAYS/(3·SHEET)` exactly. A pure count, so a finite thing to hunt. See the
+ * bottom of `SPREAD`.
+ *
+ * THE ELEVENTH IS THE OTHER INFORMATIVE ONE. It has a
+ * mechanism, it is static, it gives 1/r, and it fixes its own coefficient — and
+ * it fails on ARITHMETIC THE MODEL DOES ELSEWHERE. `D = c·λ/3` is not
+ * negotiable for anything moving at c, and the only constant-density scatterer
+ * here is the vacuum, whose length `reach` already computes. See the bottom of
+ * `SPREAD`. Ten of these failed on a shape; this one failed on the model
+ * contradicting itself, which has not happened before and is worth more.
+ *
  * WHAT DOES WORK, and it is one idea: put the source AT THE BODY. If making a
  * charge converts one neutral point into the two a ± pair needs, the body is a
  * point source of space at a rate proportional to its mass — a delta function,
@@ -729,20 +748,64 @@ const density = (s: Live, r: number) => chance(s.mass ?? 1, r);
  * cosine says that and nothing more: full weight in the middle, nothing at
  * the ends, no parameter.
  *
- *     R (cells)      1      2      4      8     16     32
- *     in step        0.07   0.15   0.30   0.50   0.50   0.50
- *     half a cycle   0.93   0.85   0.70   0.50   0.50   0.50
+ * Measured against the wavelength, which is where it belongs — ω IS the mass
+ * (see `mass` in `physics.ts`), so one wavelength is 2π/m = 2π·G·λ_Compton:
+ *
+ *     R/λ            0.02   0.05   0.10   0.20   0.50   0.70   1.00   ≥1.5
+ *     in step        0.012  0.030  0.059  0.119  0.297  0.409  0.500  0.500
+ *     half a cycle   0.988  0.941  0.881  0.762  0.405  ...    0.500  0.500
+ *
+ * — rising almost exactly linearly from nought to a half across one
+ * wavelength, and flat for ever after. Gone SMOOTHLY, too: the residual
+ * ripple over R from twenty to thirty-four cells falls from 8.45% of the
+ * share to 0.32%.
+ *
+ * WHAT THAT IS A STATEMENT ABOUT, now that ω is not free. The pull goes as
+ * `share` and the incoherent value is a half, so `G_eff/G = 2·share`:
+ *
+ *     two identical emitters IN STEP and close      G_eff → 0
+ *     two identical emitters OUT OF STEP and close  G_eff → 2G
+ *     anything further apart than one wavelength    G_eff = G
+ *
+ * In step and on top of each other there is no gravity between them AT ALL —
+ * they put out the same sign at the same moment, so nothing cancels, so
+ * nothing is annihilated, so the interval between them does not shorten. Out
+ * of step, every meeting cancels and the pull is doubled.
  *
- * — a real, strong effect inside one wavelength, gone beyond it, and gone
- * SMOOTHLY: the residual ripple over R from twenty to thirty-four cells
- * falls from 8.45% of the share to 0.32%. Two things a long way apart cannot
- * be in step in any way that matters, and the model now actually says so
- * rather than saying it on average and oscillating about it.
+ * So between two of the SAME elementary thing, G runs anywhere from 0 to 2G
+ * over the first Compton wavelength and which one depends on their relative
+ * phase. Inside λ_C that is not a correction to gravity; it is a different
+ * interaction, and one that already knows about phase. Beyond λ_C the
+ * ordinary inverse square returns, which is why nothing above the Compton
+ * scale has ever seen it.
+ *
+ * None of this was added. `coherence`, `opposed` and ω have been here since
+ * the pull was written, doing what looked like bookkeeping about interference.
+ * Telling ω that it is the mass — which the Compton relation forces — is what
+ * turned them into a statement about identical particles at their own scale.
  *
  * Sources turning at DIFFERENT rates never had a fixed relation to average
  * in the first place, and go straight to a half.
  */
 export const coherence = (one: Live, two: Live, R: number) => {
+  /**
+   * A BODY MADE OF THINGS HAS NO PHASE, so it can never be coherent with
+   * anything — and that, rather than an arranged spread of rates, is why
+   * `share` is a half for everything in this article.
+   *
+   * `mass` is how often a thing pulses and once a tick is the ceiling, so an
+   * elementary emitter weighs at most `G·m_Planck` ≈ 1.36 µg. Every source in
+   * every panel is enormously past that — the Sun is 1.2e57 nucleons — and a
+   * sum of 1e57 emitters with no reason to agree has a uniform phase. The
+   * average of `opposed(ψ) = |ψ|/π` over a uniform ψ is exactly ½, which is
+   * the number this used to be given by hand.
+   *
+   * So the walk below is not about stars. It is about two of the SAME
+   * elementary thing, which do share an ω because ω IS the mass, and which
+   * therefore hold a fixed phase relation for as long as they exist.
+   */
+  if (!one.lone || !two.lone) return 0.5;
+
   if (Math.abs(one.omega - two.omega) > 1e-9) return 0.5;
 
   const steps = WALK(R);
@@ -1163,6 +1226,11 @@ export const GRAVITY = G_LATTICE * GRAIN;
  * rule would have to produce on its own for γ = 1 to be derived rather than
  * assumed.
  *
+ * IT DOES NOT. See the bottom of `SPREAD`: `MADE` and `SPREAD` are one
+ * constraint written twice (`D = c/MADE`), and read as a diffusivity it demands
+ * a mean free path of ten cells where the model's own vacuum gives 10⁶⁰. The
+ * account below is kept for its mechanism and not for its number.
+ *
  * WHY IT IS NOT WIRED IN. Three things were measured and two of them work:
  *
  *   the sign     right. Space made near a mass gives C/r < 2π, excess radius,
@@ -1189,7 +1257,13 @@ export const GRAVITY = G_LATTICE * GRAIN;
 export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
 
 /**
- * HOW FAST THE SURPLUS SPREADS — and with it, the whole of B, derived.
+ * HOW FAST THE SURPLUS SPREADS — and why this account is now CLOSED.
+ *
+ * This said "and with it, the whole of B, derived". It is not, and the reason
+ * is at the bottom of this comment: `D` is not a free number, the lattice has
+ * exactly one length that could set it, and that length is wrong by fifty-nine
+ * orders of magnitude. What follows is kept because the mechanism is right and
+ * only the number kills it, and because the number is the model's OWN.
  *
  * `MADE` above says a body makes space. This says what happens to it, and the
  * two together are what turn a rate into a metric.
@@ -1238,6 +1312,172 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  * Both are the same requirement — how much space has to end up at radius r —
  * written once as a rate per charge and once as a diffusivity. One constraint,
  * not two agreeing, and the second decimal place is not a confirmation.
+ *
+ * ---------------------------------------------------------------------------
+ * AND HERE IS WHAT KILLS IT. `D` was SOLVED FOR, by requiring δ = 3u. That is
+ * the last place γ_PPN = 1 is assumed rather than counted, so the whole point
+ * of it is to be derived independently — and a diffusivity cannot be posted as
+ * a free parameter, because for anything moving at c it is
+ *
+ *     D = c·λ/3
+ *
+ * with λ the distance between scatters. So the account is only as good as the
+ * λ the lattice can supply, and that is a question with an answer.
+ *
+ * WHAT D DEMANDS.  λ = 3D/c = π·WAYS/SHEET = 10.21 cells.
+ *
+ * WHAT THE LATTICE HAS. Diffusion needs a CONSTANT-density scatterer, because
+ * a constant D is the only thing that gives 1/r — source it from the body's own
+ * field instead and `chance ∝ 1/r²` makes λ(r) ∝ r², hence D(r) ∝ r², hence
+ * `4πr²D dδ/dr = −S` gives δ ∝ 1/r³. So it has to be the vacuum, and the model
+ * ALREADY COMPUTES that length: it is `reach`, the thing that makes gravity
+ * Yukawa, at `λ/R_horizon = REACHES = 0.361`. With the cell at the Planck
+ * length — which `physics.ts` fixes, since the mass unit is G·m_Planck —
+ *
+ *     needed     1.02·10¹    cells
+ *     have       2.91·10⁶⁰   cells
+ *     ratio      2.85·10⁵⁹
+ *
+ * and it is not a factor-of-two argument about scattering versus annihilating.
+ * A charge meeting an opposite one annihilates and an alike one scatters, at
+ * share = ½ each, so the two lengths differ by about two. Fifty-nine orders is
+ * not two.
+ *
+ * WHICH PUTS THE MODEL DEEP IN THE BALLISTIC LIMIT, and that is measured, not
+ * argued. Point source, charges streaming at c, exponential free path, isotropic
+ * re-scatter, tallying path per shell:
+ *
+ *     λ          δ·r  (flat ⇒ 1/r)          δ·r² (flat ⇒ 1/r²)
+ *                r=4     r=32    r=256      r=4     r=32    r=256
+ *     10.21    3.3e−2  2.1e−2  9.9e−3     1.4e−1  6.8e−1  2.3e+0
+ *     10³      1.8e−2  2.7e−3  4.2e−4     8.0e−2  8.4e−2  9.6e−2
+ *     10⁶      1.8e−2  2.5e−3  3.4e−4     7.9e−2  8.0e−2  7.9e−2
+ *
+ * At λ = 10.21 the profile is 1/r at exactly the coefficient assumed —
+ * `(S/4πD)(1 − r/R)`, ratio 0.989 in the window λ ≪ r ≪ R, the `1 − r/R` being
+ * the box. So the MECHANISM is sound. At λ ≫ r it is 1/r² and equals `S/4πc` to
+ * 0.6%, which is the regime the lattice is actually in.
+ *
+ * AND δ ∝ 1/r² IS NOT A POTENTIAL. `u ∝ 1/r²` does not give Newton, never mind
+ * the metric — so this route does not produce a weakened B, it produces the
+ * wrong law entirely.
+ *
+ * SO THE HONEST STATEMENT CHANGED. It was "the coefficient is unfound". It is
+ * now: `SPREAD` and `reach` are the same vacuum read twice, and they demand
+ * lengths fifty-nine orders apart, so THEY CANNOT BOTH BE RIGHT. That is worth
+ * more than the open question was — an unfound coefficient waits, whereas a
+ * contradiction has to be spent, and there are only two ways to spend it.
+ *
+ *   drop `reach`     then λ is free and D can be 10.21 — but `REACHES = 0.361`
+ *                    is the one full prediction in this file, and it goes.
+ *   keep `reach`     then transport is ballistic, δ goes as 1/r², and space
+ *                    being made cannot be where the metric comes from at all.
+ *
+ * The second is the one to take, because `reach` is counted and `SPREAD` was
+ * solved for, and a derived number outranks a fitted one.
+ *
+ * ---------------------------------------------------------------------------
+ * AND SPENDING IT THAT WAY PAYS, WHICH WAS NOT EXPECTED. Killing diffusion does
+ * NOT kill the point source, because there is a way to get 1/r out of a 1/r²
+ * density that needs no transport whatever, and it had not been tried:
+ *
+ *     ∫_r^∞ (1/s²) ds = 1/r
+ *
+ * INTEGRATE IT RADIALLY. One integration, no diffusivity, no mean free path,
+ * nothing free. And it is not "read u off the force" — δ goes as `m_b` ALONE
+ * where `shortfall` goes as `m_a·m_b`, so this is a fact about a PLACE, which
+ * was the entire objection to the old `settle`.
+ *
+ * MEASURED, with `δ(s) = chance(m,s)/c`, the surplus read ballistically:
+ *
+ *     r        ∫_r^∞ δ ds     m·SHEET/(4πrc)    ratio
+ *     10       6.362817e−2    6.366198e−2       0.999469
+ *     100      6.366158e−3    6.366198e−3       0.999994
+ *     1000     6.366191e−4    6.366198e−4       0.999999
+ *
+ * — 1/r, exactly, with nothing fitted. So it PREDICTS G rather than absorbing
+ * it. Setting `∫δ = 3u` and `u = G·m/(rc²)`:
+ *
+ *     predicted    G = SHEET·c/(12π)      = 0.21220659
+ *     the pull's   G = SHEET²/(4π²·WAYS)  = 0.06235150
+ *     ratio                                 3.403392
+ *     π·WAYS/(3·SHEET)                      3.403392
+ *     SPREAD                                3.403392
+ *
+ * THE THREE ARE ONE NUMBER, and that says what `SPREAD` actually is. It is NOT
+ * a diffusivity. It is the factor by which the METRIC route's G exceeds the
+ * PULL route's G, and it was given the name of a mechanism it does not have.
+ * The mechanism is dead by fifty-nine orders; the NUMBER is real, and it is a
+ * measured disagreement between two independent derivations of one constant.
+ *
+ * WHICH IS A FAR BETTER PLACE TO BE STUCK. Before: an unfound coefficient and a
+ * mechanism needing a length the lattice has not got. Now: two routes, both
+ * counted, neither with a free parameter, disagreeing by `π·WAYS/(3·SHEET)`
+ * exactly — a pure count, so a statement about the lattice's geometry and
+ * nothing else. Something in one of the two counts is wrong and it is a
+ * COUNTABLE thing. That is a finite search, which "unfound" never was.
+ *
+ * AND THE FIX IS NOT A COEFFICIENT. The two agree iff `WAYS/SHEET = 3/π`:
+ *
+ *     d = 2   WAYS 8     SHEET 2    ratio 4.0000
+ *     d = 3   WAYS 26    SHEET 8    ratio 3.2500      want 0.9549
+ *     d = 4   WAYS 80    SHEET 26   ratio 3.0769
+ *     d = 5   WAYS 242   SHEET 80   ratio 3.0250
+ *
+ * `3/π` is irrational and `WAYS/SHEET` is a ratio of integers that tends to 3
+ * from above, so no dimension closes it and no lattice of this shape can. The
+ * two counts cannot both be right AS THEY STAND. Since they are not even the
+ * same kind of count — SHEET is what a source EMITS, WAYS is what a path could
+ * have DONE INSTEAD — the honest reading is that one of them is being used for
+ * a job it is not the count for, which is the same mistake `gravity.ts` already
+ * made once and recorded under `WAYS`.
+ *
+ * THE AUDIT, done. `WAYS` enters the DYNAMICS in exactly one place — `BIAS` —
+ * and `SHEET` in `chance` and `reach`. Everything else (G, MADE, SPREAD) is
+ * built from those. So there are three places the error can be, and they can be
+ * ranked:
+ *
+ *   substituting into BIAS      G_pull       ratio to G_metric
+ *     WAYS   (current)          0.06235150   3.403392
+ *     SHEET                     0.20264237   1.047198   ← π/3
+ *     WAYS−1                    0.06484556   3.272492
+ *     WAYS+1                    0.06004218   3.534292
+ *
+ * `SHEET` in `BIAS` closes it from three and a half TIMES to four and a half
+ * PER CENT — and the residual is exactly π/3. That is a striking near miss and
+ * it is NOT a fix: the argument for WAYS is good (alternatives a path could
+ * have taken, not charges emitted) and 4.7% is not nought. It is recorded
+ * because a residual of exactly π/3 is either meaningless or the whole answer,
+ * and those can be told apart by finding where a π/3 would live.
+ *
+ * Keeping WAYS, the metric route's `k` would have to be `π·WAYS/SHEET = 10.21`
+ * instead of 3 — and 3 was there because a VOLUME excess is three times a
+ * linear one, which is DIMS. 10.21 is not a metric factor at all, so the
+ * discrepancy cannot be hidden in `k` without throwing away the only reason `k`
+ * had a value.
+ *
+ * AND THE WEAKEST LINK IS NOT EITHER COUNT — it is the identification itself,
+ * which should have been flagged harder when it was found. `∫_r^∞ δ ds = 3u`
+ * is a PROPOSAL. δ is a density of charges per cell, a local dimensionless
+ * occupancy, and integrating it along a radial ray gives "how many of the
+ * body's charges you meet going out from r to infinity" — a perfectly good
+ * lattice quantity that does go as 1/r. Identifying that with a VOLUME excess
+ * is a choice, and the competing reading (δ ITSELF is the local volume excess)
+ * gives 1/r² and is arguably the more natural one. The shape came out right;
+ * the reason for preferring the integral is still that it works, which is the
+ * thing this file refuses to accept everywhere else.
+ *
+ * Ranked, most likely wrong first:
+ *   1. the identification ∫δ = 3u   a choice, unargued
+ *   2. BIAS's WAYS                  argued, but sits π/3 from closing it
+ *   3. the pull's own geometry      checked hardest, least likely
+ *
+ * So: B does not come from diffusion, it may come from the radial integral,
+ * and what stands between is one wrong count or one unargued identification
+ * rather than a missing mechanism.
+ * `slowing` and `thickness` stay borrowed until it is found. The ten mechanisms
+ * under `carry` are now twelve, and the twelfth is the first that fails by a
+ * stated finite amount instead of by a shape or by sixty orders.
  */
 export const SPREAD = Math.PI * WAYS * LIGHT / (3 * BITE * SHEET);
 
@@ -1265,3 +1505,146 @@ export const SPREAD = Math.PI * WAYS * LIGHT / (3 * BITE * SHEET);
  */
 export const foldAt = (mass: number, R: number) =>
   GRAVITY * mass / (R * LIGHT * LIGHT);
+
+/**
+ * HOW FAR GRAVITY REACHES — and it is not for ever.
+ *
+ * A body's charges do not only meet the other body's. Every source in the
+ * universe is putting charges everywhere, so what any place holds is a thin
+ * fog of everyone else's — an AMBIENT FIELD, and a's charges annihilate
+ * against it on their way to b like anything else. Beyond a mean free path,
+ * none of a's charges reach b, and the pull is Yukawa:
+ *
+ *     S(a,b)  ∝  exp(−R/λ) / R²        λ = 1/(BITE·share·Φ)
+ *
+ * because the two attenuations multiply to `exp(−R/λ)` wherever along the line
+ * the meeting happens.
+ *
+ * WHAT Φ IS. A shell of the universe at r holds ρ·4πr² dr of mass and puts
+ * `m·SHEET/4πr²` on you, so it contributes `ρ·SHEET·dr` — the r² cancels and
+ * EVERY SHELL COUNTS THE SAME. That is Olbers' paradox in the same form, and
+ * the sum does not converge on its own. It converges because the fog screens
+ * itself: distant charges are attenuated by what they crossed, so
+ *
+ *     Φ = ∫ρ·SHEET·e^{−r/λ} dr = ρ·SHEET·λ,   λ = 1/kΦ
+ *     ⇒  Φ = √(ρ·SHEET/k),   λ = 1/√(k·SHEET·ρ)
+ *
+ * AND IT IS A FIXED FRACTION OF THE HORIZON. Friedmann has ρ = 3H²/8πG, and
+ * the density cancels outright:
+ *
+ *     λ/R_h = √( 8π·G / (3·BITE·share·SHEET) ) = 0.361
+ *
+ * A pure count. Gravity reaches about a third of the way to the horizon in ANY
+ * universe this model describes, whatever its density — a denser one screens
+ * harder in exactly the proportion that it expands faster. At our density that
+ * is 1.55 Gpc: nothing at all in the solar system or the Galaxy, 0.6% down
+ * across a cluster, 9.2% down at the BAO scale, and half gone by a gigaparsec.
+ *
+ * This is the one thing in the file that is a prediction in the full sense —
+ * not fitted, not borrowed, not a reproduction of something already known —
+ * and it lands on the DERIVED half of the model. If 0.361 is excluded by
+ * large-scale structure then the pull is wrong, independently of everything
+ * `carry` and `SPREAD` are still borrowing.
+ *
+ * AND IT NOW COSTS SOMETHING, which is how you tell a prediction from a
+ * decoration. This same λ is the only constant-density scattering length the
+ * lattice has, so it is also the only thing that could have set `SPREAD`'s
+ * diffusivity — and at 10⁶⁰ cells it sets it fifty-nine orders too high, which
+ * puts the surplus in the ballistic limit and kills the one account of where B
+ * might come from. `reach` and `SPREAD` cannot both stand. Keeping this one is
+ * the right call — it is counted and `SPREAD` was solved for — but it is a
+ * choice with a bill attached, and the bill is that the metric stays borrowed.
+ *
+ * AND IT IS WHY THE VACUUM CANNOT BE THE EXPANSION. Space is made when a pair
+ * gets away without meeting anything, so a vacuum making pairs at C would
+ * expand the world at H = C/3 — and would settle at Φ = √(C/k), which screens.
+ * One Φ, both jobs, and they pull opposite ways:
+ *
+ *     for H as observed        Φ = 8.4·10⁻³¹   ⇒  λ = 38 µm
+ *     for gravity at 1 AU      Φ ≲ 3·10⁻⁴⁸     ⇒  H ≲ 10⁻⁹⁶, short by 10³⁵
+ *
+ * Thirty-five orders, with nothing left to choose. The λ the expansion demands
+ * is √(l_P·R_h/3k) — the geometric mean of the Planck length and the Hubble
+ * radius, which is the dark-energy length scale that short-range experiments
+ * were built to look at. It is a pretty number and it is the scale at which
+ * gravity would DIE, not the scale at which it would start. So the vacuum
+ * makes space and cannot be what expands the universe, and this model has no
+ * cosmology.
+ */
+export const reach = (density: number) =>
+  LIGHT / Math.sqrt(BITE * 0.5 * SHEET * density);
+
+/** And what that is as a fraction of the horizon, which is where it is a count. */
+export const REACHES = Math.sqrt(
+  8 * Math.PI * G_LATTICE / (3 * BITE * 0.5 * SHEET));
+
+/**
+ * AND SO THE COSMOLOGY, which the rules fix whether or not one was wanted —
+ * and which comes out empty, four separate ways. Written down because each
+ * closure is a fact about the model rather than a failure to try.
+ *
+ * WHAT THE MODEL DOES SAY. Matter makes space (`MADE`), meetings unmake it
+ * (`BITE`), so the net is what escapes without meeting anything. That is a
+ * real expansion and it compounds — new points can split too, so H is constant
+ * and the growth is exponential. de Sitter, for free.
+ *
+ * AND WHAT IT CANNOT. Ask it for the observed H and it fails five times over:
+ *
+ *  1. SCREENING. The pairs that make the space ARE the fog that stops the
+ *     gravity — one Φ doing both jobs, wanting opposite values. For H as
+ *     observed, Φ = 8·10⁻³¹ and λ = 38 µm; for gravity at 1 AU, Φ ≲ 2·10⁻⁴⁶
+ *     and H ≲ 10⁻⁹⁶. Thirty-five orders apart with nothing left to choose.
+ *
+ *  2. THE ATTRACTOR. Take the cascade seriously — creation, annihilation and
+ *     the expansion's own dilution together — and the charge density is not
+ *     free at all. `2C − 2kΦ² − 3HΦ = 0` with `3H = C − kΦ²` gives
+ *     `(C − kΦ²)(2 − Φ) = 0`: either nothing expands, or Φ = 2 EXACTLY, at any
+ *     rate, in any such universe. And Φ = 2 puts λ at ONE lattice step.
+ *
+ *  3. MATTER IS TOO THIN TO GATE IT. The obvious escape is that bound regions
+ *     do not expand, so the fog is only in the voids. But C is one number and
+ *     it is what empty space does, and there is empty space between the Earth
+ *     and the Sun. For matter to suppress it, `chance` at a body would have to
+ *     approach one; with the volume properly integrated (`ρ·SHEET·R`, not a
+ *     point — worth a factor of three) it is 1.5·10⁻⁴⁸ inside the Sun and
+ *     8·10⁻³⁹ inside a neutron star. The gap is the mass hierarchy, not the
+ *     geometry: a proton is 10⁻¹⁹ of a Planck mass and mass IS the pulse rate,
+ *     so its field is 10⁻¹⁸ even one step away.
+ *
+ *  4. THE CLOCK. The expanding steady state needs C = 2 pairs a cell a tick,
+ *     and once a tick is the ceiling (see `mass` in `physics.ts`). It asks
+ *     empty space to pulse twice as fast as the lattice permits. Not a
+ *     shortfall — a contradiction.
+ *
+ *  5. AND A FIFTH, WHICH THE BALLISTIC RESULT OPENED. All four above are about
+ *     the VACUUM making pairs. There is a route that needs no vacuum at all,
+ *     and it had not been checked: a body's charges that cross the horizon
+ *     never meet anything, so they never give their point back (see `BITE`) —
+ *     a net creation sourced by MATTER, immune to (1) because it needs no Φ,
+ *     and not capped by (4) because it is a fraction of an emission rather
+ *     than a rate. The escaping fraction is not small:
+ *
+ *         e^(−R_h/λ) = e^(−1/REACHES) = 0.0628
+ *
+ *     Six per cent of everything emitted leaves for good. What that expands:
+ *
+ *         ρ = 8.6·10⁻²⁷ kg/m³   →  2.68·10⁻¹²² mass units a cell
+ *         emission                 2.14·10⁻¹²¹ charges a cell a tick
+ *         net creation             1.35·10⁻¹²² points a cell a tick
+ *         H = (dV/V)/3             8.3·10⁻⁸⁰ /s,  against 2.19·10⁻¹⁸
+ *
+ *     Sixty-one orders short, and it would want 2·10³⁵ kg/m³ — 10⁶¹ times the
+ *     matter there is — to close. It fails on the plainest thing available:
+ *     there is not enough matter.
+ *
+ * AND THE SIGN OF ALL FIVE IS THE SAME, which is the thing worth noticing. The
+ * usual embarrassment is a vacuum energy 10¹²⁰ too LARGE. Every mechanism this
+ * lattice has runs the other way — 35 orders short on the vacuum route, 61 on
+ * the matter route — so the model does not have the cosmological constant
+ * problem, it has its mirror image. A model that cannot make the universe
+ * expand at all is wrong in a way that can be stated and looked for.
+ *
+ * So: no expansion, no dark energy, no thermal history, and — since ± pairs
+ * are made in exact pairs — no matter/antimatter asymmetry either. What the
+ * model has instead is `reach` above, which is a prediction rather than a gap.
+ */
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index c5f31b3..bf37058 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -614,6 +614,468 @@ const MADE_FROM: Derivation = {
       a vacuum dense enough to carry anything is dense enough to switch gravity
       off within about seven steps.
     </Step>
+
+    <Because>and that constraint turned out to be the one that closes it — the other way</Because>
+    <Step eq={<>
+      <V>D</V> = <V>cλ</V>/3
+      <span style={{ padding: '0 1.2em', color: FAINT }}>needs 10.2 cells</span>
+      <V>λ</V> = <K>REACHES</K>·<V>R</V><Sub>h</Sub>
+      <span style={{ padding: '0 1.2em', color: FAINT }}>is 2.9·10<Sup>60</Sup></span>
+    </>}>
+      The same number written as a diffusivity is <V>D</V> = <V>c</V>/<V>ε</V> =
+      3.403, and a diffusivity <i>is not free</i>: for anything moving at{' '}
+      <V>c</V> it is <V>cλ</V>/3. So the account is only as good as the{' '}
+      <V>λ</V> the lattice can supply — and the only constant-density scatterer
+      here is the vacuum, whose length the panel below already computes.{' '}
+      <b style={{ color: INK }}>They disagree by fifty-nine orders of
+        magnitude.</b> Sourcing the scattering from the body’s own field
+      instead does not save it: chance ∝ 1/<V>r</V><Sup>2</Sup> makes{' '}
+      <V>λ</V> ∝ <V>r</V><Sup>2</Sup> and the profile comes out
+      1/<V>r</V><Sup>3</Sup>.
+    </Step>
+
+    <Because>which puts the surplus in the ballistic limit — measured</Because>
+    <Step eq={<span style={{ fontFamily: 'ui-monospace, Menlo, monospace', fontSize: '0.8em' }}>
+      λ=10.2 → 1/r ✓&nbsp;&nbsp;&nbsp;λ=10³ → 1/r²&nbsp;&nbsp;&nbsp;λ=10⁶ → 1/r²
+    </span>}>
+      Point source, charges streaming at <V>c</V>, exponential free path,
+      tallying path per shell. At <V>λ</V> = 10.2 the profile is 1/<V>r</V> at
+      exactly the assumed coefficient — ratio 0.989 in the window{' '}
+      <V>λ</V> ≪ <V>r</V> ≪ <V>R</V> — so the <i>mechanism</i> is sound. At{' '}
+      <V>λ</V> ≫ <V>r</V> it is 1/<V>r</V><Sup>2</Sup>, equal to{' '}
+      <V>S</V>/4π<V>c</V> to 0.6%. And{' '}
+      <b style={{ color: INK }}><V>δ</V> ∝ 1/<V>r</V><Sup>2</Sup> is not a
+        potential</b> — it does not give Newton, never mind the metric.
+    </Step>
+
+    <Because>so the honest statement changed</Because>
+    <Step>
+      It was <i>the coefficient is unfound</i>. It is now: <V>ε</V> and the
+      reach are the same vacuum read twice, and they demand lengths fifty-nine
+      orders apart, so <b style={{ color: INK }}>they cannot both be right</b>.
+      Drop the reach and <V>λ</V> is free, but 0.361 is the one full prediction
+      here and it goes with it. Keep it and diffusion cannot be where the metric
+      comes from.{' '}
+      <b style={{ color: INK }}>Keep it</b>: it is counted and <V>ε</V> was
+      solved for, and a derived number outranks a fitted one.
+    </Step>
+
+    <Because>and spending it that way pays, which was not expected</Because>
+    <Step eq={<>∫<Sub><V>r</V></Sub><Sup>∞</Sup> d<V>s</V>/<V>s</V><Sup>2</Sup> = 1/<V>r</V></>}>
+      Killing diffusion does not kill the point source, because there is a way
+      to get 1/<V>r</V> from a 1/<V>r</V><Sup>2</Sup> density that needs no
+      transport at all and had not been tried:{' '}
+      <b style={{ color: INK }}>integrate it radially</b>. One integration,
+      nothing free. Measured with <V>δ</V> = chance/<V>c</V>, it lands on{' '}
+      <V>m</V>·<K>SHEET</K>/(4π<V>rc</V>) to six figures. And it is not
+      “read <V>u</V> off the force” — <V>δ</V> goes as <V>m</V><Sub>b</Sub>{' '}
+      alone where the pull goes as <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub>, so
+      it is a fact about a <i>place</i>, which was the whole objection.
+    </Step>
+
+    <Because>so it predicts G rather than absorbing it — and gets it wrong, precisely</Because>
+    <Step eq={<>
+      <Frac over={<><K>SHEET</K>·<V>c</V>/12π</>}
+        under={<><K>SHEET</K><Sup>2</Sup>/4π<Sup>2</Sup><K>WAYS</K></>} /> =
+      <Frac over={<>π<K>WAYS</K></>} under={<>3<K>SHEET</K></>} /> = 3.4034
+    </>}>
+      Predicted <V>G</V> = 0.21221, the pull’s <V>G</V> = 0.06235, ratio
+      3.403392 — and <b style={{ color: INK }}>that is <V>ε</V>’s own number,
+        to every digit</b>. Which says what it always was: not a diffusivity,
+      but the factor by which the metric route’s <V>G</V> exceeds the pull
+      route’s, wearing the name of a mechanism it does not have.
+    </Step>
+
+    <Because>which is a far better place to be stuck</Because>
+    <Step eq={<span style={{ fontFamily: 'ui-monospace, Menlo, monospace', fontSize: '0.8em' }}>
+      d=2 4.000&nbsp;&nbsp;d=3 3.250&nbsp;&nbsp;d=4 3.077&nbsp;&nbsp;d=5 3.025&nbsp;&nbsp;(want 3/π = 0.955)
+    </span>}>
+      Two routes, both counted, neither with a free parameter, disagreeing by a{' '}
+      <i>pure count</i> — so it is a statement about the lattice’s geometry and
+      nothing else, and the search is finite. The fix is not a coefficient and
+      not a dimension: they agree iff <K>WAYS</K>/<K>SHEET</K> = 3/π, which is
+      irrational, while <K>WAYS</K>/<K>SHEET</K> is a ratio of integers tending
+      to 3 from above.{' '}
+      <b style={{ color: INK }}>So one of the two counts is being used for a job
+        it is not the count for</b> — and they are not even the same kind of
+      thing, <K>SHEET</K> being what a source emits and <K>WAYS</K> what a path
+      could have done instead. That is the same mistake this file already made
+      once, and recorded.
+    </Step>
+  </>,
+};
+
+const REACH: Derivation = {
+  label: 'how far gravity reaches',
+  title: <>the ambient field, and the end of the pull</>,
+  body: <>
+    <Because>every source is putting charges everywhere</Because>
+    <Step eq={<>
+      <V>Φ</V> = ∫ <V>ρ</V>·<K>SHEET</K> d<V>r</V>
+    </>}>
+      A shell of the universe at <V>r</V> holds <V>ρ</V>·4π<V>r</V><Sup>2</Sup>d<V>r</V>{' '}
+      of mass and puts <V>m</V><K>SHEET</K>/4π<V>r</V><Sup>2</Sup> on you — so it
+      contributes <V>ρ</V><K>SHEET</K>d<V>r</V> and{' '}
+      <b style={{ color: INK }}>every shell counts the same</b>. That is Olbers’
+      paradox in the same form, and the sum does not converge.
+    </Step>
+
+    <Because>it converges because it screens itself</Because>
+    <Step eq={<>
+      <V>Φ</V> = <V>ρ</V><K>SHEET</K><V>λ</V>,&nbsp;&nbsp;
+      <V>λ</V> = 1/<V>k</V><V>Φ</V>
+      &nbsp;&nbsp;⇒&nbsp;&nbsp;
+      <V>λ</V> = 1/√(<V>k</V>·<K>SHEET</K>·<V>ρ</V>)
+    </>}>
+      Those distant charges were attenuated by the fog they crossed. Solving
+      the two together is what makes the integral finite —{' '}
+      <V>k</V> = <K>BITE</K>·share.
+    </Step>
+
+    <Because>and a body’s own charges are attenuated too</Because>
+    <Step eq={<>
+      <V>S</V>(<V>a</V>,<V>b</V>) ∝
+      <Frac over={<>e<Sup>−<V>R</V>/<V>λ</V></Sup></>}
+        under={<><V>R</V><Sup>2</Sup></>} />
+    </>}>
+      The two attenuations multiply to e<Sup>−<V>R</V>/<V>λ</V></Sup> wherever
+      along the line the meeting happens. So the pull is{' '}
+      <b style={{ color: INK }}>Yukawa</b>, and gravity has a range.
+    </Step>
+
+    <Because>which is a fixed fraction of the horizon</Because>
+    <Step eq={<>
+      <Frac over={<V>λ</V>} under={<><V>R</V><Sub>h</Sub></>} /> =
+      √<Paren><Frac over={<>8<V>π G</V></>}
+        under={<>3 <K>BITE</K>·share·<K>SHEET</K></>} /></Paren> = 0.361
+    </>}>
+      Friedmann has <V>ρ</V> = 3<V>H</V><Sup>2</Sup>/8π<V>G</V>, and the
+      density <i>cancels</i>. Gravity reaches about a third of the way to the
+      horizon in <b style={{ color: INK }}>any</b> universe this model
+      describes — a denser one screens harder in exactly the proportion that it
+      expands faster. At our density, 1.55 Gpc.
+    </Step>
+
+    <Because>what that looks like</Because>
+    <Step>
+      Nothing at all in the solar system or the Galaxy. 0.6% down across a
+      cluster, <b style={{ color: INK }}>9.2% down at the BAO scale</b>, half
+      gone by a gigaparsec. This is the one thing here that is a prediction in
+      the full sense — not fitted, not borrowed, not a reproduction — and it
+      sits on the <i>derived</i> half of the model. If 0.361 is excluded by
+      large-scale structure then the pull is wrong, independently of everything{' '}
+      <i>carry</i> and <V>D</V> are still borrowing.
+    </Step>
+  </>,
+};
+
+const IDENTICAL: Derivation = {
+  label: 'gravity between identical things',
+  title: <>two of the same, closer than a wavelength</>,
+  body: <>
+    <Because>ω is not free any more</Because>
+    <Step eq={<><V>ω</V> = <V>m</V>,&nbsp;&nbsp; one wavelength = 2π/<V>m</V> = 2π<V>G</V><V>λ</V><Sub>C</Sub></>}>
+      Mass is how often a thing pulses, so the rate at which its charge
+      reverses is the mass. It used to be set by <K>SLOW</K> in{' '}
+      <i>models.ts</i> — a drawing choice — and spread 3.7% a body so that no
+      two ever matched. That spread was standing in for a fact.
+    </Step>
+
+    <Because>a body made of things has no phase</Because>
+    <Step eq={<>⟨|<V>ψ</V>|/π⟩ = ½&nbsp;&nbsp; over uniform <V>ψ</V></>}>
+      Nothing elementary weighs more than <V>G</V>·<V>m</V><Sub>Planck</Sub> ≈
+      1.36 µg, and the Sun is 1.2·10<Sup>57</Sup> nucleons. A sum of that many
+      emitters with no reason to agree has a uniform phase, and the average of{' '}
+      <i>opposed</i> over uniform phase is exactly a half.{' '}
+      <b style={{ color: INK }}>So share = ½ is derived, not arranged</b> — it
+      is what being made of things does.
+    </Step>
+
+    <Because>but two of the SAME thing do share a phase</Because>
+    <Step eq={<>
+      <V>G</V><Sub>eff</Sub>/<V>G</V> = 2·share
+    </>}>
+      Same mass, same ω, so they hold a fixed relation for as long as they
+      exist and <i>coherence</i> walks instead of returning a half. Measured
+      from it directly:
+    </Step>
+
+    <Step eq={<>
+      <span style={{ fontFamily: 'monospace', fontSize: '0.82em', whiteSpace: 'pre' }}>
+        {`R/λ        0.02   0.10   0.20   0.50   1.00   ≥1.5
+in step    0.02   0.12   0.24   0.59   1.00   1.00
+half out   1.98   1.88   1.76   1.41   1.00   1.00`}
+      </span>
+    </>}>
+      <b style={{ color: INK }}>In step and close together there is no gravity
+        between them at all.</b> They put out the same sign at the same moment,
+      so nothing cancels, so nothing is annihilated, so the interval between
+      them does not shorten. Out of step, every meeting cancels and the pull is
+      doubled. Beyond one wavelength both settle to the ordinary law.
+    </Step>
+
+    <Because>so</Because>
+    <Step>
+      Between two of the same elementary thing, <V>G</V> runs anywhere from
+      nought to 2<V>G</V> over the first Compton wavelength, and which one
+      depends on their relative phase. Inside <V>λ</V><Sub>C</Sub> that is not
+      a correction to gravity — it is a different interaction, and one that
+      already knows about phase. None of it was added: <i>coherence</i>,{' '}
+      <i>opposed</i> and ω have been here since the pull was written. Telling
+      ω that it is the mass is what turned them into this.
+    </Step>
+  </>,
+};
+
+const CLOCK: Derivation = {
+  label: 'mass as a period',
+  title: <>once a tick is the ceiling</>,
+  body: <>
+    <Because>mass is how often, so turn it round</Because>
+    <Step eq={<><V>X</V> = 1/<V>m</V> ticks between pulses,&nbsp;&nbsp;<V>m</V> ≤ 1</>}>
+      A heavier thing pulses more often, and nothing pulses more than once a
+      tick. So mass is a <i>period</i>, and there is a largest elementary
+      mass: the lattice mass unit is <V>G</V>·<V>m</V><Sub>Planck</Sub> ≈
+      1.36 µg. Anything heavier has to be many emitters — which is what matter
+      is.
+    </Step>
+
+    <Because>turn the period into a length</Because>
+    <Step eq={<>
+      <V>X</V>·<V>c</V> = <V>G</V> ·
+      <Frac over={<>ħ</>} under={<><V>mc</V></>} /> = <V>G</V> · <V>λ</V><Sub>Compton</Sub>
+    </>}>
+      Exactly, at every mass. Measured across twenty orders — electron, proton,
+      uranium atom, virus, grain of sand — the ratio is 0.062329 every time,
+      against <V>G</V> = 0.062351.
+    </Step>
+
+    <Because>and it is not a coincidence</Because>
+    <Step>
+      <V>m</V><Sub>P</Sub>·<V>l</V><Sub>P</Sub> = ħ/<V>c</V>, so “period = 1/mass”
+      in the lattice’s own units <i>is</i> the Compton relation.{' '}
+      <b style={{ color: INK }}>The identity was put here to make the
+        equivalence principle fall out of counting, and it turns out to have
+        been a quantum statement the whole time.</b> The lattice is not a
+      classical model waiting to have quantum mechanics added — <V>E</V> = ħω
+      is a consequence of what it already means by mass.
+    </Step>
+  </>,
+};
+
+const IGNORANCE: Derivation = {
+  label: 'de Broglie from not knowing where',
+  title: <>λ = <V>h</V>/<V>p</V> as the price of not knowing which side you are on</>,
+  body: <>
+    <Because>a moving source has two retarded branches, and one of them is yours</Because>
+    <Step eq={<>
+      <V>t</V><Sub>r</Sub> = <Frac over={<><V>t</V> − <V>x</V>/<V>c</V></>} under={<>1 − <V>β</V></>} />
+      <span style={{ padding: '0 1.2em', color: FAINT }}>ahead</span>
+      <V>t</V><Sub>r</Sub> = <Frac over={<><V>t</V> + <V>x</V>/<V>c</V></>} under={<>1 + <V>β</V></>} />
+      <span style={{ padding: '0 1.2em', color: FAINT }}>behind</span>
+    </>}>
+      A source pulses at its own rate ω, which <i>is</i> its mass, and a place
+      carries the phase the source had when the shell left. Moving, that has
+      two branches — blue ahead, red behind — and exactly one is true of you.
+      Nothing is superposed: a point receives one shell, from one side, at a
+      time. Solve the retarded equation at any x and only one branch ever comes
+      back consistent.
+    </Step>
+
+    <Because>so weight them by how likely you are to be on each side</Because>
+    <Step eq={<>
+      <V>φ</V> = <V>ω</V><V>γ</V>[ (1 − <V>β</V> + 2<V>pβ</V>)<V>t</V> +
+      (1 − <V>β</V> − 2<V>p</V>)<V>x</V>/<V>c</V> ]
+    </>}>
+      Know how fast the thing is going but not <i>where</i>, and you do not
+      know which branch applies. Weight them <V>p</V> and 1 − <V>p</V> — that
+      is <i>expected</i> in <i>field.ts</i>, and <V>p</V> is a parameter, not a
+      constant, so the ignorance is tunable.
+    </Step>
+
+    <Because>and at a half it is de Broglie, exactly</Because>
+    <Step eq={<>
+      <V>φ</V> = <V>ω</V><V>γ</V>(<V>t</V> − <V>vx</V>/<V>c</V><Sup>2</Sup>)
+      <span style={{ padding: '0 1.2em', color: FAINT }}>at <V>p</V> = ½</span>
+      <V>λ</V> = <V>λ</V><Sub>C</Sub>/<V>γβ</V> = <V>h</V>/<V>p</V>
+    </>}>
+      Measured to nine figures at every β and every x. The phase speed is{' '}
+      <V>c</V><Sup>2</Sup>/<V>v</V>, which is de Broglie’s and is allowed to
+      beat light because it carries nothing. And the half-<i>difference</i> is{' '}
+      <V>ω</V><V>γ</V>(<V>βt</V> − <V>x</V>/<V>c</V>) — the Compton
+      oscillation at <V>λ</V><Sub>C</Sub>/<V>γ</V>, with its zero at{' '}
+      <V>x</V> = <V>vt</V>, travelling <i>with</i> the thing.{' '}
+      <b style={{ color: INK }}>The mean is the wave and the difference is the
+        particle.</b>
+    </Step>
+
+    <Because>the half is doing real work — this is a test, not a detail</Because>
+    <Step eq={<>
+      <V>k</V> = <V>ω</V><V>γ</V>(2<V>p</V> − 1 + <V>β</V>)/<V>c</V>
+    </>}>
+      At <V>p</V> = 0.4 or 0.6 the wavelength is 20–40% off <V>h</V>/<V>p</V>.
+      At <V>p</V> = (1 − <V>β</V>)/2 the wavenumber is <i>zero</i> — no x in
+      the phase at all, a bare oscillation with no wavelength — and past that
+      it changes sign and the wave runs backwards. So this is not a dial with
+      de Broglie somewhere on it: there is a zero, a sign change, and one point
+      that gives <V>h</V>/<V>p</V>.
+    </Step>
+
+    <Because>and a half is what it has to be, for a reason that is not about radiation</Because>
+    <Step>
+      Relativistic beaming puts (1+<V>β</V>)/2 of a moving source’s output into
+      the forward hemisphere, which would give exactly <i>half</i> the de
+      Broglie wavelength — measured, at every β. But beaming is the wrong
+      quantity.{' '}
+      <b style={{ color: INK }}>What is weighted is not how much goes each way,
+        it is how likely you are to be on one side rather than the other</b> —
+      a fact about not knowing the source’s <i>position</i>, not about its
+      radiation pattern. A position you know nothing about is equally likely
+      either side of you.
+    </Step>
+
+    <Because>and it is the fields that average, not just the phases</Because>
+    <Step eq={<>
+      ½(cos <V>φ</V><Sub>A</Sub> + cos <V>φ</V><Sub>B</Sub>) =
+      cos <V>φ</V><Sub>dB</Sub> · cos <V>φ</V><Sub>C</Sub>
+    </>}>
+      An identity, to 6·10<Sup>−15</Sup> — so nothing had to be chosen about{' '}
+      <i>which object</i> to average, and the de Broglie wave comes out as a
+      factor of the mean field rather than as an interpretation of it. Off a
+      half it stops factorising at all.{' '}
+      <b style={{ color: INK }}>One number puts the wavelength at <V>h</V>/<V>p</V>{' '}
+        and makes the field split into de Broglie times Compton — the same
+        number, both jobs.</b>
+    </Step>
+
+    <Because>so does the lattice itself average? — three tries</Because>
+    <Step eq={<span style={{ fontFamily: 'ui-monospace, Menlo, monospace', fontSize: '0.8em' }}>
+      scatter → phase speed c, not c²/v
+    </span>}>
+      <b>Scatter</b> turns the backward emission round, so the red phase does
+      reach a point that is ahead — but it then travels <i>+x</i>, so its{' '}
+      <V>k</V> adds where the behind-branch’s subtracts. Mean{' '}
+      <V>k</V> = <V>ω</V><Sub>0</Sub><V>γ</V>/<V>c</V>, phase speed exactly{' '}
+      <V>c</V>. A light wave, not de Broglie. To get <V>k</V><Sub>B</Sub> the
+      red phase must <i>arrive from ahead</i>, which needs the backward
+      emission to have overtaken the source.
+    </Step>
+
+    <Step eq={<>
+      <V>φ</V><Sub>i</Sub> = <V>ω</V><Sub>0</Sub>(<V>t</V>/<V>γ</V> −
+      <V>vξ</V><Sub>i</Sub>/<V>c</V><Sup>2</Sup>)
+    </>}>
+      <b>A composite source</b> is the promising one, because a body above
+      1.36 µg is many emitters and a receiver really <i>is</i> ahead of some and
+      behind others — a physical average, not an epistemic one. Which pushes
+      the question to what sets the constituents’ phases, and there it is sharp:
+      measured as the phase gradient across the body,{' '}
+      <b style={{ color: INK }}>in step in the body’s frame gives{' '}
+        <V>k</V> = 5.7735·10<Sup>−3</Sup>, exactly λ<Sub>dB</Sub>; in step in
+        the lattice’s frame gives <V>k</V> = 0 and no wave at all.</b>
+    </Step>
+
+    <Because>so the obstruction is one specific thing: the global tick</Because>
+    <Step>
+      <V>ω</V><V>γ</V>(<V>t</V> − <V>vx</V>/<V>c</V><Sup>2</Sup>) is{' '}
+      <V>ω</V> times the source’s proper time at the event simultaneous with{' '}
+      (<V>t</V>,<V>x</V>) <i>in its own rest frame</i>. Averaging the branches
+      reconstructs rest-frame simultaneity; rest-frame synchrony assumes it.
+      They agree to every digit because they are one statement — and{' '}
+      <i>tick()</i> advancing everything at once is exactly its denial.{' '}
+      <b style={{ color: INK }}>For de Broglie to be derived, a composite body
+        must be in step with itself in its own frame</b> — a per-body
+      simultaneity, not a global one. That is a statement about what the update
+      rule would have to be, and it can be tried. It is also uncomfortable,
+      because the global tick is most of how this model stays simple.
+    </Step>
+
+    <Because>so make it a dial rather than a choice</Because>
+    <Step eq={<>
+      ahead = (1 − <V>β</V>(1 − sync))/2
+      <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+      <V>k</V> = sync · <V>ωγβ</V>/<V>c</V>
+    </>}>
+      The two conventions are not two models — they are two values of the same
+      weight, and everything between them is defined.{' '}
+      <b style={{ color: INK }}>sync = 0 is the global tick and has no matter
+        wave at all; sync = 1 is de Broglie</b>, and <V>k</V> is exactly linear
+      in between with nothing discontinuous. So the model can be <i>asked</i>{' '}
+      for the other theory instead of having to pick one — <i>relax</i>,{' '}
+      <i>synced</i> and <i>wave</i> in <i>field.ts</i>.
+    </Step>
+
+    <Because>and the dial is the classical limit</Because>
+    <Step>
+      <i>sync</i> is how much of a body is in step with <i>itself</i> in its{' '}
+      <i>own</i> frame. A lone elementary emitter is trivially in step with
+      itself, so sync = 1 and it carries a full de Broglie wave; a body of
+      10<Sup>57</Sup> emitters updated by one global tick is in step in the{' '}
+      <i>lattice’s</i> frame, so its internal gradient is nought and sync → 0.{' '}
+      <b style={{ color: INK }}>Small things are quantum and big things are
+        not, and it falls out rather than being imposed.</b> A conjecture, and
+      a testable one: it says λ = λ<Sub>dB</Sub>/sync should degrade with
+      internal temperature and not only with mass. What sets sync from the
+      constituent count is not derived — the dial exists so the question can be
+      asked with numbers.
+    </Step>
+
+    <Because>and at sync = 1 the phase is the action, which is the whole point</Because>
+    <Step eq={<>
+      <V>φ</V> = <V>ωγ</V>(<V>t</V> − <V>vx</V>/<V>c</V><Sup>2</Sup>) =
+      −(<b>p</b>·<b>x</b> − <V>Et</V>)/ħ
+    </>}>
+      To nine figures at every <V>β</V>, and along the worldline{' '}
+      <V>x</V> = <V>vt</V> it collapses to <V>ω</V><V>τ</V> = −<V>mc</V><Sup>2</Sup>∫d<V>τ</V>/ħ,
+      the relativistic free action.{' '}
+      <b style={{ color: INK }}>Nothing put it there</b> — it is what{' '}
+      mass = rate plus rest-frame simultaneity comes to.
+    </Step>
+
+    <Because>which makes ignorance of WHICH PATH the right next move</Because>
+    <Step eq={<>Σ<Sub>paths</Sub> e<Sup>i<V>φ</V></Sup> = ∫𝒟<V>x</V> e<Sup>i<V>S</V>/ħ</Sup></>}>
+      The two-slit test put openings and a screen in by hand, so what came out
+      depended on the arrangement — and the arrangement is not the physics. Sum
+      over <i>all</i> paths from A to B instead. Measured on the free
+      propagator, arg(amplitude) − <V>k·X</V> converges to{' '}
+      <b style={{ color: INK }}>0.7862, 0.7845, 0.7837 against π/4 = 0.7854</b>,
+      with the amplitude going as √<V>X</V> — ratios 1.4141 and 1.4142 against
+      √2. So the sum gives the straight-line action <i>plus</i> the Fresnel
+      phase the free propagator is known to carry: stationary phase picks the
+      classical path out of the ignorance, with nothing selecting it and no
+      screen anywhere. Two slits are then a corollary, for any geometry.
+    </Step>
+
+    <Because>and the one thing still assumed — tried, and it fails</Because>
+    <Step eq={<span style={{ fontFamily: 'ui-monospace, Menlo, monospace', fontSize: '0.8em' }}>
+      k_eff = 0.016&nbsp;&nbsp;against&nbsp;&nbsp;k = 0.30
+    </span>}>
+      <b style={{ color: INK }}>Every path gets the same modulus.</b> Feynman
+      postulates it, and <K>WAYS</K> looked like the answer: every way out of a
+      point equally available, one step a tick so path length ∝ time, hence all
+      equal-time paths equally likely. Summed over every 8-neighbour path of 130
+      steps, the phase does <i>not</i> track <V>k·x</V> — fitted
+      <V>k</V><Sub>eff</Sub> is 5% of <V>k</V> — and |A| falls twenty-two orders
+      across the span. Not a wave: the large-deviation tail of a random walk.
+    </Step>
+
+    <Because>and the diagnosis is the same mistake as the audit found</Because>
+    <Step>
+      Every charge here moves at exactly <V>c</V>, so every step is{' '}
+      <i>lightlike</i> and every path has the same proper time — nought. A
+      massive particle’s phase is −<V>mc</V><Sup>2</Sup>∫d<V>τ</V>/ħ, which
+      along a lightlike path is nought too.{' '}
+      <b style={{ color: INK }}>A charge’s path is not a particle’s path</b>,
+      and <K>WAYS</K> counts a charge’s options; the path integral needs the
+      worldlines of the <i>emitter</i>, which moves at <V>v</V> &lt; <V>c</V>.
+      Two independent things now point at one structural gap — the lattice has
+      one kind of mover, and both quantum mechanics and the metric want
+      statements about the other kind. So the ladder reads: mass = rate gives <V>E</V> = ħω; rest-frame
+      simultaneity gives λ = <V>h</V>/<V>p</V> and makes the phase the action;
+      ignorance over paths gives the propagator. Two things are owed — what
+      sets sync, and why the modulus is flat — and the second now has a shape:
+      it needs the emitter’s options counted, not the charge’s.
+    </Step>
   </>,
 };
 
@@ -1141,6 +1603,224 @@ export const Law = () => {
       is derived.
     </Note>
 
+    <Head>how far it reaches</Head>
+
+    <Note>
+      Every source is putting charges everywhere, so what any place holds is a
+      thin fog of everyone else’s — and a body’s charges annihilate against
+      that fog on the way to wherever they were going. Beyond a mean free path
+      none of them arrive.
+    </Note>
+
+    <Eq derive={REACH} open={show}
+      note="the pull is Yukawa, and its range is a fixed fraction of the horizon">
+      <V>S</V>(<V>a</V>,<V>b</V>) ∝
+      <Frac over={<>e<Sup>−<V>R</V>/<V>λ</V></Sup></>}
+        under={<><V>R</V><Sup>2</Sup></>} />
+      <span style={{ padding: '0 1.6em' }} />
+      <Frac over={<V>λ</V>} under={<><V>R</V><Sub>h</Sub></>} /> =
+      √<Paren><Frac over={<>8<V>π G</V></>}
+        under={<>3 <K>BITE</K>·share·<K>SHEET</K></>} /></Paren> = 0.361
+    </Eq>
+
+    <Note>
+      The density cancels, so it is the same fraction in any universe this
+      model describes. At ours, 1.55 Gpc: invisible in the solar system and the
+      Galaxy, 0.6% down across a cluster,{' '}
+      <b style={{ color: INK }}>9.2% down at the BAO scale</b>, half gone by a
+      gigaparsec. <b style={{ color: INK }}>This is the one prediction on the
+        page</b> — nothing fitted and nothing borrowed — and it lands on the
+      derived half of the model, so large-scale structure can falsify the pull
+      without touching anything <V>B</V> is still assuming.
+    </Note>
+
+    <Note>
+      And it <b style={{ color: INK }}>costs something</b>, which is how you
+      tell a prediction from a decoration. This <V>λ</V> is the only
+      constant-density scattering length the lattice has, so it is also the
+      only thing that could have set the diffusivity behind <V>ε</V> — and at
+      10<Sup>60</Sup> cells it sets it fifty-nine orders too high, which puts
+      the surplus in the ballistic limit and kills the one account of where{' '}
+      <V>B</V> might have come from.{' '}
+      <b style={{ color: INK }}>The reach and <V>ε</V> cannot both stand.</b>{' '}
+      Keeping this one is right — it is counted, <V>ε</V> was solved for — but
+      it is a choice with a bill, and the bill is that the metric stays
+      borrowed. So the answer to <i>can the last assumption be removed</i> is
+      no, and now for a stated reason rather than for want of trying.
+    </Note>
+
+    <Note>
+      The audit that followed found <K>WAYS</K> enters the dynamics in exactly
+      one place — <K>BIAS</K>. Putting <K>SHEET</K> there instead closes the gap
+      from three and a half <i>times</i> to{' '}
+      <b style={{ color: INK }}>π/3, four and a half per cent</b> — a striking
+      near miss, and not a fix, since the argument for <K>WAYS</K> is good and
+      4.7% is not nought. Keeping <K>WAYS</K>, the metric route’s 3 would have
+      to be 10.21, and the 3 was there because a volume excess is three times a
+      linear one. So the likeliest error is neither count but{' '}
+      <b style={{ color: INK }}>the identification ∫<V>δ</V> = 3<V>u</V>{' '}
+        itself</b> — a choice, and one this page came close to calling a
+      derivation.
+    </Note>
+
+    <Head>and what mass turns out to be</Head>
+
+    <Eq derive={CLOCK} open={show}
+      note="a heavier thing pulses more often, and nothing pulses more than once a tick">
+      <V>X</V> = 1/<V>m</V>
+      <span style={{ padding: '0 1.4em', color: FAINT }}>ticks between pulses</span>
+      <V>X</V>·<V>c</V> = <V>G</V> · <V>λ</V><Sub>Compton</Sub>
+    </Eq>
+
+    <Eq derive={IDENTICAL} open={show}
+      note="two of the same thing, closer than a wavelength — no gravity in step, double out of it">
+      <Frac over={<><V>G</V><Sub>eff</Sub></>} under={<V>G</V>} /> = 2·share
+      <span style={{ padding: '0 1.4em', color: FAINT }}>0 … 2</span>
+      within&nbsp; 2π<V>G</V><V>λ</V><Sub>C</Sub>
+    </Eq>
+
+    <Note>
+      And once ω is the mass, <i>coherence</i> stops being bookkeeping.{' '}
+      <b style={{ color: INK }}>share = ½ becomes derived</b> — a body of
+      10<Sup>57</Sup> emitters has uniform phase, and ⟨|<V>ψ</V>|/π⟩ = ½ — so
+      the 3.7% spread of rates in <i>models.ts</i> was standing in for being
+      made of things. But two of the <i>same</i> elementary thing do hold a
+      phase, and then <V>G</V> runs from nought (in step: same sign at the same
+      moment, nothing cancels, no pull at all) to 2<V>G</V> (out of step:
+      everything cancels), settling to the ordinary law beyond one Compton
+      wavelength.
+    </Note>
+
+    <Eq derive={IGNORANCE} open={show}
+      note="know how fast it is going but not where, and what you are holding is a de Broglie wave">
+      <V>λ</V> = <Frac over={<><V>λ</V><Sub>C</Sub></>} under={<><V>γβ</V></>} /> =
+      <Frac over={<V>h</V>} under={<V>p</V>} />
+      <span style={{ padding: '0 1.4em', color: FAINT }}>at ignorance = ½</span>
+      <V>v</V><Sub>phase</Sub> = <V>c</V><Sup>2</Sup>/<V>v</V>
+    </Eq>
+
+    <Note>
+      A moving source has two retarded branches and exactly one of them is
+      yours. Weight them by how likely you are to be ahead rather than behind —{' '}
+      <i>expected</i> in <i>field.ts</i> takes that weight as a parameter — and
+      at a half the expected phase is <V>ω</V><V>γ</V>(<V>t</V> − <V>vx</V>/
+      <V>c</V><Sup>2</Sup>) to nine figures, which is de Broglie’s wave, while
+      the half-<i>difference</i> is the Compton oscillation contracted and
+      travelling with the thing.{' '}
+      <b style={{ color: INK }}>The mean is the wave, the difference is the
+        particle</b> — and ½(cos <V>φ</V><Sub>A</Sub> + cos <V>φ</V><Sub>B</Sub>)
+      = cos <V>φ</V><Sub>dB</Sub>·cos <V>φ</V><Sub>C</Sub> is an identity, so
+      the fields average as cleanly as the phases.
+    </Note>
+
+    <Note>
+      The half is <b style={{ color: INK }}>load-bearing, which makes it a
+        test</b>. Bias it to 0.6 and the wavelength is 30% off <V>h</V>/<V>p</V>;
+      at (1−<V>β</V>)/2 the wave vanishes outright and past that runs backwards;
+      and anywhere but a half the field stops factorising. It is not radiation
+      that sets it — beaming would put (1+<V>β</V>)/2 forward and give exactly
+      half the de Broglie wavelength — but <i>position</i>: what is weighted is
+      which side of the thing you are on, and a position you know nothing about
+      is equally likely either side of you.{' '}
+      <b style={{ color: INK }}>So <V>E</V> = ħω comes from what mass is, and{' '}
+        <V>λ</V> = <V>h</V>/<V>p</V> from not knowing where it is</b> — with the
+      bridge between them being that the ignorance is symmetric, which is the
+      uncertainty relation doing the work rather than being assumed.
+    </Note>
+
+    <Note>
+      And the lattice does <i>not</i> do the averaging itself — scatter
+      delivers the red phase travelling the wrong way, and a composite body
+      only carries the de Broglie gradient if its emitters are in step in{' '}
+      <i>its own</i> frame.{' '}
+      <b style={{ color: INK }}>The obstruction is the global tick</b>, and
+      that is a sharper thing to be stuck on than “the observer’s ignorance”
+      was: it names the update rule that would have to change. So it is made a{' '}
+      <b style={{ color: INK }}>dial</b> rather than a choice — sync = 0 is the
+      global tick and sync = 1 is de Broglie, with <V>k</V> linear between — and
+      the dial doubles as the classical limit, since being in step with itself
+      in its own frame is free for one emitter and hard for 10<Sup>57</Sup>.
+    </Note>
+
+    <Note>
+      And at sync = 1 the phase <i>is</i> the relativistic free action over ħ,
+      to nine figures — which is what makes summing e<Sup>i<V>φ</V></Sup> over
+      paths literally ∫𝒟<V>x</V> e<Sup>i<V>S</V>/ħ</Sup>. Measured on the free
+      propagator it gives the straight-line action plus{' '}
+      <b style={{ color: INK }}>π/4 to three figures</b>, amplitude ∝ √<V>X</V>{' '}
+      — so stationary phase picks the classical path out of the ignorance with
+      nothing selecting it, and two slits are a corollary rather than a setup.{' '}
+      <b style={{ color: INK }}>One thing is left assumed: that every path gets
+        the same modulus.</b>
+    </Note>
+
+    <Note>
+      Exactly, at every mass, across twenty orders. Because{' '}
+      <V>m</V><Sub>P</Sub><V>l</V><Sub>P</Sub> = ħ/<V>c</V>, “period = 1/mass”
+      in the lattice’s units <i>is</i> the Compton relation — so the identity
+      that was put here to make the equivalence principle fall out of counting
+      has been a quantum statement all along. And the ceiling gives a largest
+      elementary mass, <V>G</V>·<V>m</V><Sub>Planck</Sub> ≈ 1.36 µg; anything
+      heavier is many emitters, which is what matter is.
+    </Note>
+
+    <Head>and the cosmology, which comes out empty</Head>
+
+    <Note>
+      The rules fix one whether or not one was wanted. Matter makes space,
+      meetings unmake it, and the net is what escapes — a real expansion, and
+      it compounds, so <V>H</V> is constant and the growth exponential. Ask it
+      for the <i>observed</i> <V>H</V> and it fails five separate ways, each
+      worth recording because each is a fact rather than a failure to try:
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>screening</span>,
+        <>The pairs that make the space <i>are</i> the fog that stops the
+          gravity. One <V>Φ</V>, two jobs, opposite values: observed <V>H</V>{' '}
+          wants <V>λ</V> = 38 µm; gravity at 1 AU wants{' '}
+          <V>H</V> ≲ 10<Sup>−96</Sup>. Thirty-five orders apart.</>],
+      [<span style={{ color: DERIVED }}>the attractor</span>,
+        <>With the cascade and the expansion’s own dilution,{' '}
+          (<V>C</V>−<V>k</V><V>Φ</V><Sup>2</Sup>)(2−<V>Φ</V>) = 0 — so either
+          nothing expands, or <V>Φ</V> = 2 <i>exactly</i>, at any rate. And{' '}
+          <V>Φ</V> = 2 puts <V>λ</V> at one lattice step.</>],
+      [<span style={{ color: DERIVED }}>matter is too thin</span>,
+        <>Bound regions not expanding does not clear the fog, because{' '}
+          <V>C</V> is what empty space does and there is empty space between
+          the Earth and the Sun. Integrated over its volume, <V>Φ</V> inside
+          the Sun is 1.5·10<Sup>−48</Sup>. The gap is the mass hierarchy, not
+          the geometry.</>],
+      [<span style={{ color: DERIVED }}>the clock</span>,
+        <>The expanding state needs <V>C</V> = 2 pairs a cell a tick, and once
+          a tick is the ceiling. It asks empty space to pulse twice as fast as
+          the lattice permits — a contradiction, not a shortfall.</>],
+      [<span style={{ color: DERIVED }}>escaping charges</span>,
+        <>The four above are all about the <i>vacuum</i> making pairs. This one
+          needs no vacuum: a body’s charges that cross the horizon never meet
+          anything, so they never give their point back —{' '}
+          e<Sup>−1/0.361</Sup> = <b style={{ color: INK }}>6.3% of everything
+            emitted leaves for good</b>. Immune to screening, uncapped by the
+          clock, and still <V>H</V> = 8·10<Sup>−80</Sup>/s against
+          2·10<Sup>−18</Sup>. <b style={{ color: INK }}>Sixty-one orders
+            short</b>, wanting 10<Sup>61</Sup> times the matter there is.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>And all five have the same sign</b>, which is
+      the thing worth noticing. The usual embarrassment is a vacuum energy
+      10<Sup>120</Sup> too <i>large</i>; every mechanism this lattice has runs
+      the other way — 35 orders short on the vacuum route, 61 on the matter
+      route. So the model does not have the cosmological constant problem, it
+      has its mirror image, and a model that cannot make the universe expand at
+      all is wrong in a way that can be stated and looked for.
+    </Note>
+
+    <Note>
+      So: no expansion, no dark energy, no thermal history, and — since ± pairs
+      are made in pairs — no matter/antimatter asymmetry either.
+    </Note>
+
     <Head>and what is still owed</Head>
 
     <Note>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
index 2a0c6c5..f2d02b4 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/physics.ts
@@ -25,9 +25,22 @@
  *   reversal only when they met head-on. See `Graph.scatter`.
  *
  *   LIGHT          = 1 cell / tick                nothing goes faster
- *   BITE           = 2 LIGHT                      cells a meeting destroys
+ *   BITE           = 1 LIGHT                      cells a meeting destroys —
+ *                                                 one, so that making and
+ *                                                 unmaking a ± pair are exact
+ *                                                 inverses. See `BITE`.
  *   mass(v)        = max(1/v, 1)                  the cost of going somewhere
  *
+ *   and mass on the EMITTING side is a period, not a rate:
+ *     X              = 1/m ticks between pulses,  m ≤ 1 — once a tick is
+ *                                                 the ceiling, so there is a
+ *                                                 largest elementary mass,
+ *                                                 G·m_Planck ≈ 1.36 µg
+ *     X·c            = G · ħ/(mc) = G · λ_Compton exactly, at every mass.
+ *                                                 `period = 1/mass` in the
+ *                                                 lattice's units IS the
+ *                                                 Compton relation. See `mass`.
+ *
  *   rate(s)        = turning, or ±1 flipping, or 0    turns per CYCLE ticks
  *   β(s,t)         = phase + t·rate / CYCLE       where its north points
  *   F(d)           = sided ? d·n̂(β) : cos 2πβ      what it emits that way
@@ -311,6 +324,32 @@ export type Source = Spin & {
    * on six known three-body orbits: at every coupling the slow ones collapsed
    * and the fast ones escaped, and no value bound all six. Newton binds all
    * six, because his pull knows what it is pulling on.
+   *
+   * AND ONCE A TICK IS THE CEILING, which turns the identity round: mass is a
+   * PERIOD rather than a rate, `X = 1/m` ticks between pulses, with `m ≤ 1`.
+   * Two things follow, and the second is not small.
+   *
+   * A LARGEST ELEMENTARY MASS. The lattice mass unit is `G·m_Planck`, about
+   * 1.36 µg, so nothing that pulses on its own can weigh more than that.
+   * Anything heavier has to be many emitters — which is what matter is.
+   *
+   * AND THE PERIOD IS THE COMPTON WAVELENGTH. Turn `X` into a length:
+   *
+   *     X·c = G · ħ/(m c) = G · λ_Compton
+   *
+   * exactly, at every mass. Measured across twenty orders — electron, proton,
+   * uranium atom, virus, grain of sand — the ratio is 0.062329 every time,
+   * against `G` = 0.062351. It is not a coincidence: `m_P·l_P = ħ/c`, so
+   * "period = 1/mass" in the lattice's own units IS the Compton relation.
+   *
+   * Which is worth stopping on. This identity was put here to make the
+   * equivalence principle fall out of counting — `a ∝ m_b/R²` because a
+   * heavier thing brings proportionally more paths to the meeting. It turns
+   * out to have been a quantum statement the whole time: `E = ħω`, arrived at
+   * from how often a thing lets go of a charge, with nothing quantum put
+   * anywhere near it. The lattice is not a classical model waiting to have
+   * quantum mechanics added; the Compton relation is a consequence of what it
+   * already means by mass.
    */
   mass?: number;
 };

From 1bd55c5c423e662335ef923a47d8896718daf390 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Tue, 11 Aug 2026 04:16:49 +0200
Subject: [PATCH 24/47] Trying to work out conclusions of the model

---
 .../2026.RayCalculiAndPhysics/field.ts        |  13 +-
 .../2026.RayCalculiAndPhysics/gravity.ts      | 160 ++++++++-
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 330 +++++++++++++++---
 .../2026.RayCalculiAndPhysics/regimes.ts      | 233 +++++++++++++
 4 files changed, 674 insertions(+), 62 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
index b2ece56..34522fe 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
@@ -1495,9 +1495,16 @@ export const wave = (v: number, omega: number, sync = 1) =>
  * that needs no simultaneity convention at all. `relax`/`synced`/`wave` stay
  * useful as a dial, but they are no longer the account.
  *
+ * NOT DELETED, SWITCHED OFF. Both accounts live in `regimes.ts` as knobs —
+ * `sync` for the simultaneity route and `turn` for the zigzag — with a check
+ * that refuses to have both on at once, since they are two roads to λ = h/p
+ * and not two effects. `RECOVERS` names the settings that give Newton, general
+ * relativity, light, Dirac, and the superseded construction, so a superseded
+ * account stays runnable and can be argued with rather than remembered.
+ *
  * WHAT IS STILL OWED. This is 1+1 dimensions, where the checkerboard is clean;
  * nobody has a fully satisfactory 3+1 version, so the next thing is to find out
- * whether `WAYS` gives one — which is the emitter's-option count the audit in
- * `gravity.ts` said was missing, now with a specific job to do. And none of it
- * touches `SPREAD`'s factor of 3.4034, which remains a separate problem.
+ * whether a spinor gives one — it does, and the cost is recorded at the foot
+ * of `regimes.ts`. And none of it touches `SPREAD`'s factor of 3.4034, which
+ * remains a separate problem, and which no dimension closes.
  */
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index 8045ace..b9aa4da 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -547,6 +547,9 @@ export const carry = (px: number, py: number, fold: number) => {
  *                                                            the vacuum gives 10⁶⁰
  *   the same, integrated RADIALLY           1/r  ✓           G out by 3.4034
  *                                                            exactly = πWAYS/3SHEET
+ *   sourced by vacuum annihilation          1/r  ✓           sourcing = screening;
+ *                                                            46 orders on range
+ *   a surplus that HOPS, one way a tick      1/r  ✓  STATIC  G out by 9.83 only
  *
  * Everything that fails, fails because it is built from `chance ∝ 1/r²`. The
  * three that pass the shape test do it by an integration or a dimensional
@@ -1257,13 +1260,24 @@ export const GRAVITY = G_LATTICE * GRAIN;
 export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
 
 /**
- * HOW FAST THE SURPLUS SPREADS — and why this account is now CLOSED.
+ * HOW FAST THE SURPLUS SPREADS — and the one account still standing.
  *
- * This said "and with it, the whole of B, derived". It is not, and the reason
- * is at the bottom of this comment: `D` is not a free number, the lattice has
- * exactly one length that could set it, and that length is wrong by fifty-nine
- * orders of magnitude. What follows is kept because the mechanism is right and
- * only the number kills it, and because the number is the model's OWN.
+ * This said "and with it, the whole of B, derived". It is not, and the history
+ * is worth the space because the same word covered two different mechanisms and
+ * only one of them fails:
+ *
+ *   DIFFUSION BY SCATTERING   dead. D would come from a charge's mean free path
+ *                             against the ambient field, and the vacuum cannot
+ *                             make that short. Fifty-nine orders. See below.
+ *   DIFFUSION BY HOPPING      alive. A created point that SITS FOR A TICK AND
+ *                             THEN GOES A RANDOM WAY is a random walk with no
+ *                             scatterer in it, so D is a property of the LATTICE
+ *                             and Φ never enters. Static, gives 1/r, and owes a
+ *                             factor of 9.83. See the foot of this comment.
+ *
+ * The distinction is the whole thing. What follows describes the mechanism —
+ * which is right either way — then what killed the first reading, then what the
+ * second one costs.
  *
  * `MADE` above says a body makes space. This says what happens to it, and the
  * two together are what turn a rate into a metric.
@@ -1472,9 +1486,137 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  *   2. BIAS's WAYS                  argued, but sits π/3 from closing it
  *   3. the pull's own geometry      checked hardest, least likely
  *
- * So: B does not come from diffusion, it may come from the radial integral,
- * and what stands between is one wrong count or one unargued identification
- * rather than a missing mechanism.
+ * AND THE AUDIT POINTS AT A ROUTE NOBODY HAS RUN — worked out here, not yet
+ * simulated, and the first thing to try next.
+ *
+ * The pull works because it is a PRODUCT of two fields integrated along a line,
+ * `chance_a · chance_b`, and that product is where the extra 1/r comes from and
+ * where WAYS enters, one `BIAS` per annihilation. The metric route has one body,
+ * so it has no second field, no line integral and no WAYS — which is the exact
+ * shape of the 3.4034.
+ *
+ * BUT A LONE BODY IS NOT ALONE. Its charges annihilate against the AMBIENT
+ * FIELD Φ, the same Φ `reach` is built on, and that restores all three:
+ *
+ *     annihilation rate at r   ∝  BITE · chance(m,r) · Φ · share
+ *     acceleration             =  BIAS · that                    (so a 1/WAYS)
+ *     u = ∫a dr                ∝  m·SHEET·Φ / (4π·r·WAYS)        ← 1/r
+ *
+ * — the same structure as `shortfall`, with the vacuum standing in for the
+ * second body. Matching `u = Gm/rc²` then fixes Φ outright:
+ *
+ *     Φ = 4π·WAYS·G/SHEET = 2.546479  =  SHEET/π, exactly
+ *
+ * AND THE COSMOLOGY ATTRACTOR ALREADY SAYS Φ = 2 EXACTLY (closure 2 under
+ * `REACHES`), from a completely unrelated argument — the cascade's fixed point.
+ * The two agree to 27%, and the residual is a bare 4/π. Pinning Φ at 2 gives
+ * `G = SHEET·Φ/(4π·WAYS) = 0.04897` against the pull's 0.06235, ratio 4/π.
+ *
+ * WHICH IS THE FIRST TIME A CHANGE OF MECHANISM HAS MOVED THAT NUMBER AT ALL —
+ * from 3.4034, a mixture of counts, to a bare π. And there is an obvious place
+ * for a π to be hiding: `opposed` returns |ψ|/π, so any quantity averaged over
+ * relative phase carries a 2/π, and 4/π is two of them. That is a finite check.
+ *
+ * AND IT COLLIDES WITH `reach` AT ONCE, which is the point rather than an
+ * objection. Φ = 2 puts the screening length at ONE CELL. So Φ is now
+ * OVER-DETERMINED, and the whole problem is one quantity instead of three:
+ *
+ *     the cosmology attractor      Φ = 2
+ *     the metric, this route       Φ = SHEET/π = 2.546
+ *     the screening length         Φ ≲ 3·10⁻⁴⁸  for gravity to work at 1 AU
+ *
+ * Two agree to 27%; the third is forty-eight orders away.
+ *
+ * TESTED, AND THE ROUTE IS DEAD — cleanly, and by a general argument rather
+ * than by a number. The proposed way out was that the SCREENING Φ and the
+ * SOURCING Φ might be different quantities, on the grounds that the vacuum's ±
+ * pairs are made together and remade together, so a passing charge could
+ * contribute an annihilation EVENT without being removed. That does not
+ * survive inspection: an annihilation removes the BODY's charge, and the
+ * vacuum pair being replaced does not bring it back. The event that sources the
+ * fold IS the event that screens.
+ *
+ * So strength and range are reciprocal, exactly:
+ *
+ *     Φ           sourced u ∝ Φ    λ = 1/(BITE·share·Φ)    product
+ *     2.55e+0     2.546e+0         7.855e−1                2.0
+ *     1.00e−30    1.000e−30        2.000e+30               2.0
+ *     2.10e−46    2.100e−46        9.524e+45               2.0
+ *
+ * — the product is pinned at 1/(BITE·share) = 2, with nothing to tune. The
+ * screening was measured to confirm it is Yukawa (flux/N against e^(−r/λ),
+ * ratio 1.0001 to 1.0006) and the annihilation profile to confirm the shape
+ * (∫_r^∞ A ds × r flat to 0.99 well inside λ). Both are as the sketch said.
+ * Then:
+ *
+ *     to source the metric        Φ = SHEET/π = 2.546
+ *     for gravity to reach 1 AU   Φ ≤ 2.16·10⁻⁴⁶
+ *     short by                    1.18·10⁴⁶
+ *
+ * At the Φ that lets gravity cross the solar system, the sourced G is
+ * 5.29·10⁻⁴⁸ against the 0.0624 the pull needs. Forty-six orders too weak.
+ *
+ * AND THAT IS A NO-GO RATHER THAN A FAILED ATTEMPT, which is what makes it
+ * worth the run: ANY account that folds space by annihilating a body's charges
+ * against something ambient pays for it in range, one for one, because the two
+ * are the same events. The whole class is excluded, not this member of it.
+ *
+ * WHICH LEAVES ONE REQUIREMENT ON WHATEVER COMES NEXT: the source must not
+ * CONSUME the field. `MADE` is the only candidate here that satisfies it —
+ * creation AT the body rather than annihilation out in space — and `MADE` is
+ * the one that needs transport to be static, which is where diffusion died.
+ * That is now the whole of the problem, and it is a single question: can a
+ * point source of space be static without a random walk?
+ *
+ * ---------------------------------------------------------------------------
+ * AND THEN THE SURPLUS WAS ASKED TO HOP, WHICH CHANGES EVERYTHING ABOVE.
+ *
+ * Every failure so far took `D` from SCATTERING — how far a charge gets before
+ * meeting something — and the vacuum cannot make that short. But a created
+ * point that simply sits for a tick and then takes one of the `WAYS` at random
+ * is a random walk with NO SCATTERER IN IT. `D` is then a fact about the
+ * lattice, and Φ is not in the problem at all:
+ *
+ *     D = ⟨ℓ²⟩/6 = (54/26)/6 = 0.346154        the 26 ways out, one a tick
+ *     D required                = 3.403392
+ *     ratio                     = 9.8320
+ *
+ * NINE POINT EIGHT, from fifty-nine orders. Measured on the lattice itself —
+ * point source, absorbing rim at R = 90, 300k walkers:
+ *
+ *     r       δ·r          (S/4πD)(1−r/R)   ratio
+ *     15.2    1.9108e−1    1.9106e−1        1.0001
+ *     29.9    1.5340e−1    1.5360e−1        0.9987
+ *     59.2    7.8724e−2    7.8674e−2        1.0006
+ *
+ * — the Green's function exactly, at the lattice's own D, AND IT IS STATIC. An
+ * occupancy, not something accumulating. That was the one requirement the
+ * vacuum-sourcing no-go left standing, and this meets it.
+ *
+ * WHAT IT OWES. `G = SHEET/(12π·D) = 0.6130` against the pull's 0.0624 — gravity
+ * nine times too strong, because a fresh direction every tick spreads the
+ * surplus too slowly and it piles up. The fix is PERSISTENCE: with mean cosine
+ * `a` between successive steps, D scales by (1+a)/(1−a), so
+ *
+ *     a = 0.8154        keep your heading about 85% of the time
+ *     1/(1−a) = 5.42 steps = 10.21 cells = π·WAYS/SHEET
+ *
+ * The two extremes bracket it and neither is right: a straight-line surplus
+ * (a = 1) gives 1/r², a fresh-direction one (a = 0) gives 1/r nine times too
+ * strong. But the character of the debt has changed completely — it is now a
+ * PERSISTENCE IN THE HOPPING RULE, which the lattice may simply have, rather
+ * than a mean free path against a vacuum that provably cannot supply one. An
+ * unfixed rule, not a contradiction.
+ *
+ * AND THE OTHER SUGGESTION, that every connection at every node split into a
+ * pair: that is Φ ~ WAYS = 26, so λ = 0.077 cells and gravity is dead in a
+ * tenth of a step — thirteen times worse than the Φ = 2 attractor, which was
+ * already fatal. Nor does the aggregate bouncing back rescue it: pairs that
+ * recombine are net nothing (`BITE` = 1) and pairs that do not ARE the fog.
+ *
+ * So: B does not come from scattering, it does come from hopping up to a
+ * factor of 9.83, and what stands between is a persistence the lattice has not
+ * been shown to have. That is the whole of the remaining gap.
  * `slowing` and `thickness` stay borrowed until it is found. The ten mechanisms
  * under `carry` are now twelve, and the twelfth is the first that fails by a
  * stated finite amount instead of by a shape or by sixty orders.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index bf37058..2678606 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -44,6 +44,7 @@ const FAINT = '#6c7080';
 const RULE = '#1c1e27';
 const NAMED = '#e0a878';        // a count the lattice fixes
 const DERIVED = '#7fb8d4';      // something that came out
+const BORROWED = '#b58a8a';     // something taken from general relativity
 
 const SERIF = 'Georgia, "Times New Roman", serif';
 
@@ -542,9 +543,9 @@ const SPACE: Derivation = {
         under={<>3 <K>BITE</K> <K>SHEET</K></>} /> = 3.403
     </>}>
       From <V>δ</V> = 3<V>u</V> and <V>u</V> = <V>GM</V>/<V>rc</V><Sup>2</Sup>.
-      A pure count, no <K>GRAIN</K>, and order one: for a lattice whose things
-      move a step a tick, 3.4 steps² a tick is a mean free path of about three
-      steps. <b style={{ color: INK }}>It is not independent of ε</b> —{' '}
+      A pure count, no <K>GRAIN</K>, and order one — but read as a mean free
+      path it is 10.21 cells, and where that could come from is the whole
+      difficulty. <b style={{ color: INK }}>It is not independent of ε</b> —{' '}
       <V>D</V> = <V>c</V>/<V>ε</V> exactly. Both are the same requirement,
       written as a rate and as a spread, so the agreement is bookkeeping.
     </Step>
@@ -686,6 +687,50 @@ const MADE_FROM: Derivation = {
       route’s, wearing the name of a mechanism it does not have.
     </Step>
 
+    <Because>and the route the audit implied — tried, and excluded</Because>
+    <Step eq={<>
+      <V>Φ</V> · <V>λ</V> =
+      <Frac over={<>1</>} under={<><K>BITE</K>·share</>} /> = 2
+      <span style={{ padding: '0 1.2em', color: FAINT }}>pinned</span>
+    </>}>
+      The pull works because it is a <i>product</i> of two fields along a line —
+      which is where <K>WAYS</K> enters. A lone body has no second field, and
+      that is the shape of the 3.4034. But a lone body is not alone: its charges
+      annihilate against the ambient <V>Φ</V>, restoring product, bias and{' '}
+      <K>WAYS</K> at once. It gives 1/<V>r</V>, and matching{' '}
+      <V>u</V> = <V>Gm</V>/<V>rc</V><Sup>2</Sup> fixes{' '}
+      <V>Φ</V> = <K>SHEET</K>/π = 2.546 —{' '}
+      <b style={{ color: INK }}>against the cosmology attractor’s independent{' '}
+        <V>Φ</V> = 2, a ratio of exactly 4/π</b>. The discrepancy drops from a
+      mixture of counts to a bare π, the first time any change of mechanism has
+      moved it.
+    </Step>
+
+    <Because>and then it dies, by a general argument rather than a number</Because>
+    <Step>
+      The hoped-for escape was that the <i>sourcing</i> <V>Φ</V> and the{' '}
+      <i>screening</i> <V>Φ</V> might differ — the vacuum’s pairs being remade,
+      so a charge could contribute an event without being consumed. It does not
+      survive inspection:{' '}
+      <b style={{ color: INK }}>an annihilation removes the <i>body’s</i>{' '}
+        charge, and replacing the vacuum pair does not bring it back.</b> The
+      event that sources the fold <i>is</i> the event that screens, so strength
+      and range are reciprocal with their product pinned at 2. Sourcing needs{' '}
+      <V>Φ</V> = 2.546; reaching 1 AU allows 2.16·10<Sup>−46</Sup>. Forty-six
+      orders, nothing to tune.
+    </Step>
+
+    <Because>which excludes a class, not an attempt</Because>
+    <Step>
+      Any account that folds space by annihilating a body’s charges against
+      something ambient pays for it in range, one for one.{' '}
+      <b style={{ color: INK }}>So the source must not <i>consume</i> the
+        field</b> — and <V>ε</V> is the only candidate here that doesn’t,
+      being creation <i>at</i> the body rather than annihilation out in space.
+      Which returns the whole problem to one question: can a point source of
+      space be static without a random walk?
+    </Step>
+
     <Because>which is a far better place to be stuck</Because>
     <Step eq={<span style={{ fontFamily: 'ui-monospace, Menlo, monospace', fontSize: '0.8em' }}>
       d=2 4.000&nbsp;&nbsp;d=3 3.250&nbsp;&nbsp;d=4 3.077&nbsp;&nbsp;d=5 3.025&nbsp;&nbsp;(want 3/π = 0.955)
@@ -864,8 +909,8 @@ const CLOCK: Derivation = {
 };
 
 const IGNORANCE: Derivation = {
-  label: 'de Broglie from not knowing where',
-  title: <>λ = <V>h</V>/<V>p</V> as the price of not knowing which side you are on</>,
+  label: 'the matter wave',
+  title: <>λ = <V>h</V>/<V>p</V>, twice — by ignorance, and then by zigzag</>,
   body: <>
     <Because>a moving source has two retarded branches, and one of them is yours</Because>
     <Step eq={<>
@@ -1076,6 +1121,88 @@ const IGNORANCE: Derivation = {
       sets sync, and why the modulus is flat — and the second now has a shape:
       it needs the emitter’s options counted, not the charge’s.
     </Step>
+
+    <Because>and counting them properly retires most of this panel</Because>
+    <Step eq={<>cos <V>Ω</V> = cos <V>m</V> · cos <V>k</V></>}>
+      One action a tick: move, or update your own state. Light spends all of it
+      moving, which is why it has no clock.{' '}
+      <b style={{ color: INK }}>But <i>idling</i> the spare ticks gives
+        (1 − <V>β</V>) where relativity wants √(1−<V>β</V><Sup>2</Sup>)</b> —
+      one Doppler factor with the other dropped, and not even symmetric under{' '}
+      <V>β</V> → −<V>β</V>, so a left-mover would age at 1.5 and a right-mover
+      at 0.5. Spend it on <i>direction</i> instead — move every tick, always at{' '}
+      <V>c</V>, and let the heading alternate — and the missing (1+<V>β</V>) is
+      carried by the backward steps. That rule is local, uses one global tick,
+      and its transfer matrix gives the dispersion above exactly.
+    </Step>
+
+    <Because>from which everything comes out</Because>
+    <Step eq={<><V>Ω</V><Sup>2</Sup> = <V>k</V><Sup>2</Sup> + <V>m</V><Sup>2</Sup></>}>
+      To six figures. And then <V>k</V> <i>is</i> <V>mγv</V>, <V>Ω</V> <i>is</i>{' '}
+      <V>mγ</V>, λ <i>is</i> λ<Sub>dB</Sub>, and the internal rate{' '}
+      <V>Ω</V> − <V>k·v</V> is <V>m</V>/<V>γ</V> — so{' '}
+      <b style={{ color: INK }}>time dilation falls out</b>. The reversal
+      spacing is 1/tan <V>m</V> + 1 → 1/<V>m</V>, which is <V>X</V>: mass as a
+      pulse rate and mass as a zigzag rate are one quantity, and{' '}
+      <i>physics.ts</i> already had it.
+    </Step>
+
+    <Because>and the modulus is no longer a postulate</Because>
+    <Step eq={<>cos<Sup><V>N</V>−<V>R</V></Sup> <V>m</V> · sin<Sup><V>R</V></Sup> <V>m</V></>}>
+      A path of <V>N</V> steps with <V>R</V> reversals weighs that — set
+      entirely by how often it turns, which is set entirely by the mass. Feynman
+      postulates a flat modulus; here it is derived, and cos<Sup>2</Sup> +
+      sin<Sup>2</Sup> = 1 makes it unitary for free.{' '}
+      <b style={{ color: INK }}>The amplitude rule is the pulse rate.</b>
+    </Step>
+
+    <Because>which retires a conclusion drawn above, and it should be said plainly</Because>
+    <Step>
+      The claim was that de Broglie needs per-body rest-frame simultaneity and
+      that the global tick was the obstruction.{' '}
+      <b style={{ color: INK }}>This derivation uses a global tick, is local,
+        and gets λ<Sub>dB</Sub> anyway — so that claim is false as stated.</b>{' '}
+      What was actually shown is narrower: a composite carrying <i>internal
+        phases</i> needs rest-frame synchrony for those to add to a matter wave.
+      The zigzag carries the phase in the amplitude over paths instead, and
+      needs no simultaneity convention at all. The dial stays useful; it is no
+      longer the account. Still owed: this is 1+1 dimensions, where the
+      checkerboard is clean and where nobody has a satisfactory 3+1 version —
+      so a spinor is what pays for it — see below.
+    </Step>
+
+    <Because>and in 3+1 it does work, at a stated cost</Because>
+    <Step eq={<>
+      <V>U</V>(<b>k</b>) = [cos <V>m</V> − <V>i</V> sin <V>m</V> <V>β</V>] ·
+      Π<Sub>j</Sub>[cos <V>k</V><Sub>j</Sub> − <V>i</V> sin <V>k</V><Sub>j</Sub> <V>α</V><Sub>j</Sub>]
+    </>}>
+      Every step still at <V>c</V>; what chooses the heading is an internal
+      state, which is a spinor, and the algebra fixes its size. It reduces to
+      the 1+1 checkerboard exactly at <V>d</V> = 1, and in 3+1 gives{' '}
+      <b style={{ color: INK }}><V>Ω</V><Sup>2</Sup> = |<b>k</b>|<Sup>2</Sup> +{' '}
+        <V>m</V><Sup>2</Sup> to five figures</b>, trace real to machine
+      precision. The cost is anisotropy at finite <V>k</V> — the <V>α</V><Sub>j</Sub>{' '}
+      do not commute, so 0.94 on the diagonal against the axis at |<b>k</b>| = 1,
+      growing as <V>k</V><Sup>2</Sup> and gone in the continuum. That is the
+      same defect <K>FLOOR</K> already flags, reached from somewhere else
+      entirely.
+    </Step>
+
+    <Because>and fractional dimensions do not survive it</Because>
+    <Step eq={<>2<Sup>⌊(<V>d</V>+1)/2⌋</Sup> components</>}>
+      <K>SHEET</K> and <K>WAYS</K> are 3<Sup><V>d</V>−1</Sup> − 1 and
+      3<Sup><V>d</V></Sup> − 1, perfectly happy at <V>d</V> = 2.5 (4.196 and
+      14.588), and every counting argument would still run. But a Clifford
+      algebra has no fractional representation — you cannot have 2.83
+      anticommuting matrices.{' '}
+      <b style={{ color: INK }}>The counts interpolate and the spinor does
+        not</b>, so a fractional-dimension version would have a gravity and no
+      fermions. Either the spinor is fundamental and <V>d</V> is an integer, or
+      the counts are and four components at <V>d</V> = 3 has to be derived.
+      Nothing here decides it. It does settle one thing negatively:{' '}
+      <K>WAYS</K>/<K>SHEET</K> is bounded below by 3 at <i>every</i> <V>d</V>,
+      so no dimension — fractional or not — closes the 3.4034.
+    </Step>
   </>,
 };
 
@@ -1464,32 +1591,51 @@ export const Law = () => {
           own response, out of the count being a count on the body’s own
           worldline.</>],
       [<span style={{ color: DERIVED }}>
-        <V>A</V> = 1 − 2<V>u</V> + 2<V>u</V><Sup>2</Sup>,{' '}
-        <V>B</V> = 1 + 2<V>u</V></span>,
-      <><b style={{ color: INK }}>A metric, out of the same count.</b> The lean
-        is a <i>ratio</i> — 1 + <V>n</V> against the <K>WAYS</K> that weigh one
-        each — and a ratio throws away the total. There are{' '}
-        <K>WAYS</K> + <V>n</V> ways out of that point now, and a point with
-        more ways out holds more space. The lean is <V>A</V>; the total
-        is <V>B</V>.</>],
-      [<span style={{ color: DERIVED }}>
-        6π<V>GM</V>/<V>c</V><Sup>2</Sup><V>a</V>(1−<V>e</V><Sup>2</Sup>)</span>,
-      <><b style={{ color: INK }}>The perihelion advance, all of it.</b> Five
-        orbits over two panels come to 6.05 to 6.20 sixths of it, ordered by
-        how deep each orbit sits and by nothing else. The lean alone gives one
-        sixth, and gives it to a part in a hundred for every one of them.</>],
-      [<span style={{ color: DERIVED }}>
-        4<V>GM</V>/<V>bc</V><Sup>2</Sup></span>,
-      <><b style={{ color: INK }}>The deflection of light, all of it.</b> Which
-        the lean could not touch at all — at <V>v</V> = <V>c</V> the count is
-        already infinite, so one more annihilation turns it by nothing. A
-        thickness needs no mass to divide by: the cell in front is simply
-        longer.</>],
+        one sixth of 6π<V>GM</V>/<V>c</V><Sup>2</Sup><V>a</V>(1−<V>e</V><Sup>2</Sup>)</span>,
+      <><b style={{ color: INK }}>The perihelion advance, the part the pull
+        owns.</b> The lean alone gives exactly one sixth, and gives it to a
+        part in a hundred for every one of five orbits over two panels. This
+        much is counted.</>],
       [<span style={{ color: DERIVED }}>screen</span>,
         <>Three bodies in a row do not simply add. Newton has no such term and
           neither does relativity at this order.</>],
     ]} />
 
+    <Head>what is borrowed</Head>
+
+    <Note>
+      Kept separate from what is derived, because the difference is the whole
+      state of the thing and it is easy to lose.{' '}
+      <b style={{ color: INK }}>The pull is counted. The metric is not.</b>
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>
+        <V>A</V> = 1 − 2<V>u</V> + 2<V>u</V><Sup>2</Sup>,{' '}
+        <V>B</V> = 1 + 2<V>u</V></span>,
+      <>General relativity’s isotropic functions, written closed rather than as
+        the series. There is a counting <i>story</i> for them — the lean is a
+        ratio and a ratio throws away the total, so <K>WAYS</K> + <V>n</V> ways
+        out means more space — but a story is not a derivation, and the
+        coefficient has never come out. See below.</>],
+      [<span style={{ color: BORROWED }}><i>carry</i></span>,
+        <>The geodesic equation. What a count is worth once the place is
+          folded, which at leading order is 1 + 2<V>v</V><Sup>2</Sup>/<V>c</V><Sup>2</Sup>{' '}
+          — and that alone does not do it, so it is taken whole.</>],
+      [<span style={{ color: BORROWED }}>
+        the other five sixths, and 4<V>GM</V>/<V>bc</V><Sup>2</Sup></span>,
+        <>Everything the metric buys: 6.05 to 6.20 sixths measured, and the
+          whole of light’s deflection, which the lean could not touch at all.
+          Correct to four figures, and <i>correct because A and B were put
+          in</i>.</>],
+      [<span style={{ color: DERIVED }}>how close it came</span>,
+        <><V>u</V> = <V>Gm</V>/<V>rc</V><Sup>2</Sup> as a fact about a place
+          does come out — from a point source of space and a surplus that hops
+          — static, 1/<V>r</V>, and{' '}
+          <b style={{ color: INK }}>wrong in <V>G</V> by 9.83</b>. That factor
+          is the entire remaining distance to a derived metric.</>],
+    ]} />
+
     <Head>what is a choice</Head>
 
     <Rows of={[
@@ -1582,25 +1728,59 @@ export const Law = () => {
       carried point source settles:
     </Note>
 
-    <Eq derive={SPACE} open={show}
-      note="static, because the flux carries the surplus away as fast as it is made">
+    <Eq derive={MADE_FROM} open={show}
+      note="a point source settles to a potential — if something carries the surplus away, and that is the whole difficulty">
       <V>δ</V>(<V>r</V>) = <Frac over={<V>S</V>}
         under={<>4<V>π D r</V></>} /> = 3<V>u</V>
       <span style={{ padding: '0 1.6em' }} />
-      <V>D</V> = <Frac over={<><V>π</V> <K>WAYS</K> <V>c</V></>}
-        under={<>3 <K>BITE</K> <K>SHEET</K></>} /> = 3.403
-      <span style={{ padding: '0 1.6em' }} />
       ⇒ <V>u</V> = <Frac over={<V>Gm</V>}
         under={<><V>r c</V><Sup>2</Sup></>} />
     </Eq>
 
     <Note>
-      Which is the metric’s own potential, out of a rate and a spread. It is
-      linear in the <i>other</i> mass alone — a fact about the place rather
-      than the pair, which the folding could never say before — and it gives
-      every number the old reading gave, to the digit. The difference is that
-      the old one took the pull and called its potential <V>u</V>, and this one
-      is derived.
+      That is the metric’s own potential out of a rate and a spread, and it is
+      linear in the <i>other</i> mass alone — a fact about the <i>place</i>{' '}
+      rather than the pair, which the folding could never say before.{' '}
+      <b style={{ color: INK }}>The source is not the difficulty. The transport
+        is.</b> <V>D</V> is not free — for anything moving at <V>c</V> it is{' '}
+      <V>cλ</V>/3 — so the account is only as good as the <V>λ</V> the lattice
+      can supply, and that has had three answers.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}>by scattering</span>,
+        <><b style={{ color: INK }}>Dead.</b> <V>λ</V> would be a charge’s mean
+          free path against the ambient field, and the only constant-density
+          scatterer is the vacuum — whose length the reach below already fixes
+          at 10<Sup>60</Sup> cells against the 10 this needs.{' '}
+          <b style={{ color: INK }}>Fifty-nine orders</b>, and the two cannot
+          both stand.</>],
+      [<span style={{ color: FAINT }}>ballistically</span>,
+        <><b style={{ color: INK }}>Wrong shape.</b> Which is where that leaves
+          it: measured, <V>δ</V>·<V>r</V><Sup>2</Sup> flat to 0.6%, so{' '}
+          <V>u</V> ∝ 1/<V>r</V><Sup>2</Sup> — not a potential, and not Newton
+          either.</>],
+      [<span style={{ color: DERIVED }}>by hopping</span>,
+        <><b style={{ color: INK }}>Alive.</b> A created point that sits a tick
+          and then takes one of the <K>WAYS</K> at random is a random walk with{' '}
+          <i>no scatterer in it</i>, so <V>D</V> = ⟨ℓ<Sup>2</Sup>⟩/6 = 0.3462 is
+          a fact about the lattice and <V>Φ</V> never enters. Measured on the
+          lattice: the Green’s function to 0.1%, and <i>static</i> — an
+          occupancy, not an accumulation.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>Nine point eight, from fifty-nine orders.</b>{' '}
+      Hopping gives <V>G</V> = <K>SHEET</K>/(12π<V>D</V>) = 0.6130 against the
+      pull’s 0.0624 — gravity nine times too strong, because a fresh direction
+      every tick spreads the surplus too slowly and it piles up. The fix is{' '}
+      <i>persistence</i>: with mean cosine <V>a</V> between steps, <V>D</V>{' '}
+      scales by (1+<V>a</V>)/(1−<V>a</V>), so <V>a</V> = 0.815 — keep your
+      heading about 85% of the time, which is 10.21 cells, which is{' '}
+      π<K>WAYS</K>/<K>SHEET</K>. The two extremes bracket it and neither is
+      right, and{' '}
+      <b style={{ color: INK }}>the debt is now a rule the lattice may simply
+        have, rather than a contradiction it cannot resolve.</b>
     </Note>
 
     <Head>how far it reaches</Head>
@@ -1692,7 +1872,7 @@ export const Law = () => {
     </Note>
 
     <Eq derive={IGNORANCE} open={show}
-      note="know how fast it is going but not where, and what you are holding is a de Broglie wave">
+      note="two routes to the same wavelength — one by not knowing where it is, one by letting the worldline turn">
       <V>λ</V> = <Frac over={<><V>λ</V><Sub>C</Sub></>} under={<><V>γβ</V></>} /> =
       <Frac over={<V>h</V>} under={<V>p</V>} />
       <span style={{ padding: '0 1.4em', color: FAINT }}>at ignorance = ½</span>
@@ -1821,25 +2001,75 @@ export const Law = () => {
       are made in pairs — no matter/antimatter asymmetry either.
     </Note>
 
+    <Head>what you can switch off</Head>
+
+    <Note>
+      The model kept producing accounts that were right about something and
+      then superseded, and deleting them lost information — a superseded
+      account is usually the same physics along a worse road. So every place it
+      could have gone another way is a knob in <i>regimes.ts</i>, and each
+      named theory below is a claim about which knobs to turn down.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}>Newton</span>,
+        <>fold 0, screen 0. Flat space, infinite range. One sixth of the
+          perihelion advance.</>],
+      [<span style={{ color: FAINT }}>general relativity</span>,
+        <>fold 1, screen 0. Six sixths and the whole of light’s deflection —
+          and <b style={{ color: INK }}>borrowed, not counted</b>.</>],
+      [<span style={{ color: FAINT }}>light</span>,
+        <>turn 0. Never reverses, so no clock, so no mass. Not “a classical
+          particle” — a photon.</>],
+      [<span style={{ color: DERIVED }}>Dirac</span>,
+        <>turn 1. The zigzag: <V>Ω</V><Sup>2</Sup> = <V>k</V><Sup>2</Sup> +{' '}
+          <V>m</V><Sup>2</Sup>, λ<Sub>dB</Sub>, time dilation, and a modulus
+          that is derived rather than postulated.</>],
+      [<span style={{ color: FAINT }}>de Broglie by simultaneity</span>,
+        <>sync 1. The superseded route to the same wavelength, kept switchable
+          because it is the only account here that says anything about what a{' '}
+          <i>composite</i> must do.</>],
+    ]} />
+
+    <Note>
+      <i>check</i> refuses sync and turn together — they are two roads to
+      λ = <V>h</V>/<V>p</V>, not two effects, and having both would count it
+      twice. <i>borrows</i> is a separate question from <i>coherent</i>, and it
+      returns non-empty for every setting with fold on, including this model’s
+      own.
+    </Note>
+
     <Head>and what is still owed</Head>
 
     <Note>
-      <b style={{ color: INK }}>One thing, and it is in the lattice rather than
-        here.</b> The third rewrite is what carries the surplus, and on the
-      lattice that is consume-ahead-emit-behind — measured, an exact swap that
-      displaces nothing net. Whether it can carry a surplus outward at{' '}
-      <V>D</V> ≈ 3.4 steps² a tick is a question about that rule, not a new
-      one. Until it is answered, <V>D</V> is a number the continuum needs and
-      the lattice has not been shown to supply.
+      <b style={{ color: INK }}>One number.</b> The pull is counted, <V>G</V>{' '}
+      is counted, the reach is counted, <V>E</V> = ħω and λ = <V>h</V>/<V>p</V>{' '}
+      and the amplitude rule all fall out of mass being a rate.{' '}
+      <b style={{ color: INK }}><V>A</V> and <V>B</V> are general relativity’s,
+        and <i>carry</i> is its geodesic equation</b> — which is five sixths of
+      the perihelion advance and all of the deflection, borrowed. Everything
+      else on this page is downstream of closing that.
+    </Note>
+
+    <Note>
+      And it has narrowed to a single question. The source is settled: creation{' '}
+      <i>at</i> the body, which is the only mechanism that does not{' '}
+      <i>consume</i> the field — and consuming it is fatal, because the event
+      that sources a fold is the event that screens, so strength and range are
+      reciprocal with their product pinned at 2. The transport is settled up to
+      a factor: a surplus that hops is static and gives 1/<V>r</V> and misses{' '}
+      <V>G</V> by 9.83. So:{' '}
+      <b style={{ color: INK }}>does the lattice have a reason for a hopping
+        point to keep its heading about 85% of the time?</b> That is the whole
+      of the remaining gap, and 10.21 = π<K>WAYS</K>/<K>SHEET</K> being a pure
+      count is either the answer in plain sight or a coincidence.
     </Note>
 
     <Note>
       Two things bound whatever answers it. An ambient charge{' '}
-      <b style={{ color: INK }}>screens</b>: a body’s charges annihilate
-      against it too, so they reach only{' '}
-      <V>λ</V> = <V>c</V>/(<K>BITE</K>·share·<V>Φ</V><Sub>0</Sub>) and gravity
-      becomes Yukawa with that range — cluster scale needs{' '}
-      <V>Φ</V><Sub>0</Sub> ≲ 10<Sup>−58</Sup> a lattice cell. And a body{' '}
+      <b style={{ color: INK }}>screens</b>, so a vacuum dense enough to carry
+      anything is dense enough to switch gravity off within a few steps — which
+      is why the hop matters, since it needs no vacuum at all. And a body{' '}
       <b style={{ color: INK }}>cannot take back</b> what it emits: measured on
       a running lattice, at most two parts in a thousand return, because a
       source emits into 4<V>π</V> and subtends nothing.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
new file mode 100644
index 0000000..c75e2f2
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
@@ -0,0 +1,233 @@
+/**
+ * WHAT TO TURN OFF TO GET SOMEBODY ELSE'S THEORY.
+ *
+ * This file exists because the model kept producing accounts that were RIGHT
+ * ABOUT SOMETHING and then superseded, and deleting them lost information. A
+ * superseded account is not a wrong one — it is usually the same physics
+ * reached along a worse road, and being able to switch it back on is how you
+ * tell those apart.
+ *
+ * So every place the model could have gone another way is a KNOB, each running
+ * 0 → 1, each with a theory at either end. Nothing here is a fudge factor:
+ * every knob is either fully on or fully off in the model's own setting, and
+ * the values between exist so that the crossover can be measured rather than
+ * asserted.
+ *
+ * TWO KNOBS CAN BE ALTERNATIVE ACCOUNTS OF ONE THING rather than independent
+ * effects, and `sync` and `turn` are exactly that — two routes to λ = h/p. They
+ * must not both be on, or the same physics is counted twice. `check` below
+ * refuses that combination rather than letting it pass quietly.
+ */
+
+/** A setting of every knob. */
+export type Regime = {
+  /**
+   * WHOSE SIMULTANEITY a body's internal phases are in step with.
+   *
+   *   0  the global tick — one phase everywhere, no internal gradient, so no
+   *      matter wave. Classical.
+   *   1  rest-frame simultaneity — the phase gradient IS ω γ β/c, so λ = h/p.
+   *
+   * This is the SUPERSEDED account of de Broglie (see `relax` in `field.ts`),
+   * kept because it is a real result about what a composite carrying internal
+   * phases would have to do, and because the dial is the classical limit: being
+   * in step with itself in its own frame is free for one emitter and hard for
+   * 10⁵⁷. It is off in the model's own setting because `turn` does the job
+   * without needing a simultaneity convention at all.
+   */
+  sync: number;
+
+  /**
+   * WHETHER A WORLDLINE MAY REVERSE — the checkerboard.
+   *
+   *   0  never turns. Every step at c in one direction: lightlike, massless,
+   *      no internal clock. This is what light is.
+   *   1  turns with amplitude sin(m), once every 1/m ticks, which is `CLOCK`'s
+   *      own pulse period. Gives Ω² = k² + m², λ = λ_dB, and time dilation.
+   *
+   * The model's own setting. Note that `turn` at 0 is not "a classical
+   * particle" — it is a PHOTON. There is no way to be slow without turning.
+   */
+  turn: number;
+
+  /**
+   * WHETHER SPACE IS FOLDED — the metric, as against a flat-space force.
+   *
+   *   0  flat. The pull alone, which is Newton and gives one sixth of the
+   *      perihelion advance.
+   *   1  `slowing` and `thickness` applied, and `carry` for the geodesic —
+   *      six sixths, and the whole of light's deflection.
+   *
+   * HONESTY: at 1 this is BORROWED, not derived. A and B are general
+   * relativity's isotropic functions. See the bottom of `SPREAD` in
+   * `gravity.ts` for how far the derivation got and exactly where it stops.
+   */
+  fold: number;
+
+  /**
+   * WHETHER THE AMBIENT FIELD SCREENS — how far gravity reaches.
+   *
+   *   0  infinite range, which is what Newton and general relativity both say.
+   *   1  Yukawa at λ = REACHES·R_horizon = 0.361 R_h — 1.55 Gpc, 9.2% down at
+   *      the BAO scale.
+   *
+   * The model's own setting, and the one thing here that is a prediction in the
+   * full sense. Turning it off is how you ask what it costs.
+   */
+  screen: number;
+};
+
+/** Every knob on: the model saying everything it has to say. */
+export const FULL: Regime = { sync: 0, turn: 1, fold: 1, screen: 1 };
+
+/**
+ * The theories this model contains, and what each one is a switching-off of.
+ *
+ * Read these as claims. "Newton is this model with `fold` and `screen` off" is
+ * either true or false and can be checked, and the panels in `models.ts` check
+ * two of them by drawing all three laws on one orbit.
+ */
+export const RECOVERS = {
+  /** Flat space, infinite range, no matter wave. One sixth of the advance. */
+  'newton': { sync: 0, turn: 0, fold: 0, screen: 0 },
+
+  /** Add the metric. Six sixths, and 4GM/bc² for light. Borrowed, not derived. */
+  'general relativity': { sync: 0, turn: 0, fold: 1, screen: 0 },
+
+  /** A photon: never turns, so no clock, so no mass. */
+  'light': { sync: 0, turn: 0, fold: 1, screen: 1 },
+
+  /** The zigzag. Ω² = k² + m², λ_dB, time dilation, and a derived modulus. */
+  'dirac': { sync: 0, turn: 1, fold: 0, screen: 0 },
+
+  /**
+   * The superseded route to the same wavelength — rest-frame simultaneity and
+   * ignorance of which side you are on. Kept switchable on purpose: it is the
+   * only account here that says anything about what a COMPOSITE has to do, and
+   * `turn` says nothing about that.
+   */
+  'de broglie by simultaneity': { sync: 1, turn: 0, fold: 0, screen: 0 },
+
+  /** What this model says when nothing is switched off. */
+  'orbitmines': FULL,
+} satisfies Record<string, Regime>;
+
+export type Recovered = keyof typeof RECOVERS;
+
+/** The setting that recovers a named theory. */
+export const setting = (of: Recovered): Regime => ({ ...RECOVERS[of] });
+
+/**
+ * Whether a regime is coherent — which is not the same as being in range.
+ *
+ * Returns the reasons it is not, empty if it is. The only rule so far is the
+ * one above: `sync` and `turn` are two accounts of one phenomenon, so having
+ * both would put λ = h/p in twice. More will land here as more knobs do.
+ */
+export const check = (r: Regime): string[] => {
+  const wrong: string[] = [];
+
+  for (const [k, v] of Object.entries(r))
+    if (!(v >= 0 && v <= 1)) wrong.push(`${k} = ${v} is outside 0…1`);
+
+  if (r.sync > 0 && r.turn > 0)
+    wrong.push('sync and turn are two accounts of λ = h/p, not two effects — '
+      + 'having both counts the same physics twice');
+
+  return wrong;
+};
+
+/**
+ * What a regime is still borrowing rather than counting — which is a different
+ * question from whether it is coherent, and the one that is easy to lose track
+ * of. `check` says whether a setting makes sense; this says what it costs.
+ */
+export const borrows = (r: Regime): string[] => {
+  const owed: string[] = [];
+
+  if (r.fold > 0) owed.push(
+    '`slowing` and `thickness` are general relativity\'s isotropic functions, '
+    + 'and `carry` is its geodesic equation. The pull is derived; the metric '
+    + 'that turns one sixth of the perihelion advance into six is not.');
+
+  return owed;
+};
+
+/**
+ * The checkerboard's dispersion at a given regime — `cos Ω = cos(turn·m)·cos k`.
+ *
+ * At `turn` = 1 this is the full zigzag and Ω² → k² + m². At `turn` = 0 it is
+ * Ω = k, a massless thing moving at c. In between the mass is `turn·m`, which
+ * is what a partially-reversing worldline weighs.
+ */
+export const stepping = (m: number, k: number, r: Regime = FULL) => {
+  const a = Math.cos(r.turn * m);
+  const omega = Math.acos(Math.max(-1, Math.min(1, a * Math.cos(k))));
+
+  return { omega, mass: r.turn * m, reverses: Math.tan(r.turn * m) };
+};
+
+/**
+ * AND THE SAME THING IN 3+1, which was the part nobody has a tidy version of.
+ *
+ * In 1+1 a worldline has two headings and reversing between them is the whole
+ * of mass. In three dimensions "reverse" is not one thing, and the construction
+ * that works keeps every step at c and lets an INTERNAL STATE choose the
+ * heading — which is a spinor, and the algebra decides how big it has to be:
+ *
+ *     U(k) = [cos m − i sin m · β] · Π_j [cos k_j − i sin k_j · α_j]
+ *
+ * with α_j² = β² = 1 so every factor is a rotation, and Ω read off the trace.
+ * For small k and m, U ≈ 1 − i(Σ k_j α_j + m β) — the Dirac Hamiltonian.
+ *
+ * IT REDUCES CORRECTLY. At d = 1 it gives `cos Ω = cos m · cos k` to 0.0e+0,
+ * which is the 1+1 checkerboard exactly. And in 3+1:
+ *
+ *     m        |k|       Ω²           |k|²+m²      ratio      Im tr
+ *     0.0200   0.0200    7.99929e−4   8.00000e−4   0.999911   0.0e+0
+ *     0.0100   0.0080    1.63997e−4   1.64000e−4   0.999984   0.0e+0
+ *     0.0040   0.0080    7.99992e−5   8.00000e−5   0.999990   0.0e+0
+ *
+ * — relativistic, with the trace real to machine precision, which is the check
+ * that the spectrum really is the doubly-degenerate ±Ω it was assumed to be.
+ *
+ * IT IS ANISOTROPIC AT FINITE k, and that is the honest cost. The α_j do not
+ * commute, so the order the axes are stepped in survives into the answer:
+ *
+ *     |k|      Ω on axis     Ω on diagonal   ratio
+ *     0.05     0.07069594    0.07069103      0.999931
+ *     0.20     0.20607419    0.20564238      0.997905
+ *     0.50     0.50228287    0.49529126      0.986080
+ *     1.00     1.00080224    0.94275679      0.942001
+ *
+ * Growing as k² and vanishing in the continuum — which is the lattice spacing
+ * showing through, and is the SAME anisotropy `FLOOR` in `field.ts` already
+ * flags as open (Chebyshev counting against Euclidean distance), arriving here
+ * from a completely different direction. Two independent routes to one defect
+ * is worth more than either.
+ *
+ * AND FRACTIONAL DIMENSIONS DO NOT WORK HERE, which is worth knowing before
+ * building on them. `SHEET` and `WAYS` are `3^(d−1) − 1` and `3^d − 1` and are
+ * perfectly happy off the integers — d = 2.5 gives 4.196 and 14.588, and every
+ * counting argument in `gravity.ts` would still run. But a Clifford algebra has
+ * no fractional representation: you cannot have 2.83 anticommuting matrices.
+ * The smallest spinor is 2^⌊(d+1)/2⌋ — four components at d = 3, and that is
+ * not a choice.
+ *
+ *     THE COUNTS INTERPOLATE AND THE SPINOR DOES NOT.
+ *
+ * So a fractional-dimension version of this model would have a gravity and no
+ * fermions. Which is a fork rather than a detail:
+ *
+ *   — if the spinor is fundamental, d is an integer and that settles it
+ *   — if the counts are fundamental, d may be fractional and the spinor has to
+ *     EMERGE, making "four components at d = 3" a thing to be derived
+ *
+ * Nothing here decides it, and recording that it is a decision is the point.
+ *
+ * ONE THING FRACTIONAL d DOES SETTLE, though, and it settles it negatively:
+ * `WAYS/SHEET` is bounded BELOW by 3 at every d — 5.73 at 1.5, 4.00 at 2, 3.25
+ * at 3, tending to 3 from above — and closing `SPREAD` needs it to be 3/π =
+ * 0.955. So no dimension rescues that factor of 3.4034, fractional or not. It
+ * was already known that no integer d does; this closes the continuous case too.
+ */

From 509679c15023f9bf4119905bc9380ac978bb2a29 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Tue, 11 Aug 2026 12:31:38 +0200
Subject: [PATCH 25/47] Reproducing results from GR

---
 .../2026.RayCalculiAndPhysics/gravity.ts      | 899 +++++++++++++++++-
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 580 ++++++++++-
 .../2026.RayCalculiAndPhysics/regimes.ts      | 126 ++-
 3 files changed, 1540 insertions(+), 65 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index b9aa4da..febc361 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -395,7 +395,13 @@ export const count = (
  *                                        (65)             (28)
  *     u at perihelion  0.0025  0.0035   0.0038  0.0048   0.0112
  *     pull alone        1.00    1.00     1.00    1.00     1.00   sixths
- *     as a metric       6.05    6.08     6.07    6.10     6.20
+ *     borrowed A,B      6.05    6.07     6.07    6.10     6.20
+ *     COMPOUNDED A,B    6.05    6.08     6.07    6.11     6.22
+ *
+ * — the second row is what the file used to use and the third is what it uses
+ * now (see `slowing`). The change is +0.005 to +0.020 sixths, ordered by depth,
+ * which is the O(u) second-post-Newtonian difference between e^{2u} and
+ * (1+u/2)⁴ and nothing else. Both rows are six plus about 3.3·u.
  *
  * — five orbits over two panels at two scales. The first row does not move off
  * a sixth by a part in a hundred. The second is six plus about 3.3·u, ordered
@@ -461,9 +467,122 @@ export const count = (
  * Nothing measured moves: the solar panels sit at `u ~ 10⁻³` where the series
  * and the closed form agree to ten figures.
  */
+/**
+ * AND THE FORM THEY SHOULD HAVE, WHICH IS NOT THE ONE BELOW.
+ *
+ * `slowing` and `thickness` are general relativity's isotropic functions,
+ * borrowed. The counting story says they should not have to be: a place has
+ * WAYS + n ways out, the LEAN is a ratio (A) and what a ratio throws away is
+ * the TOTAL (B). The only question is how the count composes.
+ *
+ *     ADDITIVE         weight of the way it went = 1 + n        √A = WAYS/(WAYS+n)
+ *     MULTIPLICATIVE   each annihilation multiplies by 1+1/WAYS  √A = (1+1/WAYS)^−n
+ *
+ * and `(1+1/WAYS)^n = exp(n·ln(1+1/WAYS)) → exp(n/WAYS) = exp(u)`, so
+ *
+ *     A = exp(−2u)      B = exp(+2u)      A·B = 1 exactly
+ *
+ * MEASURED, by integrating the orbit between its turning points rather than by
+ * expanding — advance as a fraction of 6πGM/c²a(1−e²):
+ *
+ *     metric                              r=80..120  200..300  500..700  2000..3000
+ *     GR, isotropic (what is used below)   1.03775   1.01471   1.00591   1.00081
+ *     MULTIPLICATIVE  e^∓2u                1.04151   1.01615   1.00665   1.00211
+ *     additive ratio  1/(1+u)², (1+u)²     0.85041   0.84006   0.83611   0.83290
+ *     A = 1−2u, B = 1                      0.70339   0.68086   0.67250   0.66813
+ *
+ * — so MULTIPLICATIVE COMPOSITION GIVES GENERAL RELATIVITY and additive does
+ * not. β = γ = 1 both fall out: γ because A and B read one count two ways, β
+ * because compounding is what makes it an exponential. The additive form is
+ * 17% low at every depth, exactly as its β = 3/2 says it must be.
+ *
+ * WHERE IT DIFFERS FROM GR, and it does. `A` agrees to O(u³) — the isotropic A
+ * is `exp(−2u − u³/6)` exactly — but `B` differs at O(u²), which shows in the
+ * perihelion at O(u). At real solar-system depths that is nothing: Mercury's u
+ * is 2.7·10⁻⁸, so the two differ by ~10⁻⁶ arcseconds a century against an
+ * advance of 43. In THIS FILE'S PANELS, which run at u ~ 0.0025 to 0.0112 so
+ * the effect is visible at all, it is 0.13% to 0.56% — so the measured
+ * 6.05…6.20 sixths would move to roughly 6.1…6.4. The same statement, different
+ * digits, and the panels want re-measuring before those numbers are quoted.
+ *
+ * AND ONE DIFFERENCE THAT IS NOT SMALL: `exp(−2u)` never reaches nought at
+ * finite u, so THERE IS NO HORIZON. The isotropic form has A = 0 at u = 2; this
+ * has A = 1.8·10⁻² there and 2·10⁻⁹ at u = 10. A universe of this kind has no
+ * black holes, only things arbitrarily red. That is a real prediction and a
+ * dangerous one — it is the same exponential metric that has been proposed
+ * before as an alternative to general relativity, and the absence of horizons
+ * is exactly where such proposals are tested against merger ringdowns and
+ * against the shadow the Event Horizon Telescope images. It is the sharpest
+ * falsifiable thing this model has produced.
+ *
+ * AND THE COMPOUNDING IS NOT A CHOICE — it is what the edges do.
+ *
+ * The above showed multiplicative composition GIVES general relativity. It did
+ * not show the lattice composes that way, and "it gets the right answer" is the
+ * reasoning this file refuses everywhere else. Here is the mechanism, and it is
+ * the counting argument's own:
+ *
+ *   A node that has taken n annihilations has WAYS + n edges rather than WAYS.
+ *   Edges are shared with neighbours, so THE SAME n EXTRA EDGES POINT INTO IT.
+ *   A charge wandering nearby is therefore (WAYS + n)/WAYS times more likely to
+ *   arrive there than at an unfolded node.
+ *
+ *     MORE ARRIVALS → MORE ANNIHILATIONS → MORE FOLDING → MORE ARRIVALS.
+ *
+ * So the increment is proportional to what is already there, which is what
+ * multiplicative MEANS. Written as the counting argument would write it, with
+ * u₀ the bare count — the pull's own potential, already derived:
+ *
+ *     du = du₀ · (1 + u)
+ *
+ * and that has exactly one solution. Integrated from infinity inward:
+ *
+ *     r        u measured      e^u₀ − 1        ratio
+ *     100      1.005017e−2     1.005017e−2     0.999999997
+ *     5        2.214027e−1     2.214028e−1     0.999999945
+ *     1        1.718281e+0     1.718282e+0     0.999999605
+ *
+ * `1 + u = e^u₀`, exactly, with nothing chosen. Then the same two readings as
+ * before — the lean and the total — give
+ *
+ *     √A = WAYS/(WAYS+n) = 1/(1+u) = e^−u₀
+ *     √B = (WAYS+n)/WAYS = (1+u)   = e^+u₀
+ *     ⇒  A = e^−2u₀,  B = e^+2u₀,  A·B = 1
+ *
+ * which is the metric measured above to give general relativity's perihelion
+ * advance. SO A AND B ARE NOT BORROWED. They are the bare count, compounded by
+ * the fact that a folded node is easier to arrive at.
+ *
+ * AND THE PULL IS UNTOUCHED WHERE IT WAS MEASURED. The same feedback enhances
+ * the force by (1+u), whose first-order part is already in the metric; what is
+ * new beyond that is u₀²/2 — 3.5·10⁻¹⁶ at Mercury's perihelion, 6.3·10⁻⁵ in
+ * this file's own panels. Nothing measured moves.
+ *
+ * AND NO HORIZON, IN ONE LINE. A horizon needs √A = 0, so 1 + u = ∞, so n = ∞:
+ * a node would have to have INFINITELY MANY WAYS OUT. Each annihilation adds
+ * one and a finite mass sends finitely many charges, so it never gets there.
+ * At what general relativity calls the horizon (u₀ = 2) the node has 6.4 extra
+ * ways out per WAYS — a lot, and not infinity. Light leaves, redshifted by
+ * e² = 7.4. That is the sharpest falsifiable claim in this file, and unlike the
+ * rest of it, it is one the astronomers are already testing.
+ *
+ * NOT WIRED IN, deliberately. It changes every measured number in the file by a
+ * fraction of a per cent and the panels have not been re-run. `regimes.ts` has
+ * a `compose` knob for it. What it costs to switch: nothing in the derivation —
+ * it is strictly more derived than what is below, since it needs no A and B
+ * from outside. What it costs in confidence: every table in this file was
+ * measured against the borrowed forms.
+ */
+export const slowingMul = (fold: number) => Math.exp(-2 * Math.max(fold, 0));
+export const thicknessMul = (fold: number) => Math.exp(2 * Math.max(fold, 0));
+
 const S_OF = (fold: number) => Math.max(fold, 0) / 2;
 
-export const slowing = (fold: number) => {
+/**
+ * General relativity's isotropic functions, kept for comparison and no longer
+ * what the file uses. `regimes.ts` reaches them at `compose` = 0.
+ */
+export const slowingIso = (fold: number) => {
   const s = S_OF(fold);
   if (s >= 1) return 0;                              // at or past the horizon
 
@@ -472,11 +591,18 @@ export const slowing = (fold: number) => {
   return q * q;
 };
 
-export const thickness = (fold: number) => {
-  const s = S_OF(fold);
+export const thicknessIso = (fold: number) => Math.pow(1 + S_OF(fold), 4);
 
-  return Math.pow(1 + s, 4);
-};
+/**
+ * AND WHAT THE FILE NOW USES — the compounded count, derived above.
+ *
+ * `A = e^−2u`, `B = e^+2u`, `A·B = 1`. No horizon: A reaches nought only as
+ * u → ∞, which needs a node with infinitely many ways out. `A/B = e^−4u ≤ 1`,
+ * so light is still the ceiling as a fact about the functions.
+ */
+export const slowing = (fold: number) => Math.exp(-2 * Math.max(fold, 0));
+
+export const thickness = (fold: number) => Math.exp(2 * Math.max(fold, 0));
 
 /**
  * And what a folded place does to the pull itself — the factor the count
@@ -493,6 +619,56 @@ export const thickness = (fold: number) => {
  * its own gets the perihelion and overshoots light by half again. The rest of
  * it is in `pace` and `count` above, where the same folding decides what a
  * count is worth in cells. The two have to move together or neither is right.
+ *
+ * ---------------------------------------------------------------------------
+ * AND IT IS NO LONGER BORROWED. This was the last thing in the file taken from
+ * general relativity. Three things built separately turn out to be one chain.
+ *
+ * FIRST, THE EDGE COUNT SLOWS THE CLOCK BY √A. The checkerboard's clock is the
+ * REVERSAL rate — the chance of taking the one turning direction rather than
+ * carrying on — which at an unfolded node is 1 in WAYS and at a folded one is
+ * 1 in WAYS + n. So `m_eff = m·WAYS/(WAYS+n) = m/(1+u)`, and the compounding
+ * already says `1 + u = e^{u₀}`:
+ *
+ *     u₀      m_eff/m = e^−u₀   √A = √(e^−2u₀)    diff
+ *     0.010   0.990049834       0.990049834       1.1e−16
+ *     0.100   0.904837418       0.904837418       0.0e+0
+ *     1.000   0.367879441       0.367879441       0.0e+0
+ *
+ * — identical. GRAVITATIONAL TIME DILATION IS THE EDGE COUNT THINNING OUT THE
+ * REVERSALS, and it is the same √A the metric already has. The clock and the
+ * metric are one statement, not two.
+ *
+ * SECOND, THE PHASE IS ω·τ (measured to nine figures, see `field.ts`), so the
+ * classical path EXTREMISES PROPER TIME — which is what stationary phase does
+ * to a sum over paths, and that was measured too (the free propagator came out
+ * at the straight-line action plus π/4).
+ *
+ * THIRD, THAT IS THIS FUNCTION. For `−A dt² + B dx²` the Lagrangian is
+ * `L = −m√(A − Bv²)` and Euler–Lagrange gives `dp/dt = −(A′ − B′v²)/(2W)` with
+ * `W = √(A − Bv²)`. Against `carry`:
+ *
+ *     u       p      carry(p,u)      stationary phase   ratio
+ *     0.001   0.50   1.339674870     1.339674870        1.000000000
+ *     0.010   1.50   2.992139121     2.992139122        1.000000000
+ *     0.100   1.50   2.514149638     2.514149637        1.000000000
+ *
+ * worst departure 1.0·10⁻⁷, which is the finite difference and not the physics.
+ * THE SAME FUNCTION. `carry` is not an extra rule — it is the stationary-phase
+ * limit of the model's own path sum, in the metric the model's own edge
+ * counting gives.
+ *
+ * WHAT IS STILL OWED, and it is one thing rather than a category: the
+ * checkerboard was built and MEASURED in flat space, with a reversal amplitude
+ * `sin(m)` constant everywhere. The step above lets m vary from place to place
+ * as `m·e^{−u₀}` and assumes stationary phase still picks the classical path.
+ * That is standard for a slowly varying mass term and it has not been run here
+ * — a position-dependent checkerboard is a day's work and has not been done.
+ *
+ * So the chain closes analytically and its last link is unmeasured. That is a
+ * different kind of debt from "this is general relativity's equation", and it
+ * is a runnable test rather than an open question. `regimes.ts` tracks it under
+ * `untested` rather than `borrows`.
  */
 export const carry = (px: number, py: number, fold: number) => {
   const A = slowing(fold), B = thickness(fold);
@@ -502,13 +678,13 @@ export const carry = (px: number, py: number, fold: number) => {
   const H = Math.sqrt(A * (1 + p2 / (LIGHT * LIGHT * B)));
   if (!(H > 1e-12)) return 0;                        // nothing left to turn
 
-  // Differentiated against the fold, and these are the closed forms' own
-  // derivatives rather than the series' — −2 and +2 at the origin, as they
-  // have to be. See `slowing`.
-  const s = S_OF(fold);
+  // Differentiated against the fold — −2 and +2 at the origin, as they have to
+  // be, and the exponential is its own derivative so there is nothing else to
+  // get wrong. See `slowing`.
+  const u = Math.max(fold, 0);
 
-  const dA = s >= 1 ? 0 : -2 * (1 - s) / Math.pow(1 + s, 3);
-  const dB = 2 * Math.pow(1 + s, 3);
+  const dA = -2 * Math.exp(-2 * u);
+  const dB = 2 * Math.exp(2 * u);
 
   const dAB = (dA * B - A * dB) / (B * B);
 
@@ -1598,16 +1774,154 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  * surplus too slowly and it piles up. The fix is PERSISTENCE: with mean cosine
  * `a` between successive steps, D scales by (1+a)/(1−a), so
  *
- *     a = 0.8154        keep your heading about 85% of the time
- *     1/(1−a) = 5.42 steps = 10.21 cells = π·WAYS/SHEET
+ *     p = 0.8154        keep your heading about 85% of the time
+ *     1/(1−p) = 5.42 steps = ⟨ℓ⟩/(1−p) = 7.67 cells
+ *
+ * — and the closed form was checked against a measured walk, agreeing to about
+ * a per cent from p = 0 to p = 0.9, so the number is right.
+ *
+ * AND A CLAIMED COINCIDENCE HERE WAS SPURIOUS, which is worth recording because
+ * it was nearly chased. This said the run length was "10.21 cells = π·WAYS/SHEET,
+ * a pure count". It is not. 10.21 is `3D/c`, which IS `π·WAYS/SHEET` BY
+ * CONSTRUCTION — it is `SPREAD` rewritten, not a second fact about anything.
+ * The physical run length is 7.67 cells, and the two differ by 33%. The
+ * appearance of a pure count sitting in plain sight came from comparing a
+ * transport mean free path with a persistence length as though they were the
+ * same quantity. There is no coincidence to chase.
  *
  * The two extremes bracket it and neither is right: a straight-line surplus
- * (a = 1) gives 1/r², a fresh-direction one (a = 0) gives 1/r nine times too
- * strong. But the character of the debt has changed completely — it is now a
+ * (p = 1) gives 1/r², a fresh-direction one (p = 0) gives 1/r nine times too
+ * strong. The character of the debt has still changed completely — it is now a
  * PERSISTENCE IN THE HOPPING RULE, which the lattice may simply have, rather
  * than a mean free path against a vacuum that provably cannot supply one. An
  * unfixed rule, not a contradiction.
  *
+ * WHAT COULD SUPPLY p = 0.815. Whatever turns the hopping point must be
+ * UNIFORM IN SPACE, because a turner whose density varies with r gives a D that
+ * varies with r and then the profile is not 1/r at all. Three candidates:
+ *
+ *   the body's own charges   density ∝ 1/r² ⇒ D(r) ∝ r² ⇒ profile 1/r³. Fails
+ *                            on shape, like everything built from `chance`.
+ *   the ambient field        uniform, but the turning rate goes as Φ, and one
+ *                            turn per 5.4 ticks wants Φ ~ 0.37 against the
+ *                            ≲3·10⁻⁴⁸ the reach allows. Forty-five orders —
+ *                            the same wall everything sourced from Φ has hit.
+ *   the lattice itself       uniform, no Φ, works — and then p is a constant of
+ *                            the hopping rule, put in by hand.
+ *
+ * So the third is the only survivor and it is not a derivation.
+ *
+ * ---------------------------------------------------------------------------
+ * AND BOTH WAYS OUT OF THAT WERE TESTED, AND BOTH CLOSE — by argument this
+ * time, rather than by a measurement coming out wrong.
+ *
+ * FIRST: IS THE UNIFORMITY A THEOREM? Let the turner have density ∝ r^−n, so
+ * D ∝ r^n. The steady flux `4πr²·D·(−dδ/dr) = S` gives `δ ∝ 1/r^(1+n)`, and
+ * solved on a radial grid rather than taken on trust:
+ *
+ *     n      fitted exponent of δ     wanted
+ *     −0.5   0.6085                   0.5
+ *      0.0   1.0348                   1.0     ← the only one that is 1/r
+ *      0.5   1.5103                   1.5
+ *      1.0   2.0030                   2.0
+ *      2.0   3.0004                   3.0
+ *
+ * Only n = 0 works, so D MUST BE CONSTANT and the turner MUST BE UNIFORM. That
+ * is forced, not preferred. And the model contains exactly two uniform things:
+ * the lattice itself, and the ambient field Φ — every body's own charges go as
+ * 1/r², the surplus goes as 1/r, and all other bodies' fields sum to Φ. Φ is
+ * forty-five orders short. So the turner is the lattice.
+ *
+ * WHICH DOES NOT DELIVER THE NUMBER, and this is the part that was not
+ * expected. If the turner is the lattice — the neutral points that space is
+ * made of, one to a cell — then a hopping surplus meets one EVERY HOP, so it
+ * turns every tick and p = 0. That is precisely the measured case: D = 0.3462
+ * and gravity nine times too strong. Getting p = 0.815 needs the encounter to
+ * turn it only 18.5% of the time, and that fraction is a bare number with no
+ * counting behind it. So the uniformity theorem does not rescue p — it shows
+ * that the only admissible turner gives the WRONG p, and the right one has no
+ * mechanism at all.
+ *
+ * SECOND: A SURPLUS THAT NEVER MOVES. Created from the flux passing through and
+ * removed in place — no transport, no Φ. With removal ∝ δ^q·r^−b the steady
+ * state is `δ ∝ m^(1/q)/r^((2−b)/q)`, and two things must hold at once:
+ *
+ *     q    b     δ goes as        shape   mass
+ *     1    0     m /r²            no      yes
+ *     1    1     m /r             yes     yes    ← needs a 1/r partner
+ *     2    0     √m /r            yes     NO     ← the tempting one
+ *     2    1     √m /√r           no      no
+ *
+ * `q = 2, b = 0` looks like the answer: a surplus annihilating against ITSELF
+ * gives 1/r exactly, static, with no transport and no Φ. It fails on the one
+ * thing no gravity survives — δ ∝ √m, so the pull would go as the square root
+ * of the mass. The only row that satisfies both wants a removal partner with a
+ * 1/r density, and the model has nothing with a 1/r density except the surplus,
+ * and using that makes it q = 2 again.
+ *
+ * ---------------------------------------------------------------------------
+ * AND THEN THE WHOLE TARGET MOVED, which is worth more than any of the above.
+ *
+ * All of it assumed B needs ITS OWN SOURCE — a surplus, made somewhere, carried
+ * somehow. But the file's own `METRIC` story says otherwise: a place has
+ * WAYS + n ways out, the LEAN is a ratio (that is A) and the TOTAL is what a
+ * ratio throws away (that is B). Same count, read twice. If that is right, B is
+ * not sourced separately at all and the surplus programme was solving a problem
+ * that is not there.
+ *
+ * So test it, because it is a claim with numbers: A and B carry exactly two
+ * pieces of information the pull does not fix — γ (space per unit potential)
+ * and β (how nonlinear the time part is) — and both are measured.
+ *
+ *     account                                     γ       β     perihelion  deflection
+ *     GR, isotropic — what the file uses          1.000   1.000   1.0001     1.0000
+ *     √A = WAYS/(WAYS+n), √B = (WAYS+n)/WAYS      1.000   1.500   0.8334     1.0000
+ *     A·B = 1 with B = 1 + 2u exactly             1.000   2.000   0.6668     1.0000
+ *     Newton, no metric                           0.000   0.000   0.6667     0.5000
+ *
+ * THE COUNTING STORY GETS γ RIGHT AND β WRONG, and both halves matter.
+ *
+ * γ = 1 FALLS OUT, because A and B read the same count and reading one thing
+ * two ways forces them to agree. That is the actual content of "the same count
+ * read twice", it is not nothing — γ = 1 is what Cassini measures to 2·10⁻⁵ —
+ * and it is got for free, with no surplus, no transport and no D.
+ *
+ * β = 3/2 AGAINST 1, and β is not free: it puts the perihelion advance at
+ * 0.8334 of its value. Five sixths where the file measures 6.05 to 6.20, so it
+ * is not a rounding matter. And light's deflection is untouched at 1.0000,
+ * because that depends on γ alone — so the counting story is wrong in a
+ * diagnostic place rather than uniformly.
+ *
+ * WHY β IS THE HARD ONE. Only `exp(−2u)` gives β = 1:
+ *
+ *     exp(−2u)     1 − 2u + 2u² − …     β = 1     ← GR
+ *     1/(1+u)²     1 − 2u + 3u² − …     β = 3/2
+ *     1/(1+2u)     1 − 2u + 4u² − …     β = 2
+ *
+ * so the count would have to compose MULTIPLICATIVELY rather than by addition.
+ * `BIAS` is explicitly linear — "weight of the way it went, 1 + n" — so as it
+ * stands the model gives 3/2.
+ *
+ * AND THIS IS WHERE MATTER FINALLY BEARS ON IT. β is gravity gravitating: what
+ * a SECOND annihilation at an ALREADY-FOLDED place is worth. A lone count
+ * cannot say — it is a statement about something in a field rather than about
+ * a tally. If folding a place changes what the next annihilation there buys,
+ * the composition is multiplicative and β = 1 follows. That is a specific
+ * mechanism to look for, in the one rule (`BIAS`) that has never been asked
+ * whether it is linear all the way up.
+ *
+ * SO THE GAP IS NOT WHERE THE LAST WEEK PUT IT. It is not a transport rule and
+ * not a diffusivity. It is whether `1 + n` should be `(1 + 1/WAYS)^n`, and that
+ * question is one line of the counting argument rather than a new mechanism.
+ * What follows below stands as the record of the source-and-carry programme,
+ * which is now of interest mainly for the two no-gos it established.
+ *
+ * SO THE STATE OF THE SOURCE-AND-CARRY ROUTE IS WORSE THAN "ONE POSITED CONSTANT". A static surplus
+ * cannot be linear in mass and go as 1/r at once. A hopping surplus can, but
+ * needs a persistence whose only admissible source gives the wrong value. B is
+ * not one constant away from being derived; it is one constant away from being
+ * CONSISTENT, and that constant has no mechanism behind it in either account.
+ *
  * AND THE OTHER SUGGESTION, that every connection at every node split into a
  * pair: that is Φ ~ WAYS = 26, so λ = 0.077 cells and gravity is dead in a
  * tenth of a step — thirteen times worse than the Φ = 2 attractor, which was
@@ -1790,3 +2104,556 @@ export const REACHES = Math.sqrt(
  * are made in exact pairs — no matter/antimatter asymmetry either. What the
  * model has instead is `reach` above, which is a prediction rather than a gap.
  */
+
+/**
+ * WHAT A BLACK HOLE IS, IF THERE ARE NO HORIZONS.
+ *
+ * `slowing` has no zero, so nothing is ever cut off. That leaves the question
+ * of what the objects we call black holes ARE, and the answer does not come
+ * from the metric at all — it comes from screening, which this file already
+ * has. A body's charges annihilate against its OWN field on the way out, so
+ * only a skin of thickness λ ever reaches the outside.
+ *
+ * A BODY LOOKS LIGHTER THAN IT IS. With `Φ = ρ·SHEET·R` inside a ball of
+ * density ρ and radius R, and `λ = 1/(BITE·share·Φ)`, the visible fraction is
+ * `3∫₀¹ s²e^{−x(1−s)}ds` with `x = R/λ`:
+ *
+ *     body           ρ (kg/m³)   R (m)      R/λ        M_eff/M
+ *     Earth          5.51e+3     6.37e+6    1.07e−8    1.000000
+ *     Sun            1.41e+3     6.96e+8    3.25e−5    0.999992
+ *     white dwarf    1.00e+9     7.00e+6    2.33e−3    0.999417
+ *     neutron star   5.00e+17    1.20e+4    3.43e+0    0.508504
+ *
+ * Ordinary matter is transparent. A NEUTRON STAR IS NOT — it shows about half
+ * its mass. That is the model's second falsifiable claim and it looks worse
+ * for it than the first: pulsar timing measures neutron-star masses directly,
+ * and a factor of two in baryon content is far outside any equation of state.
+ *
+ * AND FOR R ≫ λ IT IS HOLOGRAPHIC. `M_eff/M → 3λ/R`, so `M_eff → 4πR²λρ` — the
+ * AREA and not the volume (measured: 0.029406 against 3/x = 0.030000 at
+ * x = 100, 0.002994 against 0.003000 at x = 1000). The interior is sealed off
+ * not by a horizon but by its own opacity, and what the universe knows about a
+ * big clump is a surface.
+ *
+ * AND AT MAXIMUM DENSITY IT CANNOT BECOME A BLACK HOLE. Once a tick is the
+ * ceiling (see `mass` in `physics.ts`) the densest matter is one emitter per
+ * cell, ρ = 1. Then `Φ = SHEET·R`, `λ = 1/(BITE·share·SHEET·R)`, and
+ *
+ *     M_eff = 4πR²λρ = 4πR/(BITE·share·SHEET) = πR
+ *
+ * — which is Schwarzschild's own M ∝ R. So the ratio is the same at every
+ * scale, and it is a pure count:
+ *
+ *     R/R_s = 1/(2πG) = 2π·WAYS/SHEET² = 2.5525
+ *
+ * measured at 2.5525 from R = 10¹⁰ to 10⁴⁰ cells. THE DENSEST THING THE LATTICE
+ * PERMITS SITS AT TWO AND A HALF OF ITS OWN SCHWARZSCHILD RADII AND CAN NEVER
+ * BE INSIDE. So black holes do not fail to form because the metric lacks a
+ * horizon — they fail because MATTER RUNS OUT OF ROOM FIRST, and those are two
+ * independent facts that happen to agree.
+ *
+ * AND NO, THE LEAKAGE IS NOT HAWKING RADIATION. At the surface of such an
+ * object `u = G·M_eff/R = πG = 0.1959`, which is `1/(2·R/R_s)` as it must be,
+ * so light leaves redshifted by `e^−u = 0.822`. An 18% shift, M-INDEPENDENT —
+ * the same for a stellar-mass object and a galactic one. Hawking needs
+ * `T ∝ 1/M` and a lifetime `∝ M³`; this gives `T ∝ M⁰` and no evaporation at
+ * all, because nothing is trapped to begin with. The "arbitrarily slow, never
+ * quite vanishing" path is ordinary light climbing out of a shallow well, and
+ * it is not even slow.
+ *
+ * WHICH IS THE REAL PROBLEM HERE, and it is worth stating plainly rather than
+ * filing under predictions: THE MODEL HAS NO DARK COMPACT OBJECTS AT ALL. Not
+ * merely no horizons — nothing even substantially redshifted, since 18% is what
+ * the densest permitted matter manages. Against EHT shadows and merger
+ * ringdowns that is a far heavier bill than the missing Hawking radiation, and
+ * it is the sharpest thing in this file that observation can settle.
+ */
+
+/**
+ * AND WHAT WOULD GIVE BACK THE DARK COMPACT OBJECTS — which is NOT `carry`.
+ *
+ * `carry` is `dp/dt`: what a count is worth once the place is folded. It is in
+ * the equation of motion and nowhere else, while darkness is a statement about
+ * light, which the metric alone fixes —
+ *
+ *     redshift        1/√A          A alone
+ *     light's speed   c√(A/B)       A and B
+ *     a horizon       A = 0         A alone
+ *
+ * — so changing `carry` moves orbits and not one of those three. Whatever
+ * replaces it, it cannot make anything dark. Worth being exact about, because
+ * `carry` is the last borrowed thing and it is tempting to hang the remaining
+ * problems on it.
+ *
+ * THE BLOCKER IS THE SELF-SCREENING. With it, a max-density ball shows
+ * `M_eff = πR`, so `R/R_s = 2.5525` at every size — a floor. Without it,
+ * `M = (4/3)πR³` and `R/R_s = 3/(8πGR²)`, which falls as R² and crosses one at
+ * R = 1.384 cells:
+ *
+ *     R (cells)   screened R/R_s   unscreened R/R_s   u = GM/R
+ *     1.38        2.5525           1.005e+0           4.974e−1
+ *     10          2.5525           1.914e−2           2.612e+1
+ *     1e+6        2.5525           1.914e−12          2.612e+11
+ *
+ * and u grows without bound, so `e^−u` becomes arbitrarily extreme:
+ *
+ *     R = 5 cells    u = 6.53      redshift 1.5e−3
+ *     R = 10         u = 26.1      redshift 4.5e−12
+ *     R = 50         u = 653       redshift 2.7e−284
+ *
+ * A ball fifty cells across is dark to one part in 10²⁸³. SO THE MODEL DOES NOT
+ * NEED HORIZONS TO HAVE BLACK HOLES — it needs the screening not to cap the
+ * mass. Which reframes the whole complaint: the exponential metric was never
+ * the problem, and no-horizon is compatible with objects as dark as observed.
+ *
+ * AND THE MECHANISM THAT LIFTS THE CAP IS ALREADY HERE — but not the one first
+ * proposed. Self-screening is a body's charges ANNIHILATING against its own
+ * field, annihilation needs OPPOSITE charges, and `coherence` says two of the
+ * same thing IN STEP do not cancel at all. The condition for in-step is
+ * `R < 2π/m`, the Compton wavelength — see `inStep` below, where the first
+ * version of this argument had the sign backwards and said the CEILING was
+ * coherent. It is the least coherent thing there is.
+ *
+ * So the cap lifts for LIGHT constituents: `m < 2π/R`, below 6·10⁻¹² eV for a
+ * twelve-kilometre object. An upper bound rather than a knife edge.
+ *
+ * WHAT IT DOES NOT FIX: ordinary matter is thirty orders the wrong side of that
+ * bound. A neutron star's protons are coherent only out to a fermi, so share
+ * stays at ½, R/λ = 3.43, and it still shows about half its mass — and any
+ * baryonic object caps at u = 0.196 however hard it is squeezed. Dark compact
+ * objects are possible in this model, and not out of the matter we know.
+ *
+ * TWO SEPARATE FAILURES, THEN — one now with a mechanism and one without — and
+ * neither of them `carry`. `carry` remains the last borrowed thing and remains
+ * a question about the equation of motion, unconnected to any of this.
+ */
+
+/**
+ * HOW MUCH OF A BODY THE OUTSIDE ACTUALLY SEES — and the distinction the rest
+ * of this file had been eliding.
+ *
+ * BEING IN THE WAY IS NOT SCREENING. `through` in `field.ts` says a charge
+ * arriving at an occupied cell either ANNIHILATES or TURNS THE OTHER ROUND.
+ * Both are "in the way". Only one of them takes anything away:
+ *
+ *     annihilate   the charge is destroyed     flux falls      mass is screened
+ *     scatter      the charge is redirected    FLUX CONSERVED  mass is not
+ *
+ * and which happens is decided by `opposed` — alike charges scatter, opposite
+ * ones annihilate. A distant body feels FLUX, so only annihilation can reduce
+ * what it feels.
+ *
+ * MEASURED. Charges streaming out of a source, mean free path to MEET anything
+ * fixed at 20 cells, varying only what a meeting DOES. Flux crossing r, per
+ * charge emitted:
+ *
+ *     share   meaning                      r=10     r=30     r=100    r=250
+ *     0.00    in step — scatter only       1.0000   1.0000   1.0000   1.0000
+ *     0.10    mostly in step               0.9437   0.7976   0.2925   0.0129
+ *     0.50    incoherent, the usual case   0.7573   0.3968   0.0266   0.0000
+ *     1.00    fully opposed                0.5982   0.2191   0.0063   0.0000
+ *
+ * At share = 0 the flux is ONE at every radius. Those charges are maximally in
+ * each other's way — scattering every twenty cells, random-walking rather than
+ * streaming — and not one is lost. BEING IN THE WAY DELAYS A CHARGE; IT DOES
+ * NOT REMOVE IT.
+ *
+ * (And at share = ½ the fall-off is FASTER than pure absorption, because
+ * scattering lengthens the path and so exposes the charge to more chances of
+ * meeting something opposite. The two processes are not independent.)
+ *
+ * SO THE LENGTH THAT SETS `shows` IS THE ANNIHILATION LENGTH, `1/(BITE·share·Φ)`
+ * — which is the one `reach` already uses. `share` was always in that formula.
+ * Nothing new is introduced here; it is read properly for the first time.
+ *
+ * WHICH IS WHAT LETS DENSE MATTER KEEP ITS MASS. At the ceiling every emitter
+ * pulses once a tick and one global tick puts them all in step, so `share → 0`,
+ * so nothing annihilates, so `shows → 1` however big the body is. The densest
+ * matter is exactly the matter that cannot screen itself — see the note above
+ * on dark compact objects, which is what this pays for.
+ *
+ * IT IS NOT FREE, THOUGH. Coherent matter scatters its own charges hard, so
+ * they leave by a random walk rather than a straight line: the flux gets out,
+ * but in `r²/λ` steps instead of `r`. That is a statement about how fast such
+ * an object can RESPOND, not about its mass, and nothing here has worked out
+ * what it costs.
+ */
+export const shows = (
+  density: number, R: number, share = 0.5,
+) => {
+  const lam = share > 0 ? 1 / (BITE * share * density * SHEET * R) : Infinity;
+  const x = R / lam;
+
+  if (!(x > 1e-3)) return 1 - x / 4 + x * x / 20;    // series; no cancellation
+  // 3∫₀¹ s²e^{−x(1−s)}ds, written without any e^{+x} so it cannot overflow
+  return 3 * (1 / x - 2 / (x * x) + 2 / (x ** 3)) - 6 * Math.exp(-x) / (x ** 3);
+};
+
+/**
+ * HOW FAR A BODY IS IN STEP WITH ITSELF — and this had the sign backwards.
+ *
+ * It said: at the CEILING every emitter pulses once a tick, one global tick
+ * puts them all on the same tick, so they are in step. That conflates two
+ * different things, and the difference is the whole answer.
+ *
+ * Pulsing on the same tick is not being in step WHERE THE CHARGES MEET. Two
+ * emitters a distance Δr apart, both at ω = m, arrive at a meeting point with
+ * a phase difference `ω·Δr/c`. In step there needs
+ *
+ *     m · R  ≪  2π       i.e.   R  ≪  2π/m  =  THE COMPTON WAVELENGTH
+ *
+ * which is exactly what `coherence` already says — two of the same thing hold
+ * a phase only closer than a Compton wavelength. And `2π/m` is LARGE for a
+ * LIGHT emitter, so coherence wants light constituents and the ceiling is the
+ * WORST case, not the best:
+ *
+ *     at the ceiling      m = 1          coherent out to 1.0·10⁻³⁴ m
+ *     proton              9.4·10⁸ eV     8.2·10⁻¹⁶ m
+ *     neutrino, 0.1 eV                   7.8·10⁻⁷ m
+ *     fuzzy dark matter, 10⁻²² eV        7.8·10¹⁴ m — a thousand AU
+ *
+ * SO A DARK COMPACT OBJECT NEEDS `m < 2π/R`: below 6.4·10⁻¹² eV for something
+ * twelve kilometres across, below 2.6·10⁻¹¹ eV for a solar mass at its own
+ * Schwarzschild radius. AN UPPER BOUND, NOT A KNIFE EDGE — a constituent ten
+ * times under it is as coherent as one a million times under — so there is no
+ * fine-tuning, which is what the ceiling story wrongly implied.
+ *
+ * And the bound has a name: it is the condition for the whole object to be one
+ * quantum state, which is what a condensate or a boson star is.
+ *
+ * WHAT IT COSTS INSTEAD, and this is now the honest bill: dark compact objects
+ * exist in this model only if there is ULTRALIGHT MATTER to make them of. That
+ * is a claim about particle content rather than about gravity, and it says the
+ * things we call black holes are not collapsed baryons. Ordinary matter is out
+ * by some thirty orders and caps at u = 0.196 however hard it is squeezed.
+ *
+ * STILL A PROPOSAL in one respect: it extends `coherence`, argued for two
+ * identical elementary things, to a bulk of many. And it has a corollary
+ * nobody has chased — perfectly coherent matter would have no INTERNAL gravity
+ * either, since the same condition sends G_eff to nought between its own parts.
+ */
+export const inStep = (mass: number, R: number) =>
+  Math.min(1, (2 * Math.PI / Math.max(mass, 1e-300)) / Math.max(R, 1e-300));
+
+/** …and so what `share` a body of that size and constituent has. */
+export const sharing = (mass: number, R: number) =>
+  0.5 * Math.min(1, mass * R / (2 * Math.PI));
+
+/**
+ * SO HOW WOULD A DARK OBJECT FORM — and it does not need exotic matter after
+ * all, which reverses the conclusion two comments up.
+ *
+ * `R < 2π/m` is a condition on R every bit as much as on m, and the previous
+ * note only read it one way. Five permutations were tried:
+ *
+ *   lighter constituents   works, and is what was found first — but it is not
+ *                          the only way, and it was wrongly reported as if it
+ *                          were, which put black holes out of reach of ordinary
+ *                          matter for no good reason.
+ *   a hollow shell         no. A point inside a thin shell sees a TANGENTIAL
+ *                          chord of √(2Rt), not t — 77 m for a kilometre shell
+ *                          a metre thick. Geometry cannot beat a fermi.
+ *   a phase ramp           no. A phased array aligns one direction and
+ *                          misaligns the rest; screening samples all pairs
+ *                          inside, so it redistributes share over angle rather
+ *                          than lowering it.
+ *   net charge             not available. `neutral → + −` makes them in pairs,
+ *                          so a body emits both by construction.
+ *   COLLAPSE FURTHER       yes, and it is the answer.
+ *
+ * SQUEEZE ORDINARY MATTER BELOW ITS OWN COMPTON WAVELENGTH and it self-coheres.
+ * The screening does not switch off — it weakens smoothly, so the observed
+ * potential is `min(u_cap, u_free)` with `u_cap = 16π²G/(m·R·SHEET)`, and the
+ * cap itself RISES as R falls:
+ *
+ *     R (m)      R/λ_C      share      u_cap     u_free     u        redshift
+ *     2.95e+3    3.58e+19   5.00e−1    1.96e−1   5.01e−1    1.96e−1  0.822
+ *     1.00e−15   1.21e+1    5.00e−1    1.96e−1   1.48e+18   1.96e−1  0.822
+ *     1.00e−17   1.21e−1    6.07e−2    1.61e+0   1.48e+20   1.61e+0  0.199
+ *     1.00e−19   1.21e−3    6.07e−4    1.61e+2   1.48e+22   1.61e+2  8e−71
+ *     1.14e−22   1.38e−6    6.92e−7    1.42e+5   1.30e+25   1.42e+5  < 1e−300
+ *
+ * Dark (u > 30) once `R < 16π²G/(m·SHEET·30)` — 5.4·10⁻¹⁹ m for protons, about
+ * a thousandth of a fermi, and further out for anything lighter (10⁻¹⁵ m for
+ * electrons, 5·10⁻⁹ m for a 0.1 eV neutrino). NO ULTRALIGHT MATTER NEEDED.
+ *
+ * AND THE COLLAPSE HAS NOTHING TO STOP IT. In general relativity a star reaches
+ * its horizon and is done. Here no radius is marked, so it simply continues —
+ * and on the way it passes through the screened regime as a compact object with
+ * u pinned at 0.196, which is NOT a support: screening attenuates only what
+ * LEAVES, while the internal field between neighbours is short-range and
+ * unscreened. Nothing holds it up, so it keeps going until the lattice ceiling
+ * at ρ = 1. A solar mass ends as a ball 1.1·10⁻²² m across.
+ *
+ * WHAT AN OBSERVER SEES IS UNCHANGED, because that is fixed by the metric a few
+ * Schwarzschild radii out, where u ~ ½ and the exponential and isotropic forms
+ * agree closely. There is still a photon sphere and still a shadow. What
+ * differs is what sits at the middle — a ball of ceiling-density matter rather
+ * than a singularity — and that nothing was ever causally severed.
+ *
+ * WHICH LEAVES THE BILL SHORTER THAN IT WAS. Dark compact objects form from
+ * ordinary collapse. The neutron star keeps its problem — at 1.2·10⁴ m it is
+ * twenty orders too big to cohere, so it still shows about half its mass, and
+ * that is still outside any equation of state.
+ */
+
+/**
+ * AND WHAT IF MATTER IN A FOLDED PLACE CAN EMIT MORE — a second feedback, and
+ * the one that would restore horizons.
+ *
+ * A node that has taken n annihilations has WAYS + n edges. `SHEET` is how many
+ * of them a pulse goes into, so a source SITTING THERE lets go of
+ * `SHEET·(WAYS+n)/WAYS = SHEET·(1+u)` charges a pulse. Emission is mass, so
+ *
+ *     M_eff = M·(1 + κu)          κ = 1 if the sheet scales with the edges
+ *
+ * — a feedback on the SOURCE, where the earlier one (`du = du₀(1+u)`) was a
+ * feedback on the TRANSPORT. The once-a-tick ceiling stops being the ceiling,
+ * because the ceiling was on how OFTEN, not on how MANY.
+ *
+ * IT MAKES THE FOLD SELF-CONSISTENT, AND THAT DIVERGES:
+ *
+ *     u = u₀(1 + κu)   ⇒   u = u₀/(1 − κu₀)
+ *
+ *     u₀     u at κ=1    A = e^−2u
+ *     0.30   4.286e−1    4.244e−1
+ *     0.90   9.000e+0    1.523e−8
+ *     0.99   9.900e+1    1.023e−86
+ *     1.00   ∞           0            ← A HORIZON, at r = GM/c²
+ *
+ * So this restores horizons, which the arrival feedback alone could not: e^{u₀}
+ * never diverges at finite u₀, and this does.
+ *
+ * BUT IT MOVES β, AND β IS MEASURED. `A = exp(−2u₀/(1−κu₀)) = 1 − 2u₀ +
+ * (2−2κ)u₀² + …`, so `β = 1 − κ`:
+ *
+ *     κ        β        perihelion (2+2γ−β)/3
+ *     0.0001   0.9999   1.00003    allowed
+ *     0.01     0.99     1.00333    EXCLUDED, 0.3% high
+ *     1.0      0        1.33333    EXCLUDED, 33% high
+ *
+ * β is known to about 3·10⁻⁴ from lunar laser ranging and Mercury. At κ = 1 the
+ * advance is EIGHT SIXTHS where the panels measure six. SO A BOOST LINEAR IN u
+ * IS EXCLUDED OUTRIGHT, by three thousand.
+ *
+ * IT SURVIVES ONLY AS A DEEP-FIELD EFFECT. β is a statement about the u² term,
+ * so a boost beginning at u³, or above a threshold, leaves the weak field alone
+ * and still diverges eventually. And the threshold is not invented: `BIAS`
+ * saturates as `n/(WAYS+n)`, which turns over when n ~ WAYS, i.e. u ~ 1 — which
+ * is where the counting argument already changes character, and is exactly
+ * where the divergence would sit.
+ *
+ * WHAT IT KEEPS AND WHAT IT COSTS:
+ *
+ *   the pull, G, met(R)          KEPT. u ~ 10⁻⁸, so the boost is nothing.
+ *   REACHES = 0.361              KEPT. A vacuum property, no fold in it.
+ *   E = ħω, λ = h/p, Dirac       KEPT. Nothing to do with gravity.
+ *   A, B and β = γ = 1           KEPT ONLY IF the boost starts above u².
+ *   no horizons                  LOST — and that is the point.
+ *   the R/R_s = 2.55 floor       LOST. The fold runs away before it applies.
+ *   dark objects need R < λ_C    LOST. A horizon does it directly, so the
+ *                                coherence-and-collapse story is no longer
+ *                                needed — though nothing shown about it is
+ *                                wrong, it just stops being load-bearing.
+ *   neutron star at half mass    UNTOUCHED, and slightly WORSE: at u ~ 0.2 a
+ *                                boost raises emission ~20%, which raises Φ,
+ *                                which screens harder.
+ *
+ * So it cannot be the fix for both problems, and it buys horizons at the price
+ * of a threshold nobody has derived. What would settle it is whether `SHEET`
+ * really scales with a node's edge count or is fixed by the dimension — which
+ * is a question about what a pulse IS, and `field.ts` currently says the latter
+ * (`3^(d−1) − 1`, a property of the lattice and not of the place).
+ */
+
+/**
+ * TWO WAYS TO MAKE A DARK OBJECT, AND THE MODEL KEEPS BOTH.
+ *
+ * They are not rivals to be settled by argument — they predict different
+ * things, so they are settled by looking. `regimes.ts` carries `boost` for the
+ * second; at 0 the model says the first.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * ROUTE ONE — DARK BY REDSHIFT. No horizon anywhere.
+ *
+ * Collapse past λ_C, the matter self-coheres, `share → 0`, the screening cap
+ * lifts and `u = GM/rc²` grows without bound. `A = e^−2u` never reaches nought,
+ * so nothing is ever cut off; the object is dark because e^−u is small, and a
+ * solar mass ends as a ball 1.1·10⁻²² m across at the lattice ceiling.
+ *
+ *   costs nothing        no new parameter, no threshold — it follows from
+ *                        `coherence` and the once-a-tick ceiling, both already
+ *                        in the model
+ *   there is a surface   light leaves, arbitrarily redshifted, never severed
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * ROUTE TWO — DARK BY HORIZON. A genuine one.
+ *
+ * A node with WAYS + n edges has more ways for a source SITTING THERE to pulse
+ * into, so `SHEET → SHEET(1+u)` and emission — which is mass — is boosted:
+ *
+ *     M_eff = M(1 + κu)   ⇒   u = u₀/(1 − κu₀)
+ *
+ *     u₀     u at κ=1    A = e^−2u
+ *     0.30   4.286e−1    4.244e−1
+ *     0.90   9.000e+0    1.523e−8
+ *     1.00   ∞           0            ← a horizon, at r = GM/c²
+ *
+ * This is a feedback on the SOURCE where the compounding was a feedback on the
+ * TRANSPORT, and unlike `e^{u₀}` it diverges at finite u₀. The once-a-tick
+ * ceiling stops binding because the ceiling was on how OFTEN, not how MANY.
+ *
+ *   costs a threshold    `β = 1 − κ`, and β is known to 3·10⁻⁴. At κ = 1 the
+ *                        perihelion advance is EIGHT sixths where the panels
+ *                        measure six — 33% high, excluded by three thousand.
+ *                        So the boost must begin above u², at a threshold
+ *                        nobody has derived. `BIAS` saturating as n/(WAYS+n)
+ *                        turns over at n ~ WAYS, i.e. u ~ 1, which is at least
+ *                        where such a threshold would naturally sit.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHAT SEPARATES THEM, which is the useful part:
+ *
+ *     both               a photon sphere and a shadow — the metric a few R_s
+ *                        out is the same, so images do not distinguish them
+ *     route one          a surface. Ringdown echoes, no information loss,
+ *                        arbitrarily red but finite escape
+ *     route two          a true horizon. Standard black-hole phenomenology,
+ *                        clean ringdown, causal severance
+ *     route one          needs collapse below λ_C — a definite radius with no
+ *                        free parameter (5·10⁻¹⁹ m for protons)
+ *     route two          needs a threshold whose position is not fixed by
+ *                        anything counted yet
+ *
+ * WHAT NEITHER FIXES: the neutron star still shows about half its mass. Route
+ * two makes it marginally worse, since a boost at u ~ 0.2 raises emission and
+ * so raises Φ and so screens harder. That bill is outstanding under both.
+ *
+ * AND WHAT WOULD SETTLE ROUTE TWO from inside the model: whether `SHEET` scales
+ * with a node's edge count or is fixed by the dimension. `field.ts` currently
+ * says the latter — `3^(d−1) − 1`, a property of the lattice rather than of the
+ * place — so route two needs that reading changed, and route one does not.
+ */
+
+/**
+ * SCALING `SHEET` WITH THE EDGE COUNT, AND TYING THE MASS CEILING TO IT —
+ * which turns out to be TWO proposals, and only one of them survives.
+ *
+ *   (A) EACH EMITTER EMITS MORE.  SHEET → SHEET(1+u), so a given mass placed
+ *       deep radiates harder: M_eff = M(1+u).
+ *   (B) A CELL HOLDS MORE EMITTERS. The ceiling on DENSITY scales, ρ_max → 1+u,
+ *       while each emitter emits exactly what it always did.
+ *
+ * (A) changes what a FIXED mass does, so it moves β. (B) changes only how much
+ * mass fits somewhere, so it cannot. That is the whole of the difference and it
+ * decides both.
+ *
+ * (A) AND BEING CONSISTENT MAKES IT WORSE. If SHEET scales with the edges then
+ * so does WAYS — both are edge counts — and `G = BITE·SHEET²·LIGHT/(8π²·CORE·WAYS)`
+ * then scales as (1+u) too. With M_eff also boosted, `u = u₀(1+u)²`:
+ *
+ *     what scales                        k     β      perihelion
+ *     nothing (the model as it stands)   0     1.0    1.0000    allowed
+ *     SHEET only                         1     0.0    1.3333    EXCLUDED
+ *     SHEET and WAYS together            2    −1.0    1.6667    EXCLUDED
+ *
+ * TEN SIXTHS where the panels measure six. Keeping the counts consistent
+ * doubles the damage rather than cancelling it, and β is known to 3·10⁻⁴, so
+ * this is out by about seven thousand. (A) survives only above a threshold, as
+ * before; consistency does not rescue it.
+ *
+ * (B) IS SAFE, AND IT GIVES SOMETHING. A fixed mass emits what it always did,
+ * so u = u₀ and β = γ = 1 are untouched. What changes is capacity:
+ *
+ *     ρ_max = 1 + u,   u = GM/R   ⇒   M = (4/3)πR³ / (1 − (4/3)πG R²)
+ *
+ * which DIVERGES at
+ *
+ *     R_c = √(3/4πG) = √(3π·WAYS)/SHEET = 1.9567 cells
+ *
+ * — a pure count. So R_c is approached from below and never passed:
+ *
+ *     R (cells)   M it holds    as M☉        u = GM/R
+ *     1.50000     3.428e+1      2.34e−38     1.425e+0
+ *     1.90000     5.027e+2      3.43e−37     1.650e+1
+ *     1.95669     6.664e+5      4.55e−34     2.124e+4
+ *
+ *     1 M☉        R = 1.956736 cells    u = 4.669e+37
+ *     10⁶ M☉      R = 1.956736 cells    u = 4.669e+43
+ *
+ * EVERY COLLAPSED OBJECT IN THE UNIVERSE IS THE SAME PHYSICAL SIZE — a hair
+ * under two Planck lengths — and differs only in how deep its potential is,
+ * with u ∝ M. Darkness is then automatic: no coherence argument needed, no
+ * horizon needed. Route one gets stronger AND gets a size.
+ *
+ * BUT (A) AND (B) MAY NOT BE SEPARABLE, and that is the thing to settle next.
+ * `m = 1/X` ticks between pulses, and `m ≤ 1` IS "once a tick". If the ceiling
+ * on m rises above one, that is pulsing more often than once a tick, which is
+ * emitting more per tick — which is (A), which is excluded. So the ceiling that
+ * may scale is the one on HOW MANY EMITTERS A CELL HOLDS, not on how heavy a
+ * single emitter may be.
+ *
+ * Which is a real distinction and a checkable one: (B) says a folded cell fits
+ * more distinct emitters — plausibly one per edge — each of them the same old
+ * `m ≤ 1` thing, with nothing about any single emitter changed anywhere. That
+ * is exactly why β survives, and it is the version to take.
+ */
+
+/**
+ * TWO CELLS ACROSS IN WHICH SENSE — and the one prediction an instrument can
+ * settle now.
+ *
+ * `R_c = 1.9567` is a COORDINATE radius, and nothing measures those. What
+ * anything measures is the AREAL one: the sphere at coordinate r has proper
+ * area `4πr²B`, so
+ *
+ *     r_areal = r·√B = r·e^{u}          B = e^{2u},  u = GM/rc²
+ *
+ * — which is the same statement as "a node with WAYS + n edges touches far more
+ * than a cell's worth of neighbours", measured rather than counted.
+ *
+ * AND IT DOES NOT SHRINK TO NOTHING. `d/dr (r e^{GM/r}) = e^{GM/r}(1 − GM/r)`,
+ * so there is a stationary point at `r = GM/c²`:
+ *
+ *     r (coord)    r_areal      r_areal/R_s
+ *     2 GM         4.869e+3 m   1.6487
+ *     1 GM         4.014e+3 m   1.3591     ← minimum
+ *     0.5 GM       5.456e+3 m   1.8473
+ *     0.25 GM      2.016e+4 m   6.8248
+ *
+ * THE AREA HAS A THROAT, of areal radius `e·GM/c² = (e/2)·R_s = 1.3591 R_s`,
+ * and inside it the area GROWS again without bound. The geometry is not a point
+ * — it is a narrow neck opening into something vast, and the ratio is
+ * scale-free (identical at 1 M☉ and 10 M☉).
+ *
+ * SO THE OBJECT IS TWO CELLS ACROSS AND ENORMOUS AT ONCE. A solar mass at R_c
+ * has u = 4.7·10³⁷, so an areal radius of 10^(2.0·10³⁷) cells — a number with
+ * ten-to-the-thirty-seven digits — and its node carries WAYS(1+u) = 1.2·10³⁹
+ * edges. Those two are the same fact. (That figure uses the EXTERIOR u = GM/r
+ * where the interior solution actually applies; for a uniform ball u_centre is
+ * 1.5× the surface value, so the conclusion is unchanged in kind and the exact
+ * exponent is not to be trusted. The throat below is.)
+ *
+ * AND THE THROAT IS WHAT AN OBSERVER SEES. The photon sphere is where
+ * `d/dr(r²B/A) = 0`; with `B/A = e^{4u}` that is `2r − 4GM = 0`, so `r_ph = 2GM`
+ * — and the shadow's impact parameter is `b = r√(B/A) = r·e^{2u}`:
+ *
+ *     this model   b = 2e·GM/c²    = 5.4366 GM/c² = 2.7183 R_s
+ *     GR           b = 3√3·GM/c²   = 5.1962 GM/c² = 2.5981 R_s
+ *     ratio                          1.0463
+ *
+ * THE SHADOW IS 4.6% LARGER THAN GENERAL RELATIVITY'S AT THE SAME MASS. A
+ * fixed, parameter-free ratio: measure the mass from orbits and the shadow from
+ * imaging and this predicts a constant mismatch between them. It sits inside
+ * the Event Horizon Telescope's present ~10% systematic error and outside what
+ * it is aiming for, so it is a near-term test rather than a philosophical one —
+ * and it is the only thing in this file an existing instrument can settle.
+ */
+export const areal = (r: number, mass: number) =>
+  r * Math.exp(GRAVITY * mass / (r * LIGHT * LIGHT));
+
+/** The narrowest the area gets, in Schwarzschild radii. */
+export const THROAT = Math.E / 2;
+
+/** How much bigger the shadow is than general relativity's. */
+export const SHADOW = 2 * Math.E / (3 * Math.sqrt(3));
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 2678606..de12b6b 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -1599,43 +1599,112 @@ export const Law = () => {
       [<span style={{ color: DERIVED }}>screen</span>,
         <>Three bodies in a row do not simply add. Newton has no such term and
           neither does relativity at this order.</>],
+      [<span style={{ color: DERIVED }}>
+        <V>A</V> = <V>e</V><Sup>−2<V>u</V></Sup>,{' '}
+        <V>B</V> = <V>e</V><Sup>+2<V>u</V></Sup></span>,
+      <><b style={{ color: INK }}>The metric.</b> A folded node has more edges,
+        edges point both ways, so it is easier to arrive at —{' '}
+        d<V>u</V> = d<V>u</V><Sub>0</Sub>(1+<V>u</V>), which integrates to an
+        exponential with nothing chosen. β = γ = 1 both fall out.</>],
+      [<span style={{ color: DERIVED }}><i>carry</i></span>,
+        <><b style={{ color: INK }}>The geodesic equation.</b> The reversal rate
+          thins as 1/(<K>WAYS</K>+<V>n</V>), which is √<V>A</V> exactly — so the
+          clock is the edge count — and stationary phase on ω<V>τ</V> then gives
+          this function to 10<Sup>−7</Sup>.</>],
+      [<span style={{ color: DERIVED }}>
+        six sixths, and 4<V>GM</V>/<V>bc</V><Sup>2</Sup></span>,
+      <><b style={{ color: INK }}>All of it.</b> 6.05, 6.08, 6.07, 6.11, 6.22
+        sixths across the five orbits, measured through the model’s own
+        dynamics rather than off the metric — and the ellipse comes back at
+        −0.00% on every one.</>],
     ]} />
 
     <Head>what is borrowed</Head>
 
     <Note>
-      Kept separate from what is derived, because the difference is the whole
-      state of the thing and it is easy to lose.{' '}
-      <b style={{ color: INK }}>The pull is counted. The metric is not.</b>
+      <b style={{ color: INK }}>Nothing, now.</b> Kept as a section because the
+      distinction is the whole state of the thing and because the last item to
+      leave it did so recently enough to be worth showing.
     </Note>
 
     <Rows of={[
-      [<span style={{ color: BORROWED }}>
-        <V>A</V> = 1 − 2<V>u</V> + 2<V>u</V><Sup>2</Sup>,{' '}
-        <V>B</V> = 1 + 2<V>u</V></span>,
-      <>General relativity’s isotropic functions, written closed rather than as
-        the series. There is a counting <i>story</i> for them — the lean is a
-        ratio and a ratio throws away the total, so <K>WAYS</K> + <V>n</V> ways
-        out means more space — but a story is not a derivation, and the
-        coefficient has never come out. See below.</>],
-      [<span style={{ color: BORROWED }}><i>carry</i></span>,
-        <>The geodesic equation. What a count is worth once the place is
-          folded, which at leading order is 1 + 2<V>v</V><Sup>2</Sup>/<V>c</V><Sup>2</Sup>{' '}
-          — and that alone does not do it, so it is taken whole.</>],
-      [<span style={{ color: BORROWED }}>
+      [<span style={{ color: DERIVED }}><i>carry</i></span>,
+        <><b style={{ color: INK }}>No longer borrowed.</b> The checkerboard’s
+          clock is the <i>reversal</i> rate, 1 in <K>WAYS</K> unfolded and 1 in{' '}
+          <K>WAYS</K>+<V>n</V> folded — so{' '}
+          <V>m</V><Sub>eff</Sub> = <V>m</V>/(1+<V>u</V>) = <V>m e</V><Sup>−<V>u</V><Sub>0</Sub></Sup>{' '}
+          = <V>m</V>√<V>A</V>, identical to machine precision.{' '}
+          <b style={{ color: INK }}>Gravitational time dilation is the edge
+            count thinning out the reversals.</b> The phase is ω<V>τ</V>, so
+          stationary phase extremises proper time — and that is this function,
+          matching Euler–Lagrange to 10<Sup>−7</Sup> at every <V>u</V> and{' '}
+          <V>p</V> tried.</>],
+      [<span style={{ color: DERIVED }}>
+        <V>A</V> = <V>e</V><Sup>−2<V>u</V></Sup>,{' '}
+        <V>B</V> = <V>e</V><Sup>+2<V>u</V></Sup></span>,
+      <><b style={{ color: INK }}>No longer borrowed.</b> A folded node has
+        more edges, and edges point both ways, so it is easier to arrive at —
+        d<V>u</V> = d<V>u</V><Sub>0</Sub>(1+<V>u</V>), which integrates to an
+        exponential with nothing chosen. The lean gives <V>A</V>, the total
+        gives <V>B</V>, <V>A·B</V> = 1, and β = γ = 1.</>],
+      [<span style={{ color: DERIVED }}>
         the other five sixths, and 4<V>GM</V>/<V>bc</V><Sup>2</Sup></span>,
-        <>Everything the metric buys: 6.05 to 6.20 sixths measured, and the
-          whole of light’s deflection, which the lean could not touch at all.
-          Correct to four figures, and <i>correct because A and B were put
-          in</i>.</>],
-      [<span style={{ color: DERIVED }}>how close it came</span>,
-        <><V>u</V> = <V>Gm</V>/<V>rc</V><Sup>2</Sup> as a fact about a place
-          does come out — from a point source of space and a surplus that hops
-          — static, 1/<V>r</V>, and{' '}
-          <b style={{ color: INK }}>wrong in <V>G</V> by 9.83</b>. That factor
-          is the entire remaining distance to a derived metric.</>],
+        <>Re-measured against the compounded metric:{' '}
+          <b style={{ color: INK }}>6.05, 6.08, 6.07, 6.11, 6.22 sixths</b>{' '}
+          across the five orbits, against 6.05…6.20 with the borrowed forms.
+          The shift is +0.005 to +0.020, ordered by depth — the 2PN difference
+          between <V>e</V><Sup>2<V>u</V></Sup> and (1+<V>u</V>/2)<Sup>4</Sup>,
+          and nothing else. Light’s deflection is untouched, since it depends
+          on γ alone.</>],
+      [<span style={{ color: BORROWED }}>what is owed instead</span>,
+        <>A different kind of debt, and a smaller one. The checkerboard was
+          measured in <i>flat</i> space, with a reversal amplitude constant
+          everywhere; letting it vary as <V>m e</V><Sup>−<V>u</V><Sub>0</Sub></Sup>{' '}
+          is standard for a slowly varying mass term and{' '}
+          <b style={{ color: INK }}>has not been run</b>. So the chain closes
+          analytically and its last link is unmeasured —{' '}
+          <i>regimes.ts</i> tracks that under <i>untested</i> rather than{' '}
+          <i>borrows</i>.</>],
     ]} />
 
+    <Head>so is that general relativity</Head>
+
+    <Note>
+      <b style={{ color: INK }}>No, and the difference is the interesting
+        part.</b> Nothing is borrowed any more — <i>borrows</i> returns empty
+      for this model’s own setting — but what came out is not Einstein’s metric.
+      It is the exponential one, and the two agree exactly where general
+      relativity has been tested and part company where it has not.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>where they agree</span>,
+        <>β = γ = 1, so every first-post-Newtonian test is identical: the
+          perihelion advance, light’s deflection, Shapiro delay, the Cassini
+          bound on γ. <V>A</V> agrees to <V>O</V>(<V>u</V><Sup>3</Sup>) — the
+          isotropic <V>A</V> <i>is</i> <V>e</V><Sup>−2<V>u</V>−<V>u</V>³/6</Sup>.</>],
+      [<span style={{ color: BORROWED }}>where they differ</span>,
+        <><V>B</V> parts company at <V>O</V>(<V>u</V><Sup>2</Sup>), which shows
+          in the perihelion at <V>O</V>(<V>u</V>) — 10<Sup>−6</Sup> arcseconds
+          a century at Mercury, and 0.13% to 0.56% in these panels, which run at
+          exaggerated depth so the effect is visible at all.</>],
+      [<span style={{ color: BORROWED }}>and where they part outright</span>,
+        <><V>e</V><Sup>−2<V>u</V></Sup> never reaches nought, so{' '}
+          <b style={{ color: INK }}>no horizons</b>; the shadow is{' '}
+          <b style={{ color: INK }}>4.6% larger</b> at the same mass; and a
+          neutron star shows about half its mass, which is outside any equation
+          of state and is the one place the model is probably just wrong.</>],
+    ]} />
+
+    <Note>
+      So the claim is not “general relativity, rederived”. It is:{' '}
+      <b style={{ color: INK }}>a metric theory built from counting, agreeing
+        with general relativity on everything general relativity has passed,
+        and disagreeing where nobody has looked closely yet.</b> That is a
+      better position than agreement would be, because it can be shot at — and
+      the shadow is the shot to take.
+    </Note>
+
     <Head>what is a choice</Head>
 
     <Rows of={[
@@ -1775,10 +1844,10 @@ export const Law = () => {
       pull’s 0.0624 — gravity nine times too strong, because a fresh direction
       every tick spreads the surplus too slowly and it piles up. The fix is{' '}
       <i>persistence</i>: with mean cosine <V>a</V> between steps, <V>D</V>{' '}
-      scales by (1+<V>a</V>)/(1−<V>a</V>), so <V>a</V> = 0.815 — keep your
-      heading about 85% of the time, which is 10.21 cells, which is{' '}
-      π<K>WAYS</K>/<K>SHEET</K>. The two extremes bracket it and neither is
-      right, and{' '}
+      scales by (1+<V>p</V>)/(1−<V>p</V>), so <V>p</V> = 0.815 — keep your
+      heading about 85% of the time, a run of 5.42 steps or 7.67 cells, checked
+      against a measured walk to a per cent. The two extremes bracket it and
+      neither is right, and{' '}
       <b style={{ color: INK }}>the debt is now a rule the lattice may simply
         have, rather than a contradiction it cannot resolve.</b>
     </Note>
@@ -2042,17 +2111,45 @@ export const Law = () => {
     <Head>and what is still owed</Head>
 
     <Note>
-      <b style={{ color: INK }}>One number.</b> The pull is counted, <V>G</V>{' '}
-      is counted, the reach is counted, <V>E</V> = ħω and λ = <V>h</V>/<V>p</V>{' '}
-      and the amplitude rule all fall out of mass being a rate.{' '}
-      <b style={{ color: INK }}><V>A</V> and <V>B</V> are general relativity’s,
-        and <i>carry</i> is its geodesic equation</b> — which is five sixths of
-      the perihelion advance and all of the deflection, borrowed. Everything
-      else on this page is downstream of closing that.
+      <b style={{ color: INK }}>Nothing is borrowed.</b> The pull, <V>G</V>, the
+      reach, <V>E</V> = ħω, λ = <V>h</V>/<V>p</V>, the amplitude rule,{' '}
+      <V>A</V> and <V>B</V>, and <i>carry</i> — all counted. What is owed is of
+      two other kinds, and they are worth keeping apart from each other as
+      carefully as either was kept from <i>borrowed</i>.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>argued, not measured</span>,
+        <><i>carry</i> matches stationary phase to 10<Sup>−7</Sup>, but the
+          checkerboard behind it was run in <i>flat</i> space. A
+          position-dependent reversal amplitude has not been tried. Likewise{' '}
+          <i>hold</i> rests on one emitter per edge, and <i>boost</i> on a
+          threshold nothing fixes. <i>regimes.ts</i> lists these under{' '}
+          <i>untested</i>.</>],
+      [<span style={{ color: BORROWED }}>probably just wrong</span>,
+        <>A neutron star shows about half its mass — outside any equation of
+          state, and pulsar timing measures those directly. And cosmology comes
+          out empty five separate ways, every one of them short rather than
+          long.</>],
+      [<span style={{ color: DERIVED }}>and one thing to shoot at</span>,
+        <>The shadow, 4.6% larger than general relativity’s at the same mass.
+          Parameter-free, and inside the reach of an instrument that already
+          exists.</>],
+    ]} />
+
+    <Head>and the record of a road not taken</Head>
+
+    <Note>
+      What follows is kept because the two no-gos in it stay true whatever
+      replaces them, and because the target moved out from under the whole
+      programme once <V>A</V> and <V>B</V> turned out not to need a source at
+      all. It was an attempt to build <V>B</V> from space being <i>made</i>{' '}
+      somewhere and carried; the compounding above builds it from counting
+      edges, and needs none of this.
     </Note>
 
     <Note>
-      And it has narrowed to a single question. The source is settled: creation{' '}
+      It had narrowed to a single question. The source was settled: creation{' '}
       <i>at</i> the body, which is the only mechanism that does not{' '}
       <i>consume</i> the field — and consuming it is fatal, because the event
       that sources a fold is the event that screens, so strength and range are
@@ -2060,9 +2157,410 @@ export const Law = () => {
       a factor: a surplus that hops is static and gives 1/<V>r</V> and misses{' '}
       <V>G</V> by 9.83. So:{' '}
       <b style={{ color: INK }}>does the lattice have a reason for a hopping
-        point to keep its heading about 85% of the time?</b> That is the whole
-      of the remaining gap, and 10.21 = π<K>WAYS</K>/<K>SHEET</K> being a pure
-      count is either the answer in plain sight or a coincidence.
+        point to keep its heading about 85% of the time?</b> That was, at the
+      time, the whole of the remaining gap. A pure count did briefly seem to be
+      sitting in
+      plain sight — 10.21 = π<K>WAYS</K>/<K>SHEET</K> — but that is{' '}
+      3<V>D</V>/<V>c</V>, which is <V>D</V> rewritten rather than a second fact,
+      and the physical run is 7.67 cells. No coincidence to chase.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And both ways out of that are closed, by
+        argument rather than by a measurement failing.</b> Whatever turns the
+      hopping point must be <i>uniform</i> — with a turner of density{' '}
+      ∝ <V>r</V><Sup>−n</Sup> the profile is 1/<V>r</V><Sup>1+n</Sup>, measured
+      on a radial solve at 0.61, 1.03, 1.51, 2.00, 3.00 for{' '}
+      <V>n</V> = −0.5 … 2, so only <V>n</V> = 0 gives 1/<V>r</V>. The model has
+      exactly two uniform things: the lattice, and <V>Φ</V> — and <V>Φ</V> is
+      forty-five orders short. So the turner is the lattice. But the lattice is
+      neutral points at one to a cell, so a hopping surplus meets one{' '}
+      <i>every hop</i> and turns every tick:{' '}
+      <b style={{ color: INK }}><V>p</V> = 0, which is exactly the case that is
+        nine times too strong.</b> The admissible turner gives the wrong{' '}
+      <V>p</V>, and the right one has no mechanism.
+    </Note>
+
+    <Note>
+      And a surplus that never moves cannot work either. Created from the flux
+      and removed in place as <V>δ</V><Sup>q</Sup><V>r</V><Sup>−b</Sup>, the
+      steady state is <V>δ</V> ∝ <V>m</V><Sup>1/q</Sup>/<V>r</V><Sup>(2−b)/q</Sup>,
+      and shape and mass fight. Self-annihilation (<V>q</V> = 2) gives
+      1/<V>r</V> exactly, static, with no transport and no <V>Φ</V> — and{' '}
+      <b style={{ color: INK }}><V>δ</V> ∝ √<V>m</V></b>, so the pull would go
+      as the square root of the mass. The only row satisfying both wants a
+      removal partner with a 1/<V>r</V> density, and the model has none but the
+      surplus itself, which makes it <V>q</V> = 2 again.
+    </Note>
+
+    <Note>
+      So the source-and-carry route is worse than <i>one posited constant</i>:{' '}
+      <b style={{ color: INK }}><V>B</V> is not one constant away from being{' '}
+        <i>derived</i> — it is one constant away from being <i>consistent</i></b>,
+      in either account, and that constant has no mechanism behind it in either.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And then the target moved.</b> All of that
+      assumed <V>B</V> needs its own source. But a place has{' '}
+      <K>WAYS</K> + <V>n</V> ways out, the <i>lean</i> is a ratio and the{' '}
+      <i>total</i> is what a ratio throws away — <V>A</V> and <V>B</V> from the
+      same count, with no surplus, no transport and no <V>D</V>. That is a claim
+      with numbers, because <V>A</V> and <V>B</V> carry exactly two things the
+      pull does not fix: <V>γ</V> and <V>β</V>.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>γ = 1, for free</span>,
+        <>Reading one count two ways forces the space part and the time part to
+          agree. That is the real content of “the same count read twice”, and{' '}
+          <b style={{ color: INK }}>γ = 1 is what Cassini measures to
+            2·10<Sup>−5</Sup></b>. Light’s deflection comes out at 1.0000 of
+          its value, since that depends on γ alone.</>],
+      [<span style={{ color: BORROWED }}>β = 3/2, against 1</span>,
+        <>And β is not free: it puts the perihelion advance at{' '}
+          <b style={{ color: INK }}>0.8334</b> — five sixths, where the panels
+          measure 6.05 to 6.20. Wrong in a diagnostic place rather than
+          uniformly, which is what makes it useful.</>],
+      [<span style={{ color: FAINT }}>why β is hard</span>,
+        <>Only exp(−2<V>u</V>) gives β = 1. A ratio 1/(1+<V>u</V>)<Sup>2</Sup>{' '}
+          gives 3/2, and 1/(1+2<V>u</V>) gives 2. The count would have to
+          compose <i>multiplicatively</i> — and <K>BIAS</K> is explicitly
+          linear, “weight of the way it went, 1 + <V>n</V>”.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>Which is where matter finally bears on it.</b>{' '}
+      β is gravity gravitating: what a <i>second</i> annihilation at an{' '}
+      <i>already-folded</i> place is worth. A lone tally cannot say — that is a
+      statement about something in a field. If folding a place changes what the
+      next annihilation there buys, the composition is multiplicative and β = 1
+      follows. So the gap is not a transport rule and not a diffusivity:{' '}
+      <b style={{ color: INK }}>it is whether 1 + <V>n</V> should be
+        (1 + 1/<K>WAYS</K>)<Sup><V>n</V></Sup></b> — one line of the counting
+      argument, in the one rule that has never been asked whether it stays
+      linear all the way up.
+    </Note>
+
+    <Head>and it compounds, because edges point both ways</Head>
+
+    <Note>
+      A node that has taken <V>n</V> annihilations has{' '}
+      <K>WAYS</K> + <V>n</V> edges. Edges are shared with neighbours, so{' '}
+      <b style={{ color: INK }}>the same <V>n</V> extra edges point <i>into</i>{' '}
+        it</b> — a charge nearby is (<K>WAYS</K>+<V>n</V>)/<K>WAYS</K> times
+      more likely to arrive there. More arrivals, more annihilations, more
+      folding, more arrivals. The increment is proportional to what is already
+      there, which is what <i>multiplicative</i> means, and it is the counting
+      argument’s own geometry rather than a new rule.
+    </Note>
+
+    <Eq derive={METRIC} open={show}
+      note="the bare count, compounded by the fact that a folded node is easier to arrive at">
+      d<V>u</V> = d<V>u</V><Sub>0</Sub>·(1 + <V>u</V>)
+      <span style={{ padding: '0 1.4em', color: FAINT }}>⇒</span>
+      1 + <V>u</V> = <V>e</V><Sup><V>u</V><Sub>0</Sub></Sup>
+      <span style={{ padding: '0 1.4em', color: FAINT }}>⇒</span>
+      <V>A</V> = <V>e</V><Sup>−2<V>u</V><Sub>0</Sub></Sup>,&nbsp;
+      <V>B</V> = <V>e</V><Sup>+2<V>u</V><Sub>0</Sub></Sup>
+    </Eq>
+
+    <Note>
+      Integrated from infinity inward, that lands on{' '}
+      <V>e</V><Sup><V>u</V><Sub>0</Sub></Sup> − 1 to nine figures, with{' '}
+      <V>u</V><Sub>0</Sub> the <i>bare</i> count — the pull’s own potential,
+      already derived. The lean gives <V>A</V>, the total gives <V>B</V>, and{' '}
+      <V>A·B</V> = 1 exactly, so γ = 1. Integrating the orbit between its
+      turning points gives general relativity’s perihelion advance where the
+      additive form gives 0.833 of it.{' '}
+      <b style={{ color: INK }}>So <V>A</V> and <V>B</V> are not borrowed.</b>{' '}
+      And nothing measured moves: the feedback’s correction beyond first order
+      is 3.5·10<Sup>−16</Sup> at Mercury, 6.3·10<Sup>−5</Sup> in these panels.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And there are no horizons.</b> √<V>A</V> = 0
+      needs 1 + <V>u</V> = ∞, so <V>n</V> = ∞ — a node would have to have{' '}
+      <i>infinitely many ways out</i>, and each annihilation adds one, and a
+      finite mass sends finitely many charges. At what general relativity calls
+      the horizon (<V>u</V><Sub>0</Sub> = 2) the node has 6.4 extra ways out
+      per <K>WAYS</K>: a lot, and not infinity. Light leaves, redshifted by{' '}
+      <V>e</V><Sup>2</Sup> = 7.4. Nothing is ever cut off — things get
+      arbitrarily red and arbitrarily slow and never quite vanish.
+    </Note>
+
+    <Head>so what is a black hole</Head>
+
+    <Note>
+      Not a question the metric answers — that only says nothing is cut off.
+      What answers it is <i>screening</i>, which this model already has: a
+      body’s charges annihilate against its <i>own</i> field on the way out, so
+      only a skin of thickness <V>λ</V> ever reaches the outside, and{' '}
+      <b style={{ color: INK }}>a body looks lighter than it is</b>.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>ordinary matter is transparent</span>,
+        <><V>R</V>/<V>λ</V> is 10<Sup>−8</Sup> for the Earth and
+          3·10<Sup>−5</Sup> for the Sun, so <V>M</V><Sub>eff</Sub>/<V>M</V> = 1
+          to six figures. Nothing changes anywhere the model was tested.</>],
+      [<span style={{ color: BORROWED }}>a neutron star is not</span>,
+        <><V>R</V>/<V>λ</V> = 3.4, so it shows{' '}
+          <b style={{ color: INK }}>about half its mass</b>. Pulsar timing
+          measures those masses directly and a factor of two in baryon content
+          is outside any equation of state. The second falsifiable claim, and
+          it looks worse for the model than the first.</>],
+      [<span style={{ color: DERIVED }}>and it is holographic</span>,
+        <>For <V>R</V> ≫ <V>λ</V>, <V>M</V><Sub>eff</Sub> → 4π<V>R</V><Sup>2</Sup><V>λρ</V>{' '}
+          — the <i>area</i>, not the volume (0.029406 against 3<V>λ</V>/<V>R</V>{' '}
+          = 0.030000). The interior is sealed off by its own opacity rather
+          than by a horizon, and what the universe knows about a big clump is a
+          surface.</>],
+    ]} />
+
+    <Eq derive={REACH} open={show}
+      note="the densest thing the lattice permits, and where it sits">
+      <V>M</V><Sub>eff</Sub> = <V>πR</V>
+      <span style={{ padding: '0 1.4em', color: FAINT }}>⇒</span>
+      <Frac over={<V>R</V>} under={<><V>R</V><Sub>s</Sub></>} /> =
+      <Frac over={<>1</>} under={<>2π<V>G</V></>} /> =
+      <Frac over={<>2π<K>WAYS</K></>} under={<><K>SHEET</K><Sup>2</Sup></>} /> = 2.5525
+    </Eq>
+
+    <Note>
+      Once a tick is the ceiling, so the densest matter is one emitter a cell.
+      Then <V>M</V><Sub>eff</Sub> ∝ <V>R</V> — Schwarzschild’s own scaling — so
+      the ratio is the same at every size, measured at 2.5525 from{' '}
+      10<Sup>10</Sup> to 10<Sup>40</Sup> cells, and it is a pure count.{' '}
+      <b style={{ color: INK }}>The densest thing the lattice permits sits at
+        two and a half of its own Schwarzschild radii and can never be
+        inside.</b> So black holes do not fail to form because the metric lacks
+      a horizon — they fail because matter runs out of room first, and those are
+      two independent facts that happen to agree.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the leakage is not Hawking radiation.</b> At
+      the surface <V>u</V> = <V>πG</V> = 0.1959, so light leaves redshifted by
+      0.822 — an 18% shift, and <i>M-independent</i>, the same for a
+      stellar-mass object and a galactic one. Hawking needs <V>T</V> ∝ 1/<V>M</V>{' '}
+      and a lifetime ∝ <V>M</V><Sup>3</Sup>; this gives <V>T</V> ∝ <V>M</V><Sup>0</Sup>{' '}
+      and no evaporation at all, because nothing is trapped to begin with. The
+      “never quite vanishing” path is ordinary light out of a shallow well, and
+      it is not even slow.
+    </Note>
+
+    <Note>
+      Which reads as a bill until you ask what is actually blocking it — and it
+      is not the metric.{' '}
+      <b style={{ color: INK }}>It is the self-screening.</b> With it,{' '}
+      <V>R</V>/<V>R</V><Sub>s</Sub> = 2.55 at every size, a floor. Without it,{' '}
+      <V>M</V> = (4/3)π<V>R</V><Sup>3</Sup> and the ratio falls as{' '}
+      <V>R</V><Sup>2</Sup>, crossing one at 1.384 cells — after which{' '}
+      <V>u</V> grows without bound and <V>e</V><Sup>−<V>u</V></Sup> does the
+      rest.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>no horizon is needed</span>,
+        <>A ball 5 cells across at maximum density has <V>u</V> = 6.5 and a
+          redshift of 1.5·10<Sup>−3</Sup>; at 10 cells,
+          4.5·10<Sup>−12</Sup>; at 50 cells,{' '}
+          <b style={{ color: INK }}>2.7·10<Sup>−284</Sup></b>. Dark to any
+          precision anyone will ever have, with <V>A</V> never once reaching
+          nought.</>],
+      [<span style={{ color: DERIVED }}>and coherence lifts the cap</span>,
+        <>Self-screening needs <i>opposite</i> charges, and two of the same
+          thing in step do not cancel — the panel above. Two emitters{' '}
+          <V>Δr</V> apart meet with a phase difference <V>ωΔr</V>/<V>c</V>, so
+          in step means{' '}
+          <b style={{ color: INK }}><V>R</V> ≪ 2π/<V>m</V>, the Compton
+            wavelength</b>. Then share → 0, <V>λ</V> → ∞,{' '}
+          <V>M</V><Sub>eff</Sub> = <V>M</V>, and nothing caps <V>u</V>.</>],
+      [<span style={{ color: BORROWED }}>and it is an upper bound on <V>m</V></span>,
+        <>Not, as this page first had it, a requirement to sit <i>at</i> the
+          heaviest elementary mass — that argument confused pulsing on the same
+          tick with being in step where the charges meet, and{' '}
+          <b style={{ color: INK }}>the ceiling is the shortest coherence range
+            there is</b>, 10<Sup>−34</Sup> m. The condition is{' '}
+          <V>m</V> &lt; 2π/<V>R</V>: below 6·10<Sup>−12</Sup> eV for something
+          twelve kilometres across. An upper bound, so no fine-tuning — and it
+          is the condition for the whole object to be one quantum state.</>],
+      [<span style={{ color: DERIVED }}>and R is the other way in</span>,
+        <><V>R</V> &lt; 2π/<V>m</V> constrains <V>R</V> as much as <V>m</V>.
+          Squeeze <i>ordinary</i> matter below its own Compton wavelength and it
+          self-coheres — so the cap{' '}
+          <b style={{ color: INK }}>rises as the body shrinks</b>,{' '}
+          <V>u</V><Sub>cap</Sub> = 16π<Sup>2</Sup><V>G</V>/(<V>mR</V>·<K>SHEET</K>).
+          Dark once <V>R</V> &lt; 5·10<Sup>−19</Sup> m for protons — a
+          thousandth of a fermi. No exotic matter needed.</>],
+      [<span style={{ color: BORROWED }}>what it does not fix</span>,
+        <>A neutron star is twenty orders too big to cohere, so it still shows
+          about half its mass, and that is still outside any equation of
+          state.</>],
+    ]} />
+
+    <Note>
+      Four other permutations were tried and none works.{' '}
+      <i>A hollow shell</i>: a point inside sees a tangential chord of
+      √(2<V>Rt</V>), not <V>t</V> — 77 m for a kilometre shell a metre thick,
+      so geometry cannot beat a fermi. <i>A phase ramp</i>: a phased array
+      aligns one direction and misaligns the rest, and screening samples every
+      pair inside, so it redistributes share over angle rather than lowering
+      it. <i>Net charge</i>: not available, since neutral → + − makes them in
+      pairs. <i>Lower density</i>: it cancels out of the cap entirely.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the collapse has nothing to stop it.</b> In
+      general relativity a star reaches its horizon and is done; here no radius
+      is marked, so it continues. On the way it passes through the screened
+      regime as a compact object with <V>u</V> pinned at 0.196 — which is{' '}
+      <i>not</i> a support, since screening attenuates only what <i>leaves</i>{' '}
+      while the field between neighbours is short-range and unscreened. So it
+      runs to the lattice ceiling, and a solar mass ends as a ball
+      10<Sup>−22</Sup> m across: dark by redshift, with nothing ever causally
+      severed.
+    </Note>
+
+    <Note>
+      What an observer sees is unchanged, because that is fixed by the metric a
+      few Schwarzschild radii out, where <V>u</V> ~ ½ and the exponential and
+      isotropic forms agree closely.{' '}
+      <b style={{ color: INK }}>There is still a photon sphere and still a
+        shadow.</b> What differs is what sits at the middle — ceiling-density
+      matter rather than a singularity — and how it got there.
+    </Note>
+
+    <Head>and a second way, kept alongside</Head>
+
+    <Note>
+      A node with <K>WAYS</K> + <V>n</V> edges gives a source <i>sitting there</i>{' '}
+      more ways to pulse into, so <K>SHEET</K> → <K>SHEET</K>(1+<V>u</V>) and
+      emission — which <i>is</i> mass — is boosted. A feedback on the{' '}
+      <b style={{ color: INK }}>source</b>, where the compounding was a feedback
+      on the <b style={{ color: INK }}>transport</b>. The once-a-tick ceiling
+      stops binding, because the ceiling was on how <i>often</i>, not how{' '}
+      <i>many</i>.
+    </Note>
+
+    <Eq derive={METRIC} open={show}
+      note="unlike e^u₀ this diverges at finite depth — which is a horizon">
+      <V>M</V><Sub>eff</Sub> = <V>M</V>(1 + <V>κu</V>)
+      <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+      <V>u</V> = <Frac over={<><V>u</V><Sub>0</Sub></>}
+        under={<>1 − <V>κu</V><Sub>0</Sub></>} />
+      <span style={{ padding: '0 1.2em', color: FAINT }}>→ ∞ at <V>u</V><Sub>0</Sub> = 1</span>
+    </Eq>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>it restores horizons</span>,
+        <><V>A</V> = <V>e</V><Sup>−2<V>u</V></Sup> is 4.2·10<Sup>−1</Sup> at{' '}
+          <V>u</V><Sub>0</Sub> = 0.3, 1.5·10<Sup>−8</Sup> at 0.9, and{' '}
+          <b style={{ color: INK }}>exactly nought at 1</b> — a genuine horizon
+          at <V>r</V> = <V>GM</V>/<V>c</V><Sup>2</Sup>, which the transport
+          feedback alone could never produce.</>],
+      [<span style={{ color: BORROWED }}>but it costs a threshold</span>,
+        <>β = 1 − <V>κ</V>, and β is known to 3·10<Sup>−4</Sup>. At{' '}
+          <V>κ</V> = 1 the perihelion advance is{' '}
+          <b style={{ color: INK }}>eight sixths where the panels measure
+            six</b> — 33% high, excluded by three thousand. It survives only if
+          the boost begins above <V>u</V><Sup>2</Sup>, at a depth nothing has
+          fixed. <K>BIAS</K> saturating as <V>n</V>/(<K>WAYS</K>+<V>n</V>) turns
+          over at <V>u</V> ~ 1, which is at least where such a threshold would
+          sit.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>Both are kept, because they differ where it
+        matters.</b> Both give a photon sphere and a shadow, so images do not
+      separate them. Route one leaves a <i>surface</i> — ringdown echoes, no
+      information loss, arbitrarily red but finite escape — and needs no free
+      parameter, since collapse below λ<Sub>C</Sub> is a definite radius. Route
+      two gives a true horizon and ordinary black-hole phenomenology, and needs
+      a threshold nobody has derived. <i>regimes.ts</i> carries it as{' '}
+      <i>boost</i>, off by default.
+    </Note>
+
+    <Head>and how big is it, really</Head>
+
+    <Note>
+      <V>R</V><Sub>c</Sub> = 1.96 is a <i>coordinate</i> radius, and nothing
+      measures those. What anything measures is the areal one — the sphere at{' '}
+      <V>r</V> has proper area 4π<V>r</V><Sup>2</Sup><V>B</V>, so{' '}
+      <V>r</V><Sub>areal</Sub> = <V>r</V>·<V>e</V><Sup><V>u</V></Sup>. Which is
+      the same statement as{' '}
+      <b style={{ color: INK }}>“a node with <K>WAYS</K> + <V>n</V> edges
+        touches far more than a cell’s worth of neighbours”</b>, measured rather
+      than counted.
+    </Note>
+
+    <Eq derive={METRIC} open={show}
+      note="the area does not shrink to nothing — it has a narrowest point, and inside that it grows again">
+      <Frac over={<>d</>} under={<>d<V>r</V></>} />
+      <Paren><V>r e</V><Sup><V>GM</V>/<V>r</V></Sup></Paren> = 0
+      <span style={{ padding: '0 1.2em', color: FAINT }}>at</span>
+      <V>r</V> = <V>GM</V>/<V>c</V><Sup>2</Sup>
+      <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+      <V>r</V><Sub>areal</Sub> = <V>e</V>·<V>GM</V>/<V>c</V><Sup>2</Sup> =
+      1.3591 <V>R</V><Sub>s</Sub>
+    </Eq>
+
+    <Note>
+      <b style={{ color: INK }}>The area has a throat</b>, and inside it the
+      area grows again without bound — so the geometry is not a point but a
+      narrow neck opening into something vast, at a ratio that is scale-free.
+      A solar mass at <V>R</V><Sub>c</Sub> has <V>u</V> = 4.7·10<Sup>37</Sup>,
+      hence an areal radius of 10<Sup>(2·10³⁷)</Sup> cells and a node carrying
+      1.2·10<Sup>39</Sup> edges.{' '}
+      <b style={{ color: INK }}>Two cells across and enormous at once</b>, and
+      those are one fact. (That figure uses the <i>exterior</i> <V>u</V> where
+      the interior solution applies, so it is right in kind and not in detail.
+      The throat is exact.)
+    </Note>
+
+    <Eq derive={METRIC} open={show}
+      note="and this is the one number in the whole model that an instrument can settle now">
+      <V>b</V> = 2<V>e</V>·<V>GM</V>/<V>c</V><Sup>2</Sup>
+      <span style={{ padding: '0 1.2em', color: FAINT }}>against</span>
+      3√3·<V>GM</V>/<V>c</V><Sup>2</Sup>
+      <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+      1.0463
+    </Eq>
+
+    <Note>
+      The photon sphere is where d/d<V>r</V>(<V>r</V><Sup>2</Sup><V>B</V>/<V>A</V>) = 0;
+      with <V>B</V>/<V>A</V> = <V>e</V><Sup>4<V>u</V></Sup> that is{' '}
+      <V>r</V><Sub>ph</Sub> = 2<V>GM</V>, and the shadow’s impact parameter is{' '}
+      <V>b</V> = <V>r</V>·<V>e</V><Sup>2<V>u</V></Sup>. So{' '}
+      <b style={{ color: INK }}>the shadow is 4.6% larger than general
+        relativity’s at the same mass</b> — a fixed, parameter-free ratio.
+      Measure the mass from orbits and the shadow from imaging, and this
+      predicts a constant mismatch between them. It sits inside the Event
+      Horizon Telescope’s present ~10% systematic error and outside what it is
+      aiming for, which makes it a near-term test rather than a philosophical
+      one, and the only claim here an existing instrument can settle.
+    </Note>
+
+    <Note>
+      Neither route fixes the neutron star, and route two makes it slightly
+      worse — a boost at <V>u</V> ~ 0.2 raises emission, which raises{' '}
+      <V>Φ</V>, which screens harder. And what would settle route two from inside the model is
+      whether <K>SHEET</K> scales with a node’s edge count or is fixed by the
+      dimension: <i>field.ts</i> says the latter, 3<Sup><V>d</V>−1</Sup> − 1, a
+      property of the lattice rather than of the place.{' '}
+      <b style={{ color: INK }}>Route two needs that reading changed; route one
+        does not.</b>
+    </Note>
+
+    <Note>
+      And <i>carry</i> cannot help with any of it, which is worth saying because
+      it is the last borrowed thing and the temptation is to hang the leftovers
+      on it. <i>carry</i> is d<V>p</V>/d<V>t</V> — the equation of motion, and
+      nowhere else. Redshift is 1/√<V>A</V>, light’s speed is <V>c</V>√(<V>A</V>/<V>B</V>),
+      a horizon is <V>A</V> = 0.{' '}
+      <b style={{ color: INK }}>Change <i>carry</i> and orbits change; not one
+        of those three moves.</b>
     </Note>
 
     <Note>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
index c75e2f2..ce13cf4 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
@@ -75,10 +75,76 @@ export type Regime = {
    * full sense. Turning it off is how you ask what it costs.
    */
   screen: number;
+
+  /**
+   * HOW THE COUNT AT A PLACE COMPOSES — and this one decides whether the metric
+   * is derived or borrowed.
+   *
+   *   0  ADDITIVE. `weight of the way it went = 1 + n`, which is what `BIAS`
+   *      says. Gives √A = WAYS/(WAYS+n), hence β = 3/2, hence a perihelion
+   *      advance 17% low at every depth. Wrong, and measured to be wrong.
+   *   1  MULTIPLICATIVE. Each annihilation multiplies by 1 + 1/WAYS, so
+   *      √A = (1+1/WAYS)^−n → exp(−u), and A = e^−2u, B = e^+2u. Gives
+   *      β = γ = 1 and general relativity's perihelion advance.
+   *
+   * At 1 the metric is DERIVED — no A and B taken from outside — at the price
+   * of predicting NO HORIZONS, since exp(−2u) never vanishes. See `slowingMul`
+   * in `gravity.ts`. The file's panels still run at 0, because every number in
+   * them was measured against the borrowed forms.
+   */
+  compose: number;
+
+  /**
+   * WHETHER MATTER IN A FOLDED PLACE CAN EMIT MORE — which decides whether the
+   * model has horizons, and so which of its two dark-object stories is true.
+   *
+   *   0  no. `SHEET` is fixed by the dimension, emission is what it always was,
+   *      and `A = e^−2u` never reaches nought. Dark objects are DARK BY
+   *      REDSHIFT: collapse past λ_C, the matter self-coheres, the screening cap
+   *      lifts, u grows unbounded. No horizon, a surface, no free parameter.
+   *
+   *   1  yes. A node with WAYS + n edges gives a source there more ways to pulse
+   *      into, so `M_eff = M(1 + κu)` and `u = u₀/(1 − κu₀)` DIVERGES at u₀ = 1.
+   *      Dark objects are DARK BY HORIZON, the ordinary kind.
+   *
+   * The model's own setting is 0, and not because route two is wrong — because
+   * route two costs a threshold. `β = 1 − κ` and β is measured to 3·10⁻⁴, so a
+   * boost linear in u puts the perihelion advance 33% high; it survives only if
+   * it begins above u², at a depth nothing has yet fixed. Route one costs
+   * nothing and follows from rules already here.
+   *
+   * BOTH ARE KEPT because they differ observationally: route one leaves a
+   * SURFACE (ringdown echoes, no information loss), route two does not. Neither
+   * fixes the neutron star. See the foot of `gravity.ts`.
+   */
+  boost: number;
+
+  /**
+   * WHETHER A FOLDED CELL HOLDS MORE MATTER — the density ceiling, tied to the
+   * edge count rather than fixed at one emitter a cell.
+   *
+   *   0  ρ_max = 1. One emitter to a cell, everywhere.
+   *   1  ρ_max = 1 + u. A node with WAYS + n edges fits more distinct emitters,
+   *      each still the same m ≤ 1 thing.
+   *
+   * DISTINCT FROM `boost`, and the distinction is the whole point. `boost` makes
+   * ONE emitter emit more, which changes what a fixed mass does and so moves β
+   * — excluded by seven thousand. This changes only how much mass fits in a
+   * place, so a fixed mass emits exactly what it always did and β is untouched.
+   *
+   * What it buys: `M = (4/3)πR³/(1 − (4/3)πGR²)` diverges at
+   * `R_c = √(3π·WAYS)/SHEET = 1.9567 cells`, so every collapsed object is the
+   * same size — a hair under two Planck lengths — with u ∝ M. Darkness becomes
+   * automatic, needing neither the coherence argument nor a horizon.
+   *
+   * Not on by default: it rests on "one emitter per edge", which is a reading of
+   * what a cell can hold and not something counted yet.
+   */
+  hold: number;
 };
 
 /** Every knob on: the model saying everything it has to say. */
-export const FULL: Regime = { sync: 0, turn: 1, fold: 1, screen: 1 };
+export const FULL: Regime = { sync: 0, turn: 1, fold: 1, screen: 1, compose: 1, boost: 0, hold: 0 };
 
 /**
  * The theories this model contains, and what each one is a switching-off of.
@@ -88,17 +154,23 @@ export const FULL: Regime = { sync: 0, turn: 1, fold: 1, screen: 1 };
  * two of them by drawing all three laws on one orbit.
  */
 export const RECOVERS = {
+  /** Dark by redshift, with a size: every collapsed object at R_c = 1.96 cells. */
+  'black holes with a surface': { sync: 0, turn: 1, fold: 1, screen: 1, compose: 1, boost: 0, hold: 1 },
+
+  /** Dark by horizon: the emission boost on, so u diverges at u₀ = 1. */
+  'black holes with horizons': { sync: 0, turn: 1, fold: 1, screen: 1, compose: 1, boost: 1, hold: 0 },
+
   /** Flat space, infinite range, no matter wave. One sixth of the advance. */
-  'newton': { sync: 0, turn: 0, fold: 0, screen: 0 },
+  'newton': { sync: 0, turn: 0, fold: 0, screen: 0, compose: 0, boost: 0, hold: 0 },
 
   /** Add the metric. Six sixths, and 4GM/bc² for light. Borrowed, not derived. */
-  'general relativity': { sync: 0, turn: 0, fold: 1, screen: 0 },
+  'general relativity': { sync: 0, turn: 0, fold: 1, screen: 0, compose: 0, boost: 0, hold: 0 },
 
   /** A photon: never turns, so no clock, so no mass. */
-  'light': { sync: 0, turn: 0, fold: 1, screen: 1 },
+  'light': { sync: 0, turn: 0, fold: 1, screen: 1, compose: 0, boost: 0, hold: 0 },
 
   /** The zigzag. Ω² = k² + m², λ_dB, time dilation, and a derived modulus. */
-  'dirac': { sync: 0, turn: 1, fold: 0, screen: 0 },
+  'dirac': { sync: 0, turn: 1, fold: 0, screen: 0, compose: 0, boost: 0, hold: 0 },
 
   /**
    * The superseded route to the same wavelength — rest-frame simultaneity and
@@ -106,7 +178,7 @@ export const RECOVERS = {
    * only account here that says anything about what a COMPOSITE has to do, and
    * `turn` says nothing about that.
    */
-  'de broglie by simultaneity': { sync: 1, turn: 0, fold: 0, screen: 0 },
+  'de broglie by simultaneity': { sync: 1, turn: 0, fold: 0, screen: 0, compose: 0, boost: 0, hold: 0 },
 
   /** What this model says when nothing is switched off. */
   'orbitmines': FULL,
@@ -130,6 +202,16 @@ export const check = (r: Regime): string[] => {
   for (const [k, v] of Object.entries(r))
     if (!(v >= 0 && v <= 1)) wrong.push(`${k} = ${v} is outside 0…1`);
 
+  if (r.boost > 0 && r.hold > 0)
+    wrong.push('boost and hold are two readings of "a folded cell has more '
+      + 'capacity" — one per emitter, one per cell. Having both counts the '
+      + 'extra edges twice');
+
+  if (r.boost > 0 && r.compose === 0)
+    wrong.push('boost without compose is a source feedback on top of a metric '
+      + 'that has no transport feedback — the two were derived together, and '
+      + 'having one without the other is not a position anything argues for');
+
   if (r.sync > 0 && r.turn > 0)
     wrong.push('sync and turn are two accounts of λ = h/p, not two effects — '
       + 'having both counts the same physics twice');
@@ -145,10 +227,38 @@ export const check = (r: Regime): string[] => {
 export const borrows = (r: Regime): string[] => {
   const owed: string[] = [];
 
-  if (r.fold > 0) owed.push(
+  if (r.fold > 0 && r.compose === 0) owed.push(
     '`slowing` and `thickness` are general relativity\'s isotropic functions, '
     + 'and `carry` is its geodesic equation. The pull is derived; the metric '
-    + 'that turns one sixth of the perihelion advance into six is not.');
+    + 'that turns one sixth of the perihelion advance into six is not. '
+    + 'compose = 1 pays this off, at the price of having no horizons.');
+
+  return owed;
+};
+
+/**
+ * What a regime has DERIVED BUT NOT MEASURED — which is a third question again.
+ *
+ * `check` asks whether a setting is coherent, `borrows` what it takes from
+ * somebody else, and this asks what it has argued for without running. A chain
+ * that closes analytically is not the same as one that has been watched to
+ * close, and the file's whole habit is to keep those apart.
+ */
+export const untested = (r: Regime): string[] => {
+  const owed: string[] = [];
+
+  if (r.fold > 0 && r.compose > 0) owed.push(
+    '`carry` is the stationary-phase limit of the path sum — shown to match to '
+    + '1e-7 — but the checkerboard behind it was measured in FLAT space. A '
+    + 'position-dependent reversal amplitude has not been run.');
+
+  if (r.hold > 0) owed.push(
+    '`hold` rests on one emitter per edge, which is a reading of what a cell '
+    + 'can contain rather than something counted.');
+
+  if (r.boost > 0) owed.push(
+    '`boost` needs a threshold above u² that nothing has fixed; linear in u it '
+    + 'puts the perihelion advance 33% high.');
 
   return owed;
 };

From ab2014213f3919ccc9f807ecdbdab1fadb2a770c Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Tue, 11 Aug 2026 13:06:45 +0200
Subject: [PATCH 26/47] Black holes

---
 .../2026.RayCalculiAndPhysics/echoes.tsx      | 155 ++++++
 .../2026.RayCalculiAndPhysics/gravity.ts      |  59 ++-
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 133 +++++
 .../2026.RayCalculiAndPhysics/regimes.ts      |  16 +
 .../2026.RayCalculiAndPhysics/shadow.tsx      | 493 ++++++++++++++++++
 5 files changed, 852 insertions(+), 4 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/echoes.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/shadow.tsx

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/echoes.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/echoes.tsx
new file mode 100644
index 0000000..0ed4469
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/echoes.tsx
@@ -0,0 +1,155 @@
+/**
+ * WHETHER A SURFACE CAN BE HEARD, WHICH IS THE ONLY PLACE THE TWO ROUTES WERE
+ * SUPPOSED TO DIFFER — AND IT CANNOT.
+ *
+ * An image cannot separate them: both share the exterior down to the photon
+ * sphere, so both cast the same shadow. The standard fallback is a RINGDOWN.
+ * A horizon absorbs whatever falls through it, so the signal decays and stops;
+ * a surface reflects, so the wave trapped between the surface and the photon
+ * sphere leaks back out as a train of late echoes. That is exactly what
+ * LIGO and Virgo searches look for in horizonless models.
+ *
+ * The delay is the round trip at the coordinate speed of light, `c√(A/B)`:
+ *
+ *     Δt = 2 ∫_{r_s}^{r_ph} e^{2GM/r} dr / c
+ *
+ *     surface r_s    Δt (GM/c)     for 1 M☉
+ *     1.50 GM        3.175e+0      1.6e−5 s
+ *     0.60 GM        1.941e+1      9.6e−5 s
+ *     0.30 GM        1.161e+2      5.7e−4 s
+ *     0.15 GM        1.670e+4      8.2e−2 s
+ *
+ * — perfectly detectable, for a surface anywhere near where such models
+ * usually put one. But THIS model puts the surface at `R_c = 1.9567 cells`,
+ * and for a solar mass that is `r_s = 2.1·10⁻³⁸ GM`, so the delay carries a
+ * factor of `e^(9.3·10³⁷)`. A number with 10³⁷ digits.
+ *
+ * THE ECHOES NEVER COME BACK. Not late — never. And that corrects something
+ * this file said earlier: it claimed a surface would show up in a ringdown
+ * where a horizon would not, and offered that as what separates the two
+ * routes. It does not. A horizon and a Planck-scale surface are the same thing
+ * to anybody outside, because "no echo ever" and "no echo possible" are not
+ * distinguishable measurements.
+ *
+ * So the model does not predict echoes, and it would be wrong to advertise
+ * horizonlessness as though it did. What remains observable is the shadow,
+ * and nothing at all about the interior.
+ */
+
+import { CanvasView, Surface } from "./canvas";
+
+/** round trip from a surface at x = r/GM out to the photon sphere at x = 2 */
+export const delay = (xs: number) => {
+  const N = 20000;
+  let acc = 0;
+  for (let i = 0; i < N; i++) {
+    const x = xs + (2 - xs) * (i + 0.5) / N;
+    acc += Math.exp(2 / x) * (2 - xs) / N;
+  }
+  return 2 * acc;
+};
+
+type Trace = {
+  label: string;
+  under: string;
+  /** echo spacing in GM/c, or Infinity for none */
+  gap: number;
+  css: string;
+};
+
+const OMEGA = 0.55;                   // ringdown frequency, rad per GM/c
+const TAU = 14;                       // its damping time
+const SPAN = 420;                     // how much of the signal is shown
+
+/** the strain: a damped ring, plus a fainter copy every `gap` */
+const strain = (t: number, gap: number) => {
+  let h = 0;
+  for (let n = 0; n < 40; n++) {
+    const at = t - n * gap;
+    if (at < 0) break;
+    // each bounce loses most of the wave through the ring
+    h += Math.pow(0.45, n) * Math.exp(-at / TAU) * Math.sin(OMEGA * at);
+    if (!isFinite(gap)) break;
+  }
+  return h;
+};
+
+const plot = (traces: Trace[], surface: Surface) => {
+  const { ctx, width, height } = surface;
+
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = "#050508";
+  ctx.fillRect(0, 0, width, height);
+
+  const pad = 8;
+  const lane = (height - pad * 2) / traces.length;
+
+  traces.forEach((tr, i) => {
+    const mid = pad + lane * (i + 0.5);
+
+    ctx.strokeStyle = "rgba(255,255,255,0.07)";
+    ctx.lineWidth = 1;
+    ctx.beginPath();
+    ctx.moveTo(0, mid); ctx.lineTo(width, mid);
+    ctx.stroke();
+
+    ctx.strokeStyle = tr.css;
+    ctx.lineWidth = 1.3;
+    ctx.beginPath();
+    for (let px = 0; px < width; px++) {
+      const t = px / width * SPAN;
+      const y = mid - strain(t, tr.gap) * lane * 0.38;
+      if (px === 0) ctx.moveTo(px, y); else ctx.lineTo(px, y);
+    }
+    ctx.stroke();
+
+    ctx.fillStyle = tr.css;
+    ctx.font = "500 11px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText(tr.label, 10, mid - lane * 0.34);
+
+    ctx.fillStyle = "#6c7080";
+    ctx.font = "400 10px ui-monospace, Menlo, monospace";
+    ctx.fillText(tr.under, 10, mid - lane * 0.34 + 13);
+  });
+};
+
+/**
+ * A horizon, a surface shallow enough to be heard, and this model's — which
+ * is not.
+ */
+export const Echoes = ({ height = 260 }: { height?: number }) => {
+  const traces: Trace[] = [
+    {
+      label: "a horizon",
+      under: "nothing comes back",
+      gap: Infinity,
+      css: "#eb964a",
+    },
+    {
+      label: "a surface at 0.3 GM/c²",
+      under: `echoes every ${delay(0.3).toFixed(0)} GM/c — 0.6 ms for a solar mass`,
+      gap: delay(0.3),
+      css: "#8bd48b",
+    },
+    {
+      label: "this model's surface, at 2·10⁻³⁸ GM/c²",
+      under: "echoes every 10^(4·10³⁷) GM/c — nothing comes back",
+      gap: Infinity,
+      css: "#4aa8eb",
+    },
+  ];
+
+  return <div>
+    <div style={{
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+      color: "#6c7080", marginBottom: 6,
+    }}>
+      ringdown, {SPAN} GM/c of it — about 2 ms at a solar mass
+    </div>
+
+    <div style={{ height, background: "#050508" }}>
+      <CanvasView animate={false} deps={["echoes"]}
+        paint={() => ({ frame: (s) => plot(traces, s) })} />
+    </div>
+  </div>;
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index febc361..8e60eca 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -2516,15 +2516,66 @@ export const sharing = (mass: number, R: number) =>
  *
  *     both               a photon sphere and a shadow — the metric a few R_s
  *                        out is the same, so images do not distinguish them
- *     route one          a surface. Ringdown echoes, no information loss,
- *                        arbitrarily red but finite escape
- *     route two          a true horizon. Standard black-hole phenomenology,
- *                        clean ringdown, causal severance
+ *     both               AND NEITHER DOES A RINGDOWN, which is the correction
+ *                        below and was got wrong here first
  *     route one          needs collapse below λ_C — a definite radius with no
  *                        free parameter (5·10⁻¹⁹ m for protons)
  *     route two          needs a threshold whose position is not fixed by
  *                        anything counted yet
  *
+ * THE ECHO CLAIM WAS WRONG. This said a surface returns late echoes where a
+ * horizon does not, and offered that as what separates the two. The delay is
+ * the round trip at the coordinate speed of light,
+ * `Δt = 2∫ e^{2GM/r} dr/c`, which for a surface at 0.3 GM/c² is 116 GM/c —
+ * 0.6 ms at a solar mass, easily heard. But `R_c` is 1.9567 CELLS, so for a
+ * solar mass `r_s = 2.1·10⁻³⁸ GM` and the delay carries `e^(9.3·10³⁷)`. The
+ * echoes never come back. A horizon and a Planck-scale surface are the same
+ * thing to anybody outside, because "no echo ever" and "no echo possible" are
+ * not distinguishable measurements. See `echoes.tsx`.
+ *
+ * AND HOW ONE MIGHT STILL TELL THEM APART. The obstacle is that `boost` only
+ * changes the metric where its gate is open, u₀ > u*, and the gate must sit
+ * below the photon sphere or β and the shadow both go wrong. So the two are
+ * IDENTICAL outside r = 2GM/c² and differ only INSIDE the photon sphere —
+ * from which nothing returns carrying information. That is a fact about the
+ * geometry, not about instruments improving.
+ *
+ * The one thing that escapes a horizon without crossing it is HAWKING
+ * RADIATION, which is a property of the horizon existing rather than of
+ * anything falling in. A surface, however deep, has no horizon and no
+ * temperature — and unlike every other test, that difference does not shrink
+ * as the surface gets deeper:
+ *
+ *     mass       Hawking lifetime    under boost   under hold
+ *     10¹¹ g     2.7e+0 yr           gone          still here
+ *     10¹⁴ g     2.7e+9 yr           gone          still here
+ *     10¹⁷ g     2.7e+18 yr          still here    still here
+ *
+ * The lifetime reaches the age of the universe at 1.7·10¹⁴ g, so BELOW ABOUT
+ * 10¹⁵ g THE TWO DISAGREE ABOUT WHETHER THE OBJECT EXISTS TODAY. That is a
+ * live observational programme already: the missing gamma-ray background from
+ * such evaporation is what currently excludes light primordial black holes as
+ * dark matter. Under `boost` that exclusion stands; under `hold` it vanishes
+ * and the whole window below 10¹⁵ g reopens.
+ *
+ * AND THE OBJECTION TO IT, which is not small: a surface at extreme redshift
+ * can MIMIC a horizon thermodynamically — a collapsing object radiates a burst
+ * approaching a thermal spectrum as it settles, and an observer with finite
+ * patience cannot tell that from the real thing. Whether the mimicry is exact
+ * or merely good for a while is not settled here, and the answer decides
+ * whether this discriminator is real at all.
+ *
+ * SO: ONE CANDIDATE, resting on a question about horizon thermodynamics nobody
+ * here has answered, and everything else provably out of reach. Both routes
+ * are therefore OPTIONAL CONSEQUENCES (see `OPTIONAL` in `regimes.ts`) —
+ * reachable through spatial density or through the emission boost, and not
+ * distinguishable by anything this model can currently point at.
+ *
+ * SO THE TWO ROUTES ARE OBSERVATIONALLY IDENTICAL AS THINGS STAND — image and
+ * ringdown alike. The model does not predict echoes and it would be wrong to
+ * advertise horizonlessness as though it did. What remains observable is the
+ * shadow, and nothing whatever about the interior.
+ *
  * WHAT NEITHER FIXES: the neutron star still shows about half its mass. Route
  * two makes it marginally worse, since a boost at u ~ 0.2 raises emission and
  * so raises Φ and so screens harder. That bill is outstanding under both.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index de12b6b..ee8fdf6 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -1,6 +1,8 @@
 import { Fragment, ReactNode, useEffect, useRef, useState } from "react";
 
 import { GRAIN } from "./gravity";
+import { Echoes } from "./echoes";
+import { Overlay, Routes, Seam, Shadows } from "./shadow";
 
 /**
  * The law, on the page — and behind each equation, where it came from.
@@ -2528,6 +2530,45 @@ export const Law = () => {
       1.0463
     </Eq>
 
+    <Shadows />
+
+    <Note>
+      Same mass, same camera, same disc — the only difference between the two is{' '}
+      <V>A</V> and <V>B</V>. Rays are traced backwards from the eye until they
+      escape or run into the matter, which is the only thing that stops one
+      here, there being no horizon to fall through. The disc is thin and seen
+      nearly edge on, so its far side is bent up over the top and down under the
+      bottom; that arch is what makes the shadow’s edge legible at all. The
+      solid ring is general relativity’s critical impact parameter and the
+      dashed one is this model’s, both drawn on both panels.
+    </Note>
+
+    <Seam />
+
+    <Note>
+      Two panels ask the eye to remember a radius while it travels between them,
+      which it is bad at. Cut down the middle instead — general relativity left
+      of the seam, the counted metric right of it, everything else identical —
+      and{' '}
+      <b style={{ color: INK }}>the shadow’s edge and the photon ring both step
+        as they cross it</b>. A step is something the eye is very good at. Each
+      side keeps its own colour, and each critical radius is drawn as a half-arc
+      on its own side.
+    </Note>
+
+    <Overlay />
+
+    <Note>
+      And laid on top of each other rather than beside:{' '}
+      <b style={{ color: INK }}>amber and blue cancel to pale wherever the two
+        agree, and whatever is left over is the difference</b>. So the image is
+      white except for a coloured rim around the shadow and along every lensed
+      edge — blue outside, because this model’s shadow is the larger. Nothing is
+      exaggerated; it is the same 4.6% at its true size. Traced rather than
+      derived, the two edges come out at 5.196153 and 5.436619 against closed
+      forms of 5.196152 and 5.436564.
+    </Note>
+
     <Note>
       The photon sphere is where d/d<V>r</V>(<V>r</V><Sup>2</Sup><V>B</V>/<V>A</V>) = 0;
       with <V>B</V>/<V>A</V> = <V>e</V><Sup>4<V>u</V></Sup> that is{' '}
@@ -2542,6 +2583,98 @@ export const Law = () => {
       one, and the only claim here an existing instrument can settle.
     </Note>
 
+    <Head>and do the two dark objects look different</Head>
+
+    <Note>
+      <b style={{ color: INK }}>No — they are the same picture.</b> A shadow is
+      set by the photon sphere, and both routes share the whole exterior{' '}
+      <V>A</V> = <V>e</V><Sup>−2<V>u</V><Sub>0</Sub></Sup> down to it. What
+      separates them lies <i>below</i> the ring, where no image can reach: route
+      one has a surface at <V>R</V><Sub>c</Sub>, route two a horizon at{' '}
+      <V>u</V><Sub>0</Sub> = 1.
+    </Note>
+
+    <Routes />
+
+    <Note>
+      Which makes the gate an observable. The boost has to wake up below some
+      depth <V>u</V>* or β goes wrong — and the unboosted photon sphere sits at{' '}
+      <V>u</V><Sub>0</Sub> = ½:{' '}
+      <b style={{ color: INK }}>gate it deeper and route two is pixel for pixel
+        route one; gate it shallower and the shadow balloons</b> — 7.1% over
+      general relativity at <V>u</V>* = 0.4, 49% with no gate at all. The third
+      panel is that last case, drawn not because the model says it but to show
+      what being wrong would look like. It is far outside what the Event Horizon
+      Telescope allows, so imaging already constrains where the gate can sit.
+    </Note>
+
+    <Note>
+      The usual fallback is a <i>ringdown</i>: a horizon absorbs what falls
+      through it and the signal stops, while a surface reflects and the wave
+      trapped under the photon sphere leaks back out as late echoes — which is
+      what LIGO and Virgo searches look for.{' '}
+      <b style={{ color: INK }}>This page said that separates the two routes.
+        It does not.</b>
+    </Note>
+
+    <Echoes />
+
+    <Note>
+      The delay is the round trip at the coordinate speed of light,{' '}
+      Δ<V>t</V> = 2∫<V>e</V><Sup>2<V>GM</V>/<V>r</V></Sup>d<V>r</V>/<V>c</V>.
+      For a surface at 0.3 <V>GM</V>/<V>c</V><Sup>2</Sup> that is 116{' '}
+      <V>GM</V>/<V>c</V> — 0.6 ms at a solar mass, easily heard. But{' '}
+      <V>R</V><Sub>c</Sub> is 1.96 <i>cells</i>, so a solar mass puts the
+      surface at 2·10<Sup>−38</Sup> <V>GM</V> and the delay carries a factor{' '}
+      <V>e</V><Sup>(9·10³⁷)</Sup>.{' '}
+      <b style={{ color: INK }}>The echoes never come back — not late,
+        never.</b>
+    </Note>
+
+    <Note>
+      So the two routes are observationally identical, full stop: image and
+      ringdown alike. A horizon and a Planck-scale surface are the same thing to
+      anybody outside, because <i>no echo ever</i> and <i>no echo possible</i>{' '}
+      are not distinguishable measurements.{' '}
+      <b style={{ color: INK }}>The model does not predict echoes</b>, and it
+      would be wrong to advertise horizonlessness as though it did. What remains
+      observable is the shadow, and nothing at all about the interior.
+    </Note>
+
+    <Head>so both are optional, and how one might still tell</Head>
+
+    <Note>
+      Neither route is required by anything else here — a dark object is
+      reachable through <i>spatial density</i> or through the emission boost,
+      and <b style={{ color: INK }}>the two cannot be told apart</b>. The
+      obstacle is structural: the boost only changes the metric where its gate
+      is open, the gate must sit below the photon sphere, so the two are
+      identical outside 2<V>GM</V>/<V>c</V><Sup>2</Sup> and differ only inside
+      it — and nothing returns from inside a photon sphere carrying
+      information. That is the geometry, not the instruments.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>the one thing that escapes</span>,
+        <>Hawking radiation is a property of a horizon <i>existing</i>, not of
+          anything crossing it — so a surface has none, however deep, and{' '}
+          <b style={{ color: INK }}>that difference does not shrink with
+            depth</b>, which is what killed every other test.</>],
+      [<span style={{ color: DERIVED }}>and where it shows</span>,
+        <>The Hawking lifetime reaches the age of the universe at
+          1.7·10<Sup>14</Sup> g, so below about 10<Sup>15</Sup> g the two
+          disagree about whether the object <i>exists today</i>. Under the boost
+          the missing evaporation gamma-rays exclude light primordial black
+          holes as dark matter; under spatial density that exclusion vanishes
+          and the window reopens.</>],
+      [<span style={{ color: BORROWED }}>and the objection</span>,
+        <>A surface at extreme redshift can <i>mimic</i> a horizon
+          thermodynamically — a collapsing object radiates a burst approaching
+          a thermal spectrum as it settles. Whether the mimicry is exact or
+          only good for a while is not settled here, and the answer decides
+          whether this discriminator is real.</>],
+    ]} />
+
     <Note>
       Neither route fixes the neutron star, and route two makes it slightly
       worse — a boost at <V>u</V> ~ 0.2 raises emission, which raises{' '}
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
index ce13cf4..156582a 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
@@ -189,6 +189,22 @@ export type Recovered = keyof typeof RECOVERS;
 /** The setting that recovers a named theory. */
 export const setting = (of: Recovered): Regime => ({ ...RECOVERS[of] });
 
+/**
+ * WHICH KNOBS ARE OPTIONAL CONSEQUENCES rather than parts of the model.
+ *
+ * `hold` and `boost` are both ways to get a dark compact object, and neither is
+ * required by anything else here. More than that: THEY CANNOT BE TOLD APART.
+ * Both share the exterior metric down to the photon sphere, so the shadow is
+ * the same; and `hold`'s surface sits so deep that the echo delay carries
+ * e^(9·10³⁷), so the ringdown is the same too. The difference is sealed inside
+ * the photon sphere, which is not a limit of instruments but of the geometry.
+ *
+ * The one candidate that escapes is Hawking radiation, since it is a property
+ * of a horizon EXISTING rather than of anything crossing it — see the foot of
+ * `gravity.ts`. Until that is settled, both stay optional and neither is on.
+ */
+export const OPTIONAL: (keyof Regime)[] = ["hold", "boost"];
+
 /**
  * Whether a regime is coherent — which is not the same as being in range.
  *
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/shadow.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/shadow.tsx
new file mode 100644
index 0000000..92cac17
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/shadow.tsx
@@ -0,0 +1,493 @@
+/**
+ * WHAT THE TWO METRICS LOOK LIKE, AND WHERE THEY COME APART.
+ *
+ * The file says the shadow is 4.6% larger than general relativity's at the same
+ * mass. That is a claim about an image, so it is worth making the image — but a
+ * black hole on its own is a black disc on nothing, and 4.6% of a black disc is
+ * invisible. What makes one legible is a thin accretion disc seen nearly edge
+ * on, whose far side is bent up over the top and down under the bottom, and
+ * whose inner edge sits just outside the photon ring. That arch is the ruler.
+ *
+ * The disc is BANDED rather than smooth, and deliberately so: a smooth glow
+ * hides exactly the structure that lensing does to it, and bands make every
+ * image of the disc — the direct one, the one bent over the top, and the
+ * higher ones crushed into the ring — countable by eye.
+ *
+ * AND THE TWO ARE DRAWN IN DIFFERENT COLOURS so they can be laid over each
+ * other. `Overlay` traces both into one frame, general relativity in amber and
+ * the counted metric in blue: everywhere they agree the two add to near-white,
+ * and everywhere they differ a coloured fringe is left behind. The fringe IS
+ * the 4.6%, at its true size, with nothing exaggerated.
+ *
+ * HOW A RAY IS TRACED. Spherical symmetry keeps every ray in the plane through
+ * the camera, the ray and the centre, so with u = 1/r
+ *
+ *     u″ = (B/A)′/(2b²) − u
+ *
+ * — the second-order form, rather than `(du/dφ)² = (B/A)/b² − u²`, because that
+ * one has a square root that vanishes at the turning point and the rays that
+ * matter here are exactly the ones grazing it and winding round several times.
+ * This form is smooth through the turn and needs no sign flip.
+ *
+ * AND THE DISC IS FOUND WITHOUT LEAVING THE PLANE. r(φ) does not depend on how
+ * the plane is tilted, so it is tabulated once per impact parameter; the tilt
+ * only decides WHERE the plane crosses z = 0:
+ *
+ *     cos φ·e₁z + sin φ·e₂z = 0    ⇒    φ = atan2(−e₁z, e₂z) + kπ
+ *
+ * so the crossings sit a fixed angle apart, and each k is one more image of the
+ * disc.
+ */
+
+import { CanvasView, Surface } from "./canvas";
+
+const GM = 1;
+
+type Metric = {
+  name: string;
+  BA: (u: number) => number;          // B/A, all a null geodesic needs
+  dBA: (u: number) => number;         // and its derivative
+  crit: number;                       // critical impact parameter, GM/c²
+  ink: [number, number, number];      // the colour it is drawn in
+  css: string;
+};
+
+/** General relativity, isotropic, so both are read in the same coordinates. */
+export const EINSTEIN: Metric = {
+  name: "general relativity",
+  BA: (u) => {
+    const s = GM * u / 2;
+    return Math.pow(1 + s, 6) / Math.pow(1 - s, 2);
+  },
+  dBA: (u) => {
+    const s = GM * u / 2;
+    return (GM / 2) * (6 * Math.pow(1 + s, 5) / Math.pow(1 - s, 2)
+      + 2 * Math.pow(1 + s, 6) / Math.pow(1 - s, 3));
+  },
+  crit: 3 * Math.sqrt(3),
+  ink: [235, 150, 74],
+  css: "#eb964a",
+};
+
+/** And the compounded count — A = e^−2u, B = e^+2u, so B/A = e^4u. */
+export const COUNTED: Metric = {
+  name: "the compounded count",
+  BA: (u) => Math.exp(4 * GM * u),
+  dBA: (u) => 4 * GM * Math.exp(4 * GM * u),
+  crit: 2 * Math.E,
+  ink: [74, 168, 235],
+  css: "#4aa8eb",
+};
+
+/**
+ * AND THE BOOSTED ONE — route two, where matter in a folded place emits more,
+ * so `u = u₀/(1 − κu₀)` diverges and there is a genuine horizon.
+ *
+ * The boost has to be GATED: κ linear in u puts β at nought and the perihelion
+ * advance 33% high, so it can only wake up below some depth u*. And that gate
+ * turns out to decide whether any of this is visible at all —
+ *
+ *     gate u*   r of the gate   b_crit    vs GR    vs route one
+ *     1.00      1.000 GM        5.4366     4.6%     0.0%
+ *     0.50      2.000 GM        5.4366     4.6%     0.0%     ← the photon sphere
+ *     0.40      2.500 GM        5.5639     7.1%     2.3%
+ *     0.20      5.000 GM        7.7602    49.3%    42.7%
+ *
+ * — because a shadow is set by the PHOTON SPHERE, which sits at u₀ = ½ when the
+ * boost is asleep. Gate it any deeper than that and the horizon is hidden
+ * inside the ring, where no image can reach it, and route two is pixel for
+ * pixel route one. Gate it shallower and the shadow balloons past anything the
+ * Event Horizon Telescope allows.
+ *
+ * So this is drawn only to show what is EXCLUDED. The model's own setting has
+ * the gate deep, and looks exactly like `COUNTED`.
+ */
+export const boosted = (uStar: number): Metric => ({
+  name: `boosted, gate at u* = ${uStar}`,
+  BA: (U) => {
+    const u0 = GM * U;
+    return Math.exp(4 * (u0 < uStar ? u0 : u0 / (1 - u0)));
+  },
+  dBA: (U) => {
+    const h = 1e-7;
+    const f = (x: number) => {
+      const u0 = GM * x;
+      return Math.exp(4 * (u0 < uStar ? u0 : u0 / (1 - u0)));
+    };
+    return (f(U + h) - f(U - h)) / (2 * h);
+  },
+  crit: NaN,
+  ink: [214, 96, 122],
+  css: "#d6607a",
+});
+
+const STEPS = 2200;                   // φ samples per ray
+const DPHI = 0.007;                   // ≈ 4.9 turns: enough for two lensed images
+const LANES = 560;                    // impact parameters tabulated
+const R_IN = 6.0, R_OUT = 17;         // where the disc is
+
+/** r(φ) for every impact parameter, once. 0 = ran into matter, ∞ = escaped. */
+const tabulate = (m: Metric, rObs: number, rHit: number, bMax: number) => {
+  const R = new Float32Array(LANES * STEPS);
+  const uHit = 1 / rHit, uObs = 1 / rObs;
+
+  for (let lane = 0; lane < LANES; lane++) {
+    const b = bMax * (lane + 0.5) / LANES;
+
+    let u = uObs;
+    let du = Math.sqrt(Math.max(m.BA(u) / (b * b) - u * u, 0));
+
+    const acc = (uu: number) => m.dBA(uu) / (2 * b * b) - uu;
+
+    for (let i = 0; i < STEPS; i++) {
+      const at = lane * STEPS + i;
+
+      if (u >= uHit) { R[at] = 0; continue; }
+      if (u <= 0) { R[at] = Infinity; continue; }
+
+      R[at] = 1 / u;
+
+      const h = DPHI;
+      const k1u = du, k1d = acc(u);
+      const k2u = du + h / 2 * k1d, k2d = acc(u + h / 2 * k1u);
+      const k3u = du + h / 2 * k2d, k3d = acc(u + h / 2 * k2u);
+      const k4u = du + h * k3d, k4d = acc(u + h * k3u);
+
+      u += h / 6 * (k1u + 2 * k2u + 2 * k3u + k4u);
+      du += h / 6 * (k1d + 2 * k2d + 2 * k3d + k4d);
+    }
+  }
+  return R;
+};
+
+/**
+ * How bright the disc is at a place on it — banded in radius and streaked
+ * round, so the lensed copies stay distinguishable from the direct one.
+ */
+const brightness = (r: number, theta: number) => {
+  const t = Math.max(0, Math.min(1, (r - R_IN) / (R_OUT - R_IN)));
+
+  const fall = Math.pow(R_IN / r, 1.9);                  // hotter, denser inside
+  const rings = 0.62 + 0.38 * Math.cos(r * 2.9 - 0.6);   // radial banding
+  const arms = 0.78 + 0.22 * Math.cos(3 * theta + r * 0.55);
+  const edge = Math.min(1, (1 - t) * 6);                 // fade out at the rim
+
+  return Math.max(0, fall * rings * arms * edge);
+};
+
+/** The camera basis: out along x, lifted above the disc, looking at the middle. */
+const eye = (tilt: number) => {
+  const P: [number, number, number] = [Math.cos(tilt), 0, Math.sin(tilt)];
+  const fwd: [number, number, number] = [-P[0], -P[1], -P[2]];
+
+  const dz = fwd[2];
+  const raw = [-dz * fwd[0], -dz * fwd[1], 1 - dz * fwd[2]];
+  const n = Math.hypot(...raw);
+  const up = raw.map(v => v / n) as [number, number, number];
+
+  const right: [number, number, number] = [
+    fwd[1] * up[2] - fwd[2] * up[1],
+    fwd[2] * up[0] - fwd[0] * up[2],
+    fwd[0] * up[1] - fwd[1] * up[0],
+  ];
+  return { P, fwd, up, right };
+};
+
+type Look = { rObs: number; rHit: number; span: number; tilt: number };
+
+/**
+ * What one metric puts at one pixel: how bright, and whether the ray was
+ * swallowed. Kept apart from colour so two of them can be added.
+ */
+const shade = (
+  m: Metric, R: Float32Array, bMax: number,
+  px: number, py: number, surface: Surface, look: Look,
+) => {
+  const { width, height } = surface;
+  const half = Math.min(width, height) / 2;
+  const perPixel = look.span / half;
+
+  const { P, fwd, up, right } = eye(look.tilt);
+  const scale = perPixel / look.rObs;
+
+  const sx = (px + 0.5 - width / 2) * scale, sy = -(py + 0.5 - height / 2) * scale;
+
+  let d = [
+    fwd[0] + right[0] * sx + up[0] * sy,
+    fwd[1] + right[1] * sx + up[1] * sy,
+    fwd[2] + right[2] * sx + up[2] * sy,
+  ];
+  const dn = Math.hypot(...d);
+  d = d.map(v => v / dn);
+
+  const cosPsi = d[0] * fwd[0] + d[1] * fwd[1] + d[2] * fwd[2];
+  const raw = [d[0] - cosPsi * fwd[0], d[1] - cosPsi * fwd[1], d[2] - cosPsi * fwd[2]];
+  const e2n = Math.hypot(...raw);
+  const e2 = e2n > 1e-12 ? raw.map(v => v / e2n) : [0, 1, 0];
+  const e1 = P;
+
+  const b = look.rObs * Math.min(1, e2n) * Math.sqrt(m.BA(1 / look.rObs));
+
+  const base = Math.min(LANES - 1, Math.floor(b / bMax * LANES)) * STEPS;
+  const phi0 = Math.atan2(-e1[2], e2[2]);
+
+  for (let n = -2; n < 8; n++) {
+    const phi = phi0 + n * Math.PI;
+    if (phi <= 1e-4 || phi >= STEPS * DPHI) continue;
+
+    const idx = phi / DPHI, i0 = Math.floor(idx);
+    const a = R[base + i0], c = R[base + Math.min(STEPS - 1, i0 + 1)];
+    if (!isFinite(a) || !isFinite(c) || a === 0 || c === 0) continue;
+
+    const r = a + (c - a) * (idx - i0);
+    if (r < R_IN || r > R_OUT) continue;
+
+    // where on the disc it landed, so the banding can be read off it
+    const cp = Math.cos(phi), sp = Math.sin(phi);
+    const theta = Math.atan2(r * (cp * e1[1] + sp * e2[1]), r * (cp * e1[0] + sp * e2[0]));
+
+    // the images bent further round are dimmer, which is what separates them
+    const fade = 1 / (1 + 0.8 * Math.max(0, phi / Math.PI - 1));
+
+    return { lit: brightness(r, theta) * fade, swallowed: false };
+  }
+
+  for (let i = 0; i < STEPS; i++) {
+    const v = R[base + i];
+    if (v === 0) return { lit: 0, swallowed: true };
+    if (!isFinite(v)) break;
+  }
+  return { lit: 0, swallowed: false };
+};
+
+const GROUND = 5;                      // the ground both are drawn on
+
+/** One metric, in its own colour. */
+const one = (m: Metric, surface: Surface, look: Look) => {
+  const { ctx, width, height } = surface;
+  const img = ctx.createImageData(width, height);
+
+  const bMax = look.span * Math.SQRT2 * (width / Math.min(width, height)) + 1;
+  const R = tabulate(m, look.rObs, look.rHit, bMax);
+
+  for (let py = 0; py < height; py++)
+    for (let px = 0; px < width; px++) {
+      const { lit } = shade(m, R, bMax, px, py, surface, look);
+      const k = (py * width + px) * 4;
+
+      img.data[k] = GROUND + m.ink[0] * lit;
+      img.data[k + 1] = GROUND + m.ink[1] * lit;
+      img.data[k + 2] = GROUND + 3 + m.ink[2] * lit;
+      img.data[k + 3] = 255;
+    }
+
+  ctx.putImageData(img, 0, 0);
+};
+
+/** Both, added — agreement goes white, difference stays coloured. */
+const both = (surface: Surface, look: Look) => {
+  const { ctx, width, height } = surface;
+  const img = ctx.createImageData(width, height);
+
+  const bMax = look.span * Math.SQRT2 * (width / Math.min(width, height)) + 1;
+  const RA = tabulate(EINSTEIN, look.rObs, look.rHit, bMax);
+  const RB = tabulate(COUNTED, look.rObs, look.rHit, bMax);
+
+  for (let py = 0; py < height; py++)
+    for (let px = 0; px < width; px++) {
+      const a = shade(EINSTEIN, RA, bMax, px, py, surface, look);
+      const b = shade(COUNTED, RB, bMax, px, py, surface, look);
+      const k = (py * width + px) * 4;
+
+      img.data[k] = GROUND + EINSTEIN.ink[0] * a.lit + COUNTED.ink[0] * b.lit;
+      img.data[k + 1] = GROUND + EINSTEIN.ink[1] * a.lit + COUNTED.ink[1] * b.lit;
+      img.data[k + 2] = GROUND + 3 + EINSTEIN.ink[2] * a.lit + COUNTED.ink[2] * b.lit;
+      img.data[k + 3] = 255;
+    }
+
+  ctx.putImageData(img, 0, 0);
+};
+
+const Frame = ({ height, children }: { height: number; children: React.ReactNode }) =>
+  <div style={{ height, background: "#050508" }}>{children}</div>;
+
+const Label = ({ m }: { m: Metric }) => <div style={{
+  fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+  color: m.css, marginBottom: 6,
+}}>
+  {m.name}
+  <span style={{ color: "#6c7080", textTransform: "none", letterSpacing: 0 }}>
+    {"  b = "}{m.crit.toFixed(3)}{" GM/c²"}
+  </span>
+</div>;
+
+/** The two, side by side, each in its own colour. */
+export const Shadows = ({
+  rObs = 60, rHit = 0.05, span = 11, tilt = 0.13, height = 300,
+}: Partial<Look> & { height?: number }) => {
+  const look: Look = { rObs, rHit, span, tilt };
+
+  return <div style={{ display: "flex", gap: 12, flexWrap: "wrap" }}>
+    {[EINSTEIN, COUNTED].map(m => <div key={m.name} style={{ flex: "1 1 300px" }}>
+      <Label m={m} />
+      <Frame height={height}>
+        <CanvasView animate={false} deps={[m.name, rObs, rHit, span, tilt]}
+          paint={() => ({ frame: (s) => one(m, s, look) })} />
+      </Frame>
+    </div>)}
+  </div>;
+};
+
+/**
+ * The same two, cut down the middle: general relativity on the left of the
+ * seam, the counted metric on the right, everything else identical.
+ *
+ * Two panels ask the eye to remember a radius while it moves between them,
+ * which it is bad at. One frame with a seam asks it to spot a STEP where the
+ * shadow's edge and the photon ring cross the middle, which it is very good at
+ * — and each side keeps its own colour, so which half is which needs no
+ * remembering either.
+ */
+export const Seam = ({
+  rObs = 60, rHit = 0.05, span = 11.5, tilt = 0.13, height = 480,
+}: Partial<Look> & { height?: number }) => {
+  const look: Look = { rObs, rHit, span, tilt };
+
+  return <div>
+    <div style={{
+      display: "flex", justifyContent: "space-between", marginBottom: 6,
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+    }}>
+      <span style={{ color: EINSTEIN.css }}>← general relativity</span>
+      <span style={{ color: COUNTED.css }}>the compounded count →</span>
+    </div>
+
+    <Frame height={height}>
+      <CanvasView animate={false} deps={["seam", rObs, rHit, span, tilt]}
+        paint={() => ({
+          frame: (surface) => {
+            const { ctx, width, height: h } = surface;
+            const img = ctx.createImageData(width, h);
+
+            const bMax = span * Math.SQRT2 * (width / Math.min(width, h)) + 1;
+            const RA = tabulate(EINSTEIN, rObs, rHit, bMax);
+            const RB = tabulate(COUNTED, rObs, rHit, bMax);
+
+            for (let py = 0; py < h; py++)
+              for (let px = 0; px < width; px++) {
+                const left = px < width / 2;
+                const m = left ? EINSTEIN : COUNTED;
+                const { lit } = shade(m, left ? RA : RB, bMax, px, py, surface, look);
+                const k = (py * width + px) * 4;
+
+                img.data[k] = GROUND + m.ink[0] * lit;
+                img.data[k + 1] = GROUND + m.ink[1] * lit;
+                img.data[k + 2] = GROUND + 3 + m.ink[2] * lit;
+                img.data[k + 3] = 255;
+              }
+
+            ctx.putImageData(img, 0, 0);
+
+            // the seam, and each side's critical radius as a half-arc, so the
+            // step at the middle has something to be a step against
+            const cx = width / 2, cy = h / 2;
+            const perPixel = span / (Math.min(width, h) / 2);
+
+            ctx.save();
+            ctx.strokeStyle = "rgba(255,255,255,0.10)";
+            ctx.lineWidth = 1;
+            ctx.beginPath();
+            ctx.moveTo(cx, 0); ctx.lineTo(cx, h);
+            ctx.stroke();
+
+            ctx.lineWidth = 1.25;
+            for (const [m, from, to] of [
+              [EINSTEIN, Math.PI / 2, Math.PI * 1.5],
+              [COUNTED, -Math.PI / 2, Math.PI / 2],
+            ] as const) {
+              ctx.strokeStyle = m.css;
+              ctx.beginPath();
+              ctx.arc(cx, cy, m.crit / perPixel, from, to);
+              ctx.stroke();
+            }
+            ctx.restore();
+          },
+        })} />
+    </Frame>
+  </div>;
+};
+
+/**
+ * And both in one frame, which is the only way 4.6% is actually visible.
+ *
+ * Amber is general relativity, blue is the counted metric, and they are ADDED:
+ * where the two agree the pixel goes pale, and where they disagree it keeps
+ * whichever colour was left over. So the whole image is white except for a thin
+ * coloured rim around the shadow and along every lensed edge — and that rim is
+ * the difference, at its true size.
+ */
+export const Overlay = ({
+  rObs = 60, rHit = 0.05, span = 8, tilt = 0.13, height = 500,
+}: Partial<Look> & { height?: number }) => {
+  const look: Look = { rObs, rHit, span, tilt };
+
+  return <div>
+    <div style={{
+      display: "flex", gap: 18, marginBottom: 6,
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+    }}>
+      <span style={{ color: EINSTEIN.css }}>■ general relativity</span>
+      <span style={{ color: COUNTED.css }}>■ the compounded count</span>
+      <span style={{ color: "#6c7080" }}>■ both</span>
+    </div>
+
+    <Frame height={height}>
+      <CanvasView animate={false} deps={["both", rObs, rHit, span, tilt]}
+        paint={() => ({ frame: (s) => both(s, look) })} />
+    </Frame>
+  </div>;
+};
+
+
+/**
+ * The two dark objects the model allows, and the one it does not.
+ *
+ * Route one (a surface, no horizon) and route two (a horizon, boost gated deep)
+ * share the whole exterior down to the photon sphere, so they are the SAME
+ * PICTURE — there is nothing to draw twice. What is worth drawing beside them
+ * is the version where the gate is too shallow, because that is what the model
+ * would look like if it were wrong in the one way an image could catch.
+ */
+export const Routes = ({
+  rObs = 60, rHit = 0.05, span = 13, tilt = 0.13, height = 260,
+}: Partial<Look> & { height?: number }) => {
+  const look: Look = { rObs, rHit, span, tilt };
+
+  const shallow = boosted(0.2);
+  const panels: [Metric, string][] = [
+    [EINSTEIN, "b = 5.196"],
+    [COUNTED, "b = 5.437 — both routes, identically"],
+    [shallow, "b = 7.760 — excluded"],
+  ];
+
+  return <div style={{ display: "flex", gap: 12, flexWrap: "wrap" }}>
+    {panels.map(([m, note]) => <div key={m.name} style={{ flex: "1 1 220px" }}>
+      <div style={{
+        fontSize: "0.7em", letterSpacing: "0.07em", textTransform: "uppercase",
+        color: m.css, marginBottom: 6,
+      }}>
+        {m === EINSTEIN ? "general relativity"
+          : m === COUNTED ? "this model" : "gate too shallow"}
+        <span style={{
+          display: "block", color: "#6c7080",
+          textTransform: "none", letterSpacing: 0,
+        }}>{note}</span>
+      </div>
+
+      <Frame height={height}>
+        <CanvasView animate={false} deps={[m.name, rObs, rHit, span, tilt]}
+          paint={() => ({ frame: (s) => one(m, s, look) })} />
+      </Frame>
+    </div>)}
+  </div>;
+};

From 385d5f203c71a0789f45b6f673cc593b4953db0b Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Tue, 11 Aug 2026 19:26:31 +0200
Subject: [PATCH 27/47] Thinking cosmology

---
 .../2026.RayCalculiAndPhysics/discrete.ts     |   9 +-
 .../2026.RayCalculiAndPhysics/gravity.ts      | 877 ++++++++++++++++--
 .../2026.RayCalculiAndPhysics/index.tsx       | 101 +-
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 590 ++++++++++--
 .../2026.RayCalculiAndPhysics/model.ts        |  17 +
 .../2026.RayCalculiAndPhysics/models.ts       |  30 +-
 .../2026.RayCalculiAndPhysics/regimes.ts      |  27 +-
 .../2026.RayCalculiAndPhysics/views.tsx       |  43 +-
 orbitmines.com/src/routes/references.tsx      |   4 +-
 9 files changed, 1553 insertions(+), 145 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
index 24f6866..e98b5ee 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
@@ -1958,12 +1958,9 @@ export class Graph {
     graph.dims = 2;
     graph.ringRadius = size;
 
-    const half = Math.floor(size / 2);
-
     const coords: number[][] = [];
     for (let x = -size; x < size; x++)
-      for (let y = -half; y <= half; y++)
-        coords.push([x, y]);
+      coords.push([x, 0]);
 
     const { nodes, at, facing } = Graph.lay(graph, coords, { charge });
 
@@ -2052,8 +2049,8 @@ export class Graph {
 
     const coords: number[][] = [];
     for (let x = l0 - size; x <= r0 + size; x++)
-      for (let y = -half; y <= half; y++)
-        coords.push([x, y]);
+      // for (let y = -half; y <= half; y++)
+        coords.push([x, 0]);
 
     // Only the blocks are charged. The field between them is what space is
     // when nothing has happened to it yet.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index 8e60eca..cf114cd 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -658,17 +658,54 @@ export const thickness = (fold: number) => Math.exp(2 * Math.max(fold, 0));
  * limit of the model's own path sum, in the metric the model's own edge
  * counting gives.
  *
- * WHAT IS STILL OWED, and it is one thing rather than a category: the
- * checkerboard was built and MEASURED in flat space, with a reversal amplitude
- * `sin(m)` constant everywhere. The step above lets m vary from place to place
- * as `m·e^{−u₀}` and assumes stationary phase still picks the classical path.
- * That is standard for a slowly varying mass term and it has not been run here
- * — a position-dependent checkerboard is a day's work and has not been done.
- *
- * So the chain closes analytically and its last link is unmeasured. That is a
- * different kind of debt from "this is general relativity's equation", and it
- * is a runnable test rather than an open question. `regimes.ts` tracks it under
- * `untested` rather than `borrows`.
+ * FOURTH, AND THIS WAS THE LAST THING OWED: the checkerboard was built and
+ * measured in FLAT space, with a reversal amplitude `sin(m)` constant
+ * everywhere, and the step above lets m vary from place to place. So a
+ * POSITION-DEPENDENT CHECKERBOARD was built and run.
+ *
+ * The fold hands the walk ONE number and not two. A node folded by u₀ has
+ * WAYS + n edges, and every edge is diluted by the same `e^{−u₀}` — there is
+ * no way to thin the turning edge and not the carrying one, since it is the
+ * same count in the same denominator. Which is worth pausing on, because it
+ * says the whole of gravity is a POSITION-DEPENDENT TICK RATE and nothing
+ * else: in cells, where a cell is a proper length because folding makes more
+ * nodes rather than longer edges, `H = e^{−u₀}·√(m² + p²)`. That is exactly
+ * `√(A m² + (A/B)p²)` rewritten, since one cell is √B of the coordinate — one
+ * number per node going in, and BOTH metric functions coming out.
+ *
+ * In the coordinate the rest of this file uses, so that the comparison is
+ * literally against `carry`, the generator is
+ *
+ *     H = ½{v(x), σ_z p̂} + m√A(x) σ_x
+ *
+ * — nearest neighbour, Hermitian, and at u = 0 the flat checkerboard's own
+ * generator, with σ_z carrying the two headings and σ_x turning between them.
+ * A Gaussian packet was put through a fold 0.06 deep and 150 cells wide, and
+ * its centre followed the classical path:
+ *
+ *     t      ⟨x⟩ measured    classical path   cells apart
+ *     160     450.4565        450.5405        −0.084
+ *     480     740.0414        740.3822        −0.341
+ *     800    1009.2375       1009.1243        +0.113
+ *
+ * against a bend of 44.16 cells — the whole difference the fold makes. Norm
+ * held to 6·10⁻¹⁵, so it is unitary rather than nearly so. Swept over k, m and
+ * depth the bend comes to 0.991…0.994 of the classical one, and that residual
+ * IS THE CLASSICAL LIMIT NOT YET REACHED rather than a disagreement — scaling
+ * the fold's width and the run's length by λ and the packet's width by √λ:
+ *
+ *     λ      bend measured   classical      ratio       gap      ×
+ *     0.5     −19.3490       −19.7213      0.981121   −1.888%
+ *     1.0     −39.0706       −39.4420      0.990583   −0.942%   0.499
+ *     2.0     −78.5121       −78.8834      0.995293   −0.471%   0.500
+ *     4.0    −157.3949      −157.7657      0.997650   −0.235%   0.499
+ *
+ * — halving each time the geometry doubles, which is 1/λ, which is the leading
+ * semiclassical correction and nothing else. STATIONARY PHASE STILL PICKS THE
+ * CLASSICAL PATH when the reversal amplitude varies from place to place.
+ *
+ * So the chain closes, and it closes measured. `untested` is empty for this
+ * model's own setting, as `borrows` already was.
  */
 export const carry = (px: number, py: number, fold: number) => {
   const A = slowing(fold), B = thickness(fold);
@@ -2093,9 +2130,37 @@ export const REACHES = Math.sqrt(
  *     matter there is — to close. It fails on the plainest thing available:
  *     there is not enough matter.
  *
- * AND THE SIGN OF ALL FIVE IS THE SAME, which is the thing worth noticing. The
+ *  6. AND THE ESCAPE FROM NEEDING ANY OF IT, WHICH FAILS STRUCTURALLY. A static
+ *     universe does not have to expand if light TIRES — loses energy on the way
+ *     — and that is the standing offer for anyone whose cosmology comes out
+ *     static. The lattice cannot take it. `through` gives a charge arriving at
+ *     an occupied cell exactly two outcomes and there is no third:
+ *
+ *         ANNIHILATE   the charge is destroyed        extinction
+ *         REVERSE      it goes back the way it came   extinction
+ *
+ *     Neither is a soft, forward, small-energy scatter — a step is one cell and
+ *     a heading is one of WAYS, so a photon either continues EXACTLY or leaves
+ *     the line of sight entirely. The beam goes as `e^{−D/λ}` and the survivors
+ *     arrive at the frequency they left with. THE MODEL CAN DIM LIGHT AND
+ *     CANNOT REDDEN IT, and that is a fact about what a lattice step is rather
+ *     than a number coming out wrong.
+ *
+ *     AND THE SAME OBSERVATION TIGHTENS (1) BY THIRTY ORDERS. Φ₀ was bounded by
+ *     asking gravity to survive to 1 AU; but Φ₀ also sets light's extinction
+ *     length, and we can see quasars:
+ *
+ *         what must survive     Φ₀ below     H it permits    short by
+ *         gravity at 1 AU       2.2e−46      1.4e−49 /s      10³¹
+ *         a quasar at z ~ 6     1.0e−61      3.4e−80 /s      10⁶²
+ *
+ *     — which puts the vacuum route at 62 orders, beside the matter route's 61.
+ *     The two independent routes agree on the size of the hole, which they did
+ *     not before, and it is the transparency of the sky that does it.
+ *
+ * AND THE SIGN OF ALL SIX IS THE SAME, which is the thing worth noticing. The
  * usual embarrassment is a vacuum energy 10¹²⁰ too LARGE. Every mechanism this
- * lattice has runs the other way — 35 orders short on the vacuum route, 61 on
+ * lattice has runs the other way — 62 orders short on the vacuum route, 61 on
  * the matter route — so the model does not have the cosmological constant
  * problem, it has its mirror image. A model that cannot make the universe
  * expand at all is wrong in a way that can be stated and looked for.
@@ -2103,6 +2168,534 @@ export const REACHES = Math.sqrt(
  * So: no expansion, no dark energy, no thermal history, and — since ± pairs
  * are made in exact pairs — no matter/antimatter asymmetry either. What the
  * model has instead is `reach` above, which is a prediction rather than a gap.
+ *
+ * AND WHAT THAT IS WORTH SAYING AS A PREDICTION RATHER THAN A GAP, because a
+ * static universe is not a silence — it is a claim, and it is measured:
+ *
+ *     surface brightness      model (1+z)⁰        observed (1+z)⁻⁴
+ *     supernova light curves  the same width      stretched by (1+z)
+ *     a microwave background  none, no hot past   2.7 K, and thermal
+ *
+ * The light curves are the sharpest of the three. At z = 1 the model says a
+ * supernova rises and falls in the SAME number of days as a nearby one, and the
+ * measurement says twice as many. That is not a percent-level disagreement
+ * better data might soften; it is the one place in this file where the model is
+ * not merely short but contradicted.
+ */
+
+/**
+ * SO: HOW FAST, HOW OLD, AND WHERE IS THE MIDDLE. The three questions anybody
+ * asks a cosmology, answered for the one this model actually has rather than
+ * for the one it fails to reproduce.
+ *
+ * HOW FAST. Both routes land in the same place, and neither is adjustable:
+ *
+ *     route                      H (/s)     1/H (yr)    1/H (ticks)
+ *     matter over the horizon    8.3e−80    3.8e+71     2.2e+122
+ *     the vacuum, capped         3.4e−80    9.3e+71     5.5e+122
+ *     ours, observed             2.2e−18    1.5e+10     8.5e+60
+ *
+ * The characteristic time is 10¹²² TICKS, which is the cosmological constant
+ * problem's own 10¹²⁰ arriving from the other side. That is either a coincidence
+ * of two large numbers or the same number twice, and this file has no way to
+ * tell which.
+ *
+ * HOW OLD. ETERNAL — and that is a derivation rather than an evasion. The rate
+ * is CONSTANT, because new points can split too, so the growth is exponential:
+ * de Sitter, with no first moment. No big bang, no thermal history, no age.
+ * Over our universe's 13.8 Gyr such a universe grows by `H·t = 3.6·10⁻⁶²`, one
+ * part in 10⁶¹, which is static for every purpose including this one.
+ *
+ * AND A THING THAT WAS QUIETLY BORROWED, caught while writing this down.
+ * `REACHES = √(8πG/3k·SHEET) = 0.361` — "gravity reaches a third of the way to
+ * the horizon in ANY universe this model describes" — got the density to cancel
+ * by using `ρ = 3H²/8πG`. THAT IS FRIEDMANN, and this model has no Friedmann
+ * equation. What survives is the absolute length, `λ = 1/√(k·SHEET·ρ)` = 1.60
+ * Gpc at the observed density; what does not is the claim that the fraction is
+ * universal. It is a fact about OUR density, not about any. The prediction
+ * stands and the count around it does not.
+ *
+ * OLBERS, AND WHY THERE IS STILL NO MICROWAVE BACKGROUND. A static eternal
+ * universe should glow like a stellar surface. This model is the rare one with
+ * a real answer: annihilation DESTROYS the charge, and the neutral point it
+ * leaves is inert — it has to be, since a splitting one expands the universe
+ * (closure 2). So the sink is not thermodynamic, nothing re-radiates, and the
+ * sky saturates at `ρ_L·λ/4π` instead of at a temperature:
+ *
+ *     λ          sky (W/m²/sr)   against the CMB
+ *     1 Gpc      6.4e−9          6.4e−3
+ *     100 Gpc    6.4e−7          6.4e−1
+ *     1000 Gpc   6.4e−6          6.4e+0
+ *
+ * — starlight reaches the CMB's energy density at λ ≈ 156 Gpc, which is not
+ * absurd. AND IT IS BESIDE THE POINT, because of closure 7:
+ *
+ *  7. THE LATTICE CANNOT MAKE A BLACKBODY. Its two outcomes are ANNIHILATE and
+ *     REVERSE. Reversal redistributes direction, so the model CAN isotropise;
+ *     neither outcome moves energy between frequencies, so nothing can
+ *     THERMALISE. A spectrum goes in and the same spectrum comes out, smoothed
+ *     over the sky. FIRAS has the CMB as a blackbody to a part in 10⁵, and this
+ *     model has no mechanism that would produce one at any temperature. It is
+ *     the strongest closure of the seven because it is a MISSING CHANNEL rather
+ *     than a number coming out small — the same missing channel as closure 6,
+ *     counted once against redshift and once against thermalisation.
+ */
+
+/**
+ * AND WHERE THE MIDDLE WOULD BE, IF THERE IS ONE.
+ *
+ * The model's own cosmology is homogeneous, so it has no centre. A centre
+ * exists only if the LATTICE IS FINITE, which the model neither requires nor
+ * forbids — nothing in the rules says how many cells there are. So this is a
+ * question about an extra assumption, and it is worth asking because it is the
+ * one assumption that would show up in the sky.
+ *
+ * Take a ball of radius R, an observer at distance d from the middle, and the
+ * extinction length λ that closure 6 already fixes the meaning of. The sky in a
+ * direction ψ from "straight out" is how much universe is along that line:
+ *
+ *     B(ψ) = 1 − e^{−L(ψ)/λ},   L(ψ) = −d cos ψ + √(R² − d² sin²ψ)
+ *
+ * — brighter looking ACROSS the middle, where there is more of it. That is one
+ * function with two parameters, so two measured multipoles fix it and every
+ * other one is a prediction. Taking the dipole as entirely positional and the
+ * quadrupole as the second constraint:
+ *
+ *     R/λ = 2.5559     d/λ = 0.014658     d/R = 0.57%
+ *
+ *     dipole       3.3621 mK    fitted
+ *     quadrupole   10.000 µK    fitted
+ *     octupole     8.368 nK     PREDICTED — observed ~25 µK
+ *     l = 4        71 pK
+ *
+ * IN LENGTHS, and every one of them is a floor rather than a measurement, since
+ * λ is bounded below by the sky being clear and not bounded above at all:
+ *
+ *     λ = 10 Gpc     R = 25.6 Gpc     d = 147 Mpc
+ *     λ = 100 Gpc    R = 256 Gpc      d = 1.47 Gpc
+ *
+ * THE DIRECTION IS THE ONE THING THAT IS NOT A FLOOR. Brightness rises where
+ * the chord is longest, so the middle lies at the dipole's HOT pole:
+ *
+ *     (l, b) = (264.0°, +48.3°)  =  RA 11ʰ12ᵐ, Dec −7.2°, in Crater
+ *
+ * — and we would sit half a percent of the way out from it, about 150 Mpc, in a
+ * universe some 25 Gpc across.
+ *
+ * THREE THINGS AGAINST IT, in order of how fatal.
+ *
+ * THE OCTUPOLE IS THREE THOUSAND TIMES TOO SMALL. One offset fixes every
+ * multipole at once — that is the whole appeal — and it fixes them falling as
+ * `(d/λ)^l`. Fit the dipole and quadrupole and the octupole arrives in
+ * NANOkelvin against an observed twenty-odd MICROkelvin. There is no freedom
+ * left to fix it: both parameters are spent.
+ *
+ * THE DIPOLE IS MEASURED TO BE MOTION, NOT POSITION. A boost aberrates the
+ * small-scale pattern and couples neighbouring multipoles; Planck detected
+ * exactly that coupling, at a velocity agreeing with the dipole. Standing
+ * off-centre aberrates nothing. So the positional part is at most a correction
+ * to the kinematic one, and the fit above is an upper bound on the offset
+ * rather than a determination of it.
+ *
+ * AND THERE IS NOTHING ABOVE l = 3 AT ALL. The measured spectrum has acoustic
+ * peaks at l ≈ 220, 540, 810 at percent precision. No oscillating fluid, no
+ * last scattering, no peaks — which is closure 7 again, wearing a different hat.
+ *
+ * WHAT IS WORTH KEEPING OUT OF IT. The SHAPE this construction predicts is a
+ * dipole, quadrupole and octupole ALL ALIGNED ON ONE AXIS with amplitudes
+ * falling geometrically — and that is, remarkably, the shape of the known CMB
+ * anomaly: the quadrupole and octupole are aligned with each other and roughly
+ * with the dipole at the tens-of-degrees level, and both are LOW. ΛCDM does not
+ * explain that. This model gets the shape and misses the size by three orders,
+ * which is a more interesting kind of wrong than usual, and it is the only
+ * place in the whole cosmology where the model says something specific about a
+ * measurement that is currently unexplained.
+ */
+
+/**
+ * AND THEN A DIFFERENT PLACE TO PUT THE CREATION, WHICH CHANGES MOST OF IT.
+ *
+ * Every route above makes space THROUGHOUT THE VOLUME, and every one dies of
+ * the same thing: the vacuum that makes the space is the fog that kills the
+ * gravity. That is one Φ doing two jobs, and it is not fixable by choosing a
+ * better number. But it is an assumption, and it was never argued for.
+ *
+ * PUT THE CREATION ONLY WHERE THERE IS NO SPACE YET. A cell on the FRONTIER of
+ * the lattice has nothing on one side. A charge emitted outward from it meets
+ * nothing — ever — so it never gives its point back, and that point is new
+ * space. A charge emitted inward meets the bulk and annihilates. Half the sky
+ * is empty at the frontier, so about half of what a frontier cell emits lands
+ * as space and the interior makes none at all.
+ *
+ * THE RATE IS THEN THE CEILING AND NOTHING ELSE. One emission per cell per tick
+ * is the most the lattice permits (`mass` in `physics.ts`), so a frontier cell
+ * can advance the frontier by at most one cell a tick:
+ *
+ *     dR/dt ≤ 1 cell per tick = c,   and it SATURATES, because the ceiling is
+ *                                     the rate rather than a bound on it
+ *
+ * No density, no Φ, no tuning, nothing fitted. `dR/dt = c`, so `R = c·t`.
+ *
+ * (The half-way house is worth recording too, because it is the version that
+ * fails. Keep creation in the BULK at C per cell per tick and let the escaping
+ * fraction be attenuated by `e^{−(R−r)/λ}`: the integral is a surface, so
+ * `dN/dt = C·4πR²λ` and `dR/dt = Cλ = √(C/k)`. That reaches c at C = k = ½,
+ * which is UNDER the ceiling where the bulk route needed 2 — closure 4 passes.
+ * But the same C gives λ = 2 cells, so gravity dies at two Planck lengths, and
+ * closure 1 is exactly as fatal as before. A bulk vacuum cannot be rescued by
+ * counting its escape properly. The frontier has to be the only source.)
+ *
+ * WHAT THAT DOES TO THE SEVEN:
+ *
+ *     1 screening          DISSOLVED    no bulk vacuum, so Φ₀ = 0
+ *     2 the attractor      DISSOLVED    the 3HΦ term assumed bulk expansion
+ *     3 matter too thin    DISSOLVED    expansion is not sourced by density
+ *     4 the clock          DISSOLVED    one a tick IS the rate, not half of it
+ *     5 escaping charges   SUPERSEDED   not the driver; the frontier is
+ *     6 light cannot tire  BYPASSED     the redshift is Doppler now
+ *     7 cannot thermalise  STANDS       still no blackbody, at any temperature
+ *
+ * Five of seven go, and they go for one reason rather than seven — they were
+ * all consequences of making space in the bulk.
+ *
+ * AND A HUBBLE LAW ARRIVES BY KINEMATICS. Matter that left the origin at t = 0
+ * and free-streams sits at `x = v·t`. For us at `d` and a galaxy at `x`, the
+ * separation is `r = x − d` and the relative velocity is `(x − d)/t = r/t`, so
+ * EVERY observer inside sees
+ *
+ *     v = H·r    with    H = 1/t    exactly, linear, and isotropic
+ *
+ * — no metric expansion, no stretched wavelengths, no tired light. The redshift
+ * is ordinary Doppler, which is why closure 6 stops mattering. And the age is
+ * then FORCED rather than fitted:
+ *
+ *     H₀ (km/s/Mpc)    age = 1/H₀     R = c/H₀
+ *     67.4             14.51 Gyr      4.45 Gpc
+ *     70.9             13.79 Gyr      4.23 Gpc
+ *     73.0             13.39 Gyr      4.11 Gpc
+ *
+ * against a measured 13.80 ± 0.02 Gyr and globular clusters at ~13.2. THE
+ * HUBBLE TENSION BRACKETS THE ANSWER: the two ends of the disputed H₀ give
+ * 14.51 and 13.39, and the measured age sits between them. A model whose age
+ * has no freedom to miss does not miss.
+ *
+ * IN THE MODEL'S OWN UNITS:
+ *
+ *     age        8.49·10⁶⁰ ticks
+ *     radius     8.49·10⁶⁰ cells        — the same number, which is R = ct
+ *     cells      2.57·10¹⁸³
+ *     frontier   9.06·10¹²² cells of surface
+ *
+ * AND A BILL ON THE FRONTIER ITSELF. If it were ceiling-density MATTER rather
+ * than fresh neutral space, one cell thick it would weigh 2·10¹¹⁵ kg against the
+ * universe's 10⁵³ — 10⁶² times too much. So the frontier must make SPACE and not
+ * matter: the pairs have to annihilate back and leave the point. Which is what
+ * `BITE` already says, so this is a consistency check that passes rather than a
+ * new assumption, but it is a tight one.
+ */
+
+/**
+ * SO WHERE IS THE CENTRE — and the answer is not a place.
+ *
+ * The tempting move is to read our offset off the temperature dipole. IT DOES
+ * NOT WORK, and the reason is structural rather than observational. An observer
+ * at `d` sees a shell of radius `D` around THEMSELVES; a point on it sits at
+ * `d·n̂_d + D·n̂` and moves at `(d·n̂_d + D·n̂)/t`, and averaging over the shell
+ * the `D·n̂` part vanishes by symmetry:
+ *
+ *     ⟨v_shell⟩ = d/t = our own velocity   ⇒   WE ARE AT REST IN ITS FRAME
+ *
+ * The dipole from standing off-centre CANCELS, exactly, to first order in d/R.
+ * That is the same cancellation that makes the Milne universe look isotropic to
+ * everybody in it, and it is why the measured dipole is our peculiar motion and
+ * nothing else — which is independently what Planck's aberration measurement
+ * says. The two arguments agree, from opposite directions.
+ *
+ * AND A CORRECTION, because the first version of this said something false. It
+ * claimed that with `dR/dt = c` the origin lies ON our past light cone in every
+ * direction, so the centre is "a time, not a place". IT IS NOT. Our past light
+ * cone reaches t = 0 on a sphere of radius `ct₀` around US; the origin is a
+ * single point at distance `d ≪ ct₀`, well INSIDE that sphere. The origin is an
+ * ordinary place with an ordinary direction, and the model has a preferred
+ * frame after all.
+ *
+ * WHAT IS ACTUALLY THERE. The frontier at time t′ sits at `ct′` from the
+ * origin; our backward cone at t′ is at `c(t₀−t′)` from us. Both at once:
+ *
+ *     s(ψ) = (c²t₀² − d²) / (2(ct₀ + d cos ψ))  ≈  ct₀/2 − (d/2)·cos ψ
+ *
+ * — THE FRONTIER APPEARS AT HALF THE HORIZON DISTANCE, 6.9 Gly, and its
+ * distance is DIPOLAR with fractional amplitude `d/R`. So there is a surface at
+ * a definite distance with a definite offset, which is exactly the structure
+ * the question was after.
+ *
+ * IT IS STILL INVISIBLE, but for a better reason than the wrong one. The
+ * frontier recedes at exactly c, so β = 1, γ = ∞, and it is infinitely
+ * redshifted. Just inside it the redshift is large but finite, so the model
+ * DOES have a surface of last visibility at z → ∞ whose distance carries a
+ * dipole of size `d/R`. Which is the structure a microwave background would
+ * test — if the model could produce one, which closure 7 says it cannot.
+ *
+ * WHAT THE SKY ACTUALLY SAYS, for the record, because the question deserves the
+ * measurement and not just the theory. The CMB does carry evidence that the
+ * soup is not the same in every direction, and it is NOT the temperature
+ * dipole:
+ *
+ *     hemispherical power asymmetry   ~7% dipolar modulation, l < 64,
+ *                                     toward (l, b) ≈ (220°, −20°)
+ *     quadrupole–octupole alignment   the "axis of evil", tens of degrees
+ *     the Cold Spot                   ~5° across, ~70 µK
+ *     low quadrupole, odd parity      both at 2–3σ
+ *
+ * The first is the one that means what the question means: the AMPLITUDE of the
+ * fluctuations differs by hemisphere, which is the primordial conditions
+ * themselves differing by direction. Read as an offset, with conditions varying
+ * over the scale of the ball, `A ≈ d/R` gives
+ *
+ *     d/R ≈ 0.07  ⇒  d ≈ 310 Mpc, toward (l, b) ≈ (220°, −20°)
+ *
+ * AND THE TWO SIGNALS DO NOT AGREE, WHICH IS THE TEST. One offset has to
+ * produce every anomaly at once. Read off the temperature dipole instead it is
+ * `d/R = 1.2·10⁻³`, i.e. 5.5 Mpc — a factor of 57 apart — and the two
+ * directions are some 70° from each other. No single geometry does both, which
+ * is what the cancellation above already predicted.
+ *
+ * AND DOES GRAVITY DECELERATE THE FREE-STREAMING? MOSTLY NOT, AND THE REASON IS
+ * COUNTABLE.
+ *
+ * The easy version — "gravity cannot reach because it is moving away" — is
+ * false as stated: everything interior recedes at β = s/ct < 1 while gravity
+ * travels at 1, so the influence does arrive. But the model's gravity is a
+ * MEETING RATE OF TWO FLUXES, and the flux from a receding source is thinned:
+ *
+ *     D(β) = 1/(γ(1+β)) = √((1−β)/(1+β)),    and D = 0 for β ≥ 1
+ *
+ * — the second half of which is the intuition made exact. Mass further than
+ * `ct` away recedes at or above c and its gravity NEVER ARRIVES, ever.
+ *
+ * The pull at radius r is `∫dΩ cos ψ ∫₀^chord D(s) ds` — the s² of the inverse
+ * square cancels the s² of the volume element, so it is one clean double
+ * integral, and with D = 1 it gives back `−(4/3)πGρr` exactly, which is the
+ * check that it is the same law. With D:
+ *
+ *     r/R     Newtonian    with recession   ratio
+ *     0.10    0.418879     0.028374         0.068
+ *     0.50    2.094395     0.404808         0.193
+ *     0.90    3.769911     1.311193         0.348
+ *     0.99    4.146902     1.654642         0.399
+ *
+ *     mass-weighted over the ball                0.309
+ *
+ * The suppression is strongest in the MIDDLE, which is the opposite of the
+ * naive guess and is right: near the centre the pull is a small residual left
+ * over from a nearly cancelling sphere, and killing the far side kills the
+ * residual. So the effective density is a third of the real one.
+ *
+ * WHICH IS ONLY ENOUGH BECAUSE THERE IS NO DARK MATTER. Ω is not a choice, it
+ * is what there is, and this model has no dark matter particle:
+ *
+ *     case                          t₀·H₀    age at H₀ = 67.4
+ *     pure free-streaming           1.0000   14.51 Gyr
+ *     baryons, recession thinned    0.9722   14.10 Gyr
+ *     baryons, no thinning          0.9359   13.58 Gyr
+ *     ΛCDM's dark matter too        0.8039   11.66 Gyr
+ *
+ * against a measured 13.80 ± 0.02 and globular clusters at ~13.2. FREE-STREAMING
+ * IS RECOVERED TO THREE PERCENT, and the thinned-baryon case gives exactly
+ * 13.80 Gyr at H₀ = 68.9 — inside the disputed 67…73. With ΛCDM's dark matter
+ * the universe would be YOUNGER THAN ITS OLDEST STARS, which is the age crisis
+ * that Λ was invented to fix. Having no dark matter is what saves this, and it
+ * is the same absence that ruins the rotation curves.
+ *
+ * AND YES, THE EXPANSION RATE IS WRONG AT NUCLEOSYNTHESIS — by 5·10⁷.
+ * Radiation-dominated BBN has `a ∝ √t`, so `H ∝ T²`; coasting has `a ∝ t`, so
+ * `T ∝ 1/t` and `H ∝ T`. A different POWER, not a different constant:
+ *
+ *     T = 1 MeV arrives at t = 1.0·10⁸ s (3.2 yr), not at 1 s
+ *     so H is smaller by 5.1·10⁷
+ *
+ * Freeze-out is where `Γ ∝ T⁵` falls below H. Standard `Γ/H ∝ T³` freezes at
+ * 0.8 MeV; coasting `Γ/H ∝ T⁴` freezes 85× lower, at 9.5 keV, where
+ * `n/p = e^{−1.293/0.0095} = e^{−137} ≈ 4·10⁻⁶⁰`. ZERO NEUTRONS, SO ZERO
+ * HELIUM, against a measured `Y_p = 0.245 ± 0.003` in the most metal-poor
+ * systems known. Not a tension — an absence.
+ *
+ * AND IT IS MOOT, WHICH IS WORSE. The model has no hot early phase at all
+ * (closure 7), so it never gets as far as running BBN badly; it has the deeper
+ * problem of having no source for the light elements. The sharpest of those is
+ * not helium but DEUTERIUM: stars destroy it and essentially nothing makes it,
+ * yet pristine high-redshift clouds show `D/H = 2.5·10⁻⁵`. That one number is
+ * the cleanest evidence there is for an early hot dense phase, and this model
+ * has nowhere to put one.
+ *
+ * SO WHAT IS LEFT OWED, honestly ranked:
+ *
+ *   THE LIGHT ELEMENTS, with no mechanism and no room for one.
+ *   THE MICROWAVE BACKGROUND, closure 7, untouched by any of this.
+ *   THE ROTATION CURVES, which the missing dark matter costs.
+ *   AND THE INITIAL CONDITION: `v = x/t` still needs everything to have left
+ *   the origin at once with a spread of velocities, which nothing here derives.
+ *
+ * What is NOT owed any more is the deceleration, which was the reason to doubt
+ * the free-streaming, and which turns out to be a third of an already small
+ * number.
+ */
+
+/**
+ * AND THEN DARK MATTER, WHICH THE MISSING DECELERATION JUST MADE MORE URGENT.
+ *
+ * WHAT IT HAS TO DO, stated so it can be failed. Flat rotation curves want
+ * `v² = GM(r)/r` constant, so `M(r) ∝ r`, so
+ *
+ *     ρ_halo ∝ 1/r²      AND THE EXTRA PULL IS INWARD
+ *
+ * Both halves matter, and the second is the one that kills the obvious idea.
+ * The obvious idea is that emptier outskirts make more space, so there is more
+ * expansion out there pulling on the stars. TWO THINGS GO WRONG:
+ *
+ *   THE SHELL THEOREM. Space made in a shell OUTSIDE a star's orbit has no
+ *   inside — a uniform shell has no preferred direction within it, so it moves
+ *   nothing there. Only space made INSIDE the orbit acts on the star, and that
+ *   pushes it OUTWARD. For a circular orbit `v²/r = g_grav − g_push`, so an
+ *   outward push LOWERS the speed a star can hold. Dark matter is MISSING
+ *   CENTRIPETAL FORCE; this supplies the opposite.
+ *
+ *   AND IT UNDOES THE COSMOLOGY. The whole virtue of putting the creation at
+ *   the frontier is that THE BULK MAKES NO SPACE, which is what dissolved
+ *   closures 1 through 4. Wanting voids to create locally puts it back in the
+ *   bulk and brings all four failures with it. The two ideas cannot both hold.
+ *
+ * BUT THERE IS SOMETHING REAL UNDERNEATH, AND IT IS WORTH SEPARATING OUT. The
+ * reason a bulk vacuum was fatal was screening — one Φ making space and
+ * stopping gravity. That was priced at the density EXPANSION needs. Dark matter
+ * needs almost nothing by comparison:
+ *
+ *     ρ_dark at the Sun's radius   7.0·10⁻²² kg/m³
+ *     as a lattice density         Φ = 1.4·10⁻¹¹⁸ per cell
+ *     screening length 1/(kΦ)      2.4·10⁸³ m = 10⁵⁷ Hubble radii
+ *
+ * against the Φ = 8.4·10⁻³¹ and λ = 38 µm expansion demanded — EIGHTY-EIGHT
+ * ORDERS lower. SO A GRAVITATING VACUUM AT DARK-MATTER DENSITY IS PERFECTLY
+ * FINE; closure 1 never applied at this scale. The whole question is the
+ * PROFILE and nothing else, which is a much better question to be left with.
+ *
+ * THREE PROFILES THE MODEL CAN MAKE:
+ *
+ *     mechanism                                  ρ(r)      M(r)    v(r)
+ *     a  uniform vacuum Φ₀ everywhere            const     r³      ∝ r      ✗
+ *     b  vacuum DEPLETED by the galaxy's own     ∝ r²      r⁵      ∝ r³ᐟ²   ✗
+ *        field, Φ ≈ C/kΦ_gal — screening
+ *     c  vacuum STIMULATED by it: a neutral      ∝ 1/r²    r       const    ✓
+ *        point splits when a charge arrives,
+ *        so Φ ∝ Φ_gal ∝ M/r²
+ *
+ * (c) IS THE RIGHT SHAPE AND IT IS NOT AN INVENTION. Rule 3 already says a
+ * neutral point becomes a pair; make that STIMULATED rather than spontaneous
+ * and the vacuum tracks the flux passing through it, which goes as M/r². That
+ * is an isothermal halo, exactly, and it comes with no new constant except the
+ * one that says how often a passing charge triggers a split.
+ *
+ * AND IT DIES ON TULLY–FISHER. With `ρ_halo = κM/4πr²`, `M_halo(r) = κMr`, so
+ * at large r `v² = GκM` and `v⁴ ∝ M²`. The baryonic Tully–Fisher relation is
+ * `v⁴ = GMa₀` — that is `v⁴ ∝ M¹`, with under 0.1 dex of scatter across five
+ * decades of mass:
+ *
+ *     M_b (M☉)    observed v    what (c) needs
+ *     1e+8        35.5 km/s     11.2
+ *     1e+10       112.3         112.3      (anchored here)
+ *     1e+12       355.2         1123.4
+ *
+ * A factor of ten at each end of the measured range. Not a tension — a
+ * different law. So the model can produce flat rotation curves and cannot
+ * produce the way they scale with mass, which is the usual fate of halo models
+ * and is why MOND-like schemes are about acceleration rather than density.
+ *
+ * THE ONE HOOK THAT IS NATIVE, AND IT IS AN ACCELERATION:
+ *
+ *     a₀ measured        1.200·10⁻¹⁰ m/s²
+ *     c·H₀               6.547·10⁻¹⁰        a₀/cH₀   = 0.1833
+ *     c/t₀               6.884·10⁻¹⁰        a₀/(c/t₀) = 0.1743
+ *     1/2π                                            = 0.1592
+ *
+ * so `a₀ ≈ c/(2π·t₀)` to 10%. EVERYWHERE ELSE THAT IS AN EMBARRASSMENT — why
+ * should a galaxy know the age of the universe? HERE IT IS STRUCTURAL, because
+ * the frontier construction makes `H₀ = 1/t₀` exactly and `t₀` A COUNT OF
+ * TICKS. "An acceleration of order c per age" and "one unit of velocity per
+ * tick, delivered once over the whole run" are then the same sentence, and the
+ * second is the smallest acceleration a discrete lattice can represent at all.
+ *
+ * WHAT WOULD HAVE TO BE SHOWN. `spend` gives `accel = BIAS × (annihilation
+ * rate)` with `BIAS = c/WAYS`. A rate below one meeting per t₀ is not a small
+ * acceleration — it is NO acceleration, because there is no such event. So a
+ * floor is expected near
+ *
+ *     a_min ~ BIAS/t₀ = 2.6·10⁻¹¹ m/s²   against a₀ = 1.2·10⁻¹⁰,  ratio 4.5
+ *
+ * — the right SIZE, with the counting factor unfixed. That is a hint and not a
+ * derivation, and a factor of 4.5 is exactly the sort of thing that gets fitted
+ * rather than counted, so it is filed here as a direction and not a result. But
+ * it is the only place in this model where a galactic number and a cosmological
+ * one are FORCED to be the same number, and it is where to look next.
+ */
+
+/**
+ * AND THE OTHER TRY: A WAKE. If the vacuum pulses, then a star MOVING through
+ * it meets the space ahead of it differently from the space behind, and that
+ * asymmetry should be a force. It is a good instinct — it is exactly the test
+ * that killed Le Sage's gravity — and it fails four separate ways, each of
+ * which is worth having written down because each one is a different lesson.
+ *
+ * FOR UNIFORM MOTION IT IS EXACTLY ZERO, AND IT HAS TO BE. A source moving
+ * steadily through a homogeneous isotropic vacuum carries the BOOSTED STATIC
+ * field — flattened transversely, but still symmetric under reflection through
+ * the source perpendicular to v. Annihilations ahead and behind balance term by
+ * term, so the net force is nought at EVERY order in β, not merely the first.
+ * And if it were not, the model would have an aether: a pulsing vacuum defines
+ * a rest frame, a force depending on motion relative to it is a preferred-frame
+ * effect, and those are bounded at 10⁻¹⁷ and below. It would die on a bench in
+ * a basement long before it got near a galaxy. Which agrees with the frontier
+ * cosmology, whose whole point is that THE BULK VACUUM DOES NOT PULSE.
+ *
+ * GRANT IT ANYWAY — IT POINTS THE WRONG WAY. A force along ±v̂ is TANGENTIAL on
+ * a circular orbit, so it adds nothing centripetal. It spins the star up or
+ * down instead: at a₀ for 10 Gyr, `Δv = 3.8·10⁴ km/s` against an orbital speed
+ * of 220 — a factor of 172. Galaxies would have unwound many times over. A
+ * tangential force at the dark-matter scale is not a halo, it is a demolition.
+ *
+ * AND VELOCITY IS THE WRONG VARIABLE, WHICH IS THE REAL LESSON:
+ *
+ *     system                   v (km/s)    a (m/s²)     a/a₀
+ *     Earth around the Sun     29.8        5.93e−3      4.9e+7
+ *     Sun around the Galaxy    220.0       1.96e−10     1.6
+ *     a star at 30 kpc         200.0       4.32e−11     0.36
+ *
+ * VELOCITY separates the Earth from an outer-galaxy star by 6.7×. ACCELERATION
+ * separates them by 1.4·10⁸. Velocity simply cannot tell a planet from a
+ * galactic outskirt, and that is why every scheme that works is written in
+ * accelerations.
+ *
+ * SO IT IS ALREADY EXCLUDED WHERE WE CAN MEASURE. Tune it to matter at 200 km/s
+ * and read it off at the Earth's 30:
+ *
+ *     scaling   at 200 km/s   at 30 km/s    against a 10⁻¹³ m/s² bound
+ *     ∝ v       1.2e−10       1.8e−11       180×
+ *     ∝ v²      1.2e−10       2.7e−12       27×
+ *     ∝ v³      1.2e−10       4.0e−13       4×
+ *
+ * — planetary ephemerides hold any anomalous along-track acceleration on the
+ * inner planets near 10⁻¹³, and the Pioneer anomaly, which was detectable and
+ * argued over for thirty years, was 8.7·10⁻¹⁰. No exponent switches off fast
+ * enough between 30 and 200 km/s, because there is nothing to switch off on.
+ *
+ * WHAT SURVIVES, AND IT IS NOT NOTHING. The instinct that MOTION THROUGH THE
+ * FIELD MATTERS is right, and the model already says so — `carry` IS that, and
+ * its `1 + 2v²/c²` is the whole difference between one sixth of Mercury's
+ * perihelion advance and six sixths. But it enters at O(v²/c²) and through the
+ * METRIC rather than as a wake, and at 220 km/s `v²/c² = 5.4·10⁻⁷` — nine
+ * orders under what a rotation curve wants. The model has the velocity-
+ * dependent gravity this asks for, it is measured, it is right, and it is far
+ * too small. Which points back at the acceleration floor, which is where the
+ * only native hook already was.
  */
 
 /**
@@ -2120,53 +2713,79 @@ export const REACHES = Math.sqrt(
  *
  *     body           ρ (kg/m³)   R (m)      R/λ        M_eff/M
  *     Earth          5.51e+3     6.37e+6    1.07e−8    1.000000
- *     Sun            1.41e+3     6.96e+8    3.25e−5    0.999992
- *     white dwarf    1.00e+9     7.00e+6    2.33e−3    0.999417
- *     neutron star   5.00e+17    1.20e+4    3.43e+0    0.508504
- *
- * Ordinary matter is transparent. A NEUTRON STAR IS NOT — it shows about half
- * its mass. That is the model's second falsifiable claim and it looks worse
- * for it than the first: pulsar timing measures neutron-star masses directly,
- * and a factor of two in baryon content is far outside any equation of state.
- *
- * AND FOR R ≫ λ IT IS HOLOGRAPHIC. `M_eff/M → 3λ/R`, so `M_eff → 4πR²λρ` — the
- * AREA and not the volume (measured: 0.029406 against 3/x = 0.030000 at
- * x = 100, 0.002994 against 0.003000 at x = 1000). The interior is sealed off
- * not by a horizon but by its own opacity, and what the universe knows about a
- * big clump is a surface.
- *
- * AND AT MAXIMUM DENSITY IT CANNOT BECOME A BLACK HOLE. Once a tick is the
+ *     Sun            1.41e+3     6.96e+8    3.25e−5    0.999996
+ *     white dwarf    1.00e+9     7.00e+6    2.33e−3    0.999680
+ *     neutron star   5.00e+17    1.20e+4    3.43e+0    0.679205
+ *
+ * Ordinary matter is transparent. A NEUTRON STAR IS NOT — it shows about two
+ * thirds of its mass. That is the model's second falsifiable claim and it looks
+ * worse for it than the first: pulsar timing measures neutron-star masses
+ * directly, and a third of the baryon content is far outside any equation of
+ * state. (It was HALF before the geometry of the screening was done properly —
+ * see `shows`. The correction is worth a third of the gap and no more.)
+ *
+ * AND FOR R ≫ λ IT IS HOLOGRAPHIC. `M_eff/M → k·λ/R` with `k = 3/SKIN = 15/√2
+ * = 10.6066` — measured at 10.1401, 10.5508, 10.6059, 10.6066 for x = 10³ to
+ * 10⁸ — so `M_eff ∝ 4πR²λρ`, the AREA and not the volume. The interior is
+ * sealed off not by a horizon but by its own opacity, and what the universe
+ * knows about a big clump is a surface. (`k` was 3 when the fog was counted as
+ * still and even; it is the surface value `SKIN` that decides it, and nothing
+ * about the interior at all — which is itself the area law saying so.)
+ *
+ * AND AT MAXIMUM DENSITY — THIS IS THE PART THAT REVERSED. Once a tick is the
  * ceiling (see `mass` in `physics.ts`) the densest matter is one emitter per
  * cell, ρ = 1. Then `Φ = SHEET·R`, `λ = 1/(BITE·share·SHEET·R)`, and
  *
- *     M_eff = 4πR²λρ = 4πR/(BITE·share·SHEET) = πR
- *
- * — which is Schwarzschild's own M ∝ R. So the ratio is the same at every
- * scale, and it is a pure count:
- *
- *     R/R_s = 1/(2πG) = 2π·WAYS/SHEET² = 2.5525
- *
- * measured at 2.5525 from R = 10¹⁰ to 10⁴⁰ cells. THE DENSEST THING THE LATTICE
- * PERMITS SITS AT TWO AND A HALF OF ITS OWN SCHWARZSCHILD RADII AND CAN NEVER
- * BE INSIDE. So black holes do not fail to form because the metric lacks a
- * horizon — they fail because MATTER RUNS OUT OF ROOM FIRST, and those are two
- * independent facts that happen to agree.
- *
- * AND NO, THE LEAKAGE IS NOT HAWKING RADIATION. At the surface of such an
- * object `u = G·M_eff/R = πG = 0.1959`, which is `1/(2·R/R_s)` as it must be,
- * so light leaves redshifted by `e^−u = 0.822`. An 18% shift, M-INDEPENDENT —
- * the same for a stellar-mass object and a galactic one. Hawking needs
- * `T ∝ 1/M` and a lifetime `∝ M³`; this gives `T ∝ M⁰` and no evaporation at
- * all, because nothing is trapped to begin with. The "arbitrarily slow, never
- * quite vanishing" path is ordinary light climbing out of a shallow well, and
- * it is not even slow.
- *
- * WHICH IS THE REAL PROBLEM HERE, and it is worth stating plainly rather than
- * filing under predictions: THE MODEL HAS NO DARK COMPACT OBJECTS AT ALL. Not
- * merely no horizons — nothing even substantially redshifted, since 18% is what
- * the densest permitted matter manages. Against EHT shadows and merger
- * ringdowns that is a far heavier bill than the missing Hawking radiation, and
- * it is the sharpest thing in this file that observation can settle.
+ *     M_eff = (k/3)·4πR²λρ = πR·k/3 = 11.1078·R
+ *
+ * — Schwarzschild's own M ∝ R either way, so the ratio is the same at every
+ * scale and is a pure count. But the count changed:
+ *
+ *                        as counted      corrected
+ *     M_eff/R            π = 3.1416      11.1078
+ *     u = G·M_eff/R      πG = 0.19588    0.69259
+ *     R/R_s = 1/2u       2.5525          0.72193
+ *     redshift e^−u      0.822           0.500
+ *
+ * measured flat from R = 10⁵ to 10³⁰ cells. THE DENSEST THING THE LATTICE
+ * PERMITS IS NOW INSIDE ITS OWN SCHWARZSCHILD RADIUS, not at two and a half of
+ * them. The old conclusion — "black holes fail to form because matter runs out
+ * of room first" — is simply wrong, and it was wrong by a geometric factor
+ * rather than by anything structural.
+ *
+ * AND IT IS INSIDE ITS OWN PHOTON SPHERE, WHICH IS THE PART THAT MATTERS. The
+ * impact parameter a ray leaves radius r with is `b = r·e^{2u}`, and
+ * `d/dr[r e^{2GM/r}] = e^{2u}(1 − 2u)`, so the photon sphere is at `u = ½` and
+ * `b_c = 2e·GM/c²` — which is `SHADOW`, already in this file. A surface at
+ * `u > ½` sits inside it, casts a shadow of that size, and keeps all but a cone
+ * of its own light:
+ *
+ *     measure              k        u        inside?   cone     escapes  e^−u
+ *     as counted           3.000    0.19588  no        90.0°    50.0%    0.822
+ *     lattice |v̂ − n̂|      10.607   0.69255  YES       70.5°    33.3%    0.500
+ *     Møller (1 − cos θ)   18.000   1.17530  YES       37.5°    10.3%    0.309
+ *
+ * and the threshold is `k = 3/(2πG) = 7.6576`, which BOTH measures clear. So
+ * the choice between them moves how dark the thing is and not whether it is
+ * dark, which is the right way round for a result to depend on a convention.
+ *
+ * WHICH RETIRES THE HEAVIEST BILL IN THIS FILE. It used to say, in bold, that
+ * THE MODEL HAS NO DARK COMPACT OBJECTS AT ALL — nothing even substantially
+ * redshifted — and that this was the sharpest thing observation could settle
+ * against it. That is no longer true: ordinary matter at the ceiling gets to
+ * `u = 0.69`, inside its own photon sphere, showing a `2e·GM/c²` shadow and a
+ * third of its light at half frequency. Against an EHT image that is an object
+ * with a shadow of the right size and a dim surface rather than no object at
+ * all.
+ *
+ * IT IS STILL NOT A HORIZON, and the two things it costs are worth keeping
+ * visible. A tenth to a third of the surface's light does escape, so such a
+ * thing is dark rather than black and something ought to see the difference in
+ * a hot merger remnant. And Hawking is still absent: `u` is M-INDEPENDENT, so
+ * `T ∝ M⁰` and there is no evaporation, where Hawking wants `T ∝ 1/M`. The two
+ * optional routes in `regimes.ts` — `hold` and `boost` — were built to supply
+ * darkness this argument said was missing; they are now a way of going FURTHER
+ * than u = 0.69 rather than the only way of getting anywhere.
  */
 
 /**
@@ -2186,7 +2805,12 @@ export const REACHES = Math.sqrt(
  * problems on it.
  *
  * THE BLOCKER IS THE SELF-SCREENING. With it, a max-density ball shows
- * `M_eff = πR`, so `R/R_s = 2.5525` at every size — a floor. Without it,
+ * `M_eff = 11.11·R`, so `R/R_s = 0.7219` at every size — a floor. (These were
+ * `πR` and 2.5525 before the screening's geometry was corrected; the floor is
+ * now INSIDE the Schwarzschild radius and inside the photon sphere, which is
+ * the reversal recorded above. What follows is the argument for going further
+ * still, and it is unchanged in structure — only its starting point moved.)
+ * Without it,
  * `M = (4/3)πR³` and `R/R_s = 3/(8πGR²)`, which falls as R² and crosses one at
  * R = 1.384 cells:
  *
@@ -2219,13 +2843,15 @@ export const REACHES = Math.sqrt(
  *
  * WHAT IT DOES NOT FIX: ordinary matter is thirty orders the wrong side of that
  * bound. A neutron star's protons are coherent only out to a fermi, so share
- * stays at ½, R/λ = 3.43, and it still shows about half its mass — and any
- * baryonic object caps at u = 0.196 however hard it is squeezed. Dark compact
- * objects are possible in this model, and not out of the matter we know.
- *
- * TWO SEPARATE FAILURES, THEN — one now with a mechanism and one without — and
- * neither of them `carry`. `carry` remains the last borrowed thing and remains
- * a question about the equation of motion, unconnected to any of this.
+ * stays at ½, R/λ = 3.43, and it still shows about two thirds of its mass — and
+ * any baryonic object caps at u = 0.693 however hard it is squeezed. What that
+ * cap is worth has changed, though: 0.693 is past the photon sphere at u = ½,
+ * so ordinary matter at the ceiling now makes something with a shadow. Objects
+ * DARKER than that need the cap lifted; objects dark at all no longer do.
+ *
+ * ONE FAILURE, THEN, RATHER THAN TWO. The neutron star stands, at a third of
+ * its mass rather than a half. The missing dark objects do not: they were an
+ * artefact of counting a comoving fog as a still one.
  */
 
 /**
@@ -2277,16 +2903,127 @@ export const REACHES = Math.sqrt(
  * but in `r²/λ` steps instead of `r`. That is a statement about how fast such
  * an object can RESPOND, not about its mass, and nothing here has worked out
  * what it costs.
+ *
+ * ---------------------------------------------------------------------------
+ * AND THE GEOMETRY OF IT WAS WRONG, WHICH IS WORTH ABOUT A THIRD OF THE ANSWER.
+ *
+ * The integral above puts the opacity at ONE value everywhere and treats what a
+ * charge is annihilated against as a STILL, ISOTROPIC fog. Neither is true, and
+ * both errors go the same way — they over-screen.
+ *
+ * THE FOG THINS TOWARD THE SURFACE, exactly and calculably. A charge at radius
+ * r heading in n̂ was emitted somewhere back along −n̂ INSIDE the body, so its
+ * density per unit solid angle is `ρ·ℓ(r,n̂)/4π` with ℓ the backward chord —
+ * that is not a model, it is what "sources emit at c in straight lines" means.
+ * At the centre ℓ = R in every direction, which is precisely where
+ * `Φ = ρ·SHEET·R` was calibrated (it is `∫₀^R ρ·SHEET/(4πs²)·4πs²ds`). At the
+ * surface half the sky is empty and ⟨ℓ⟩ = R/2.
+ *
+ * AND THE FOG IS NOT STILL. Everything here moves at c, and two things moving
+ * at c in the same direction never meet. Near the surface almost all the flux
+ * is outward, so an escaping charge is nearly COMOVING with what is supposed to
+ * stop it. Two measures of that are defensible and both are carried rather than
+ * the flattering one, each divided by its own isotropic average so an isotropic
+ * fog gives the old λ back and only the SHAPE is new:
+ *
+ *     LATTICE   rate ∝ |v̂ − n̂|        two hops landing on one cell — which is
+ *                                     what `through`'s rule actually says
+ *     MØLLER    rate ∝ (1 − cos θ)    the relativistic flux factor
+ *
+ *     r/R    density   lattice  product    Møller  product   (this used 1)
+ *     0.00   1.00000   1.00000  1.00000   1.00000  1.00000
+ *     0.50   0.91198   0.88753  0.80941   0.81725  0.74531
+ *     0.90   0.65540   0.70877  0.46453   0.54226  0.35540
+ *     1.00   0.50000   0.56569  0.28284   0.33333  0.16667
+ *
+ * — both endpoints exact rather than numerical: ⟨ℓ⟩(R) = R/2 by symmetry, and
+ * the Møller factor is `1 − r/(3⟨ℓ⟩)` because the odd part of the chord
+ * integrates to 2r/3, so it is 1/3 at the surface in one line.
+ *
+ * WHAT IT MOVES:
+ *
+ *     body            R/λ        as counted   lattice    Møller
+ *     Earth           1.07e−8    1.000000     1.000000   1.000000
+ *     Sun             3.25e−5    0.999992     0.999996   0.999996
+ *     white dwarf     2.33e−3    0.999418     0.999680   0.999737
+ *     NEUTRON STAR    3.43e+0    0.508514     0.679205   0.725161
+ *
+ * THE NEUTRON STAR GOES FROM HALF ITS MASS TO ABOUT TWO THIRDS, AND THAT IS
+ * NOT A FIX. It is a third of the way and the remaining third is still far
+ * outside any equation of state. To reach even 90% the body would have to be
+ * 3.5× more transparent than the count gives, and there is no factor of 3.5
+ * lying around. The bill stands; it is smaller and better understood.
+ *
+ * WHAT IT ALSO MOVES, AND THIS IS THE LARGER CONSEQUENCE: the area law. It
+ * survives — `M_eff/M → k/x` still — but with `k = 10.6` rather than 3, since
+ * only the surface layer screens and there `g·C = 0.283`. So the interior is
+ * sealed off by its own opacity as before, and a max-density ball shows 3.5×
+ * the mass it was credited with. See the foot of this file for what that does
+ * to `R/R_s`, which was 2.5525 and is the thing the no-black-holes argument
+ * rested on.
  */
+const CHORD = (s: number) => {                       // mean backward chord, R = 1
+  if (s <= 0) return 1;
+  if (s >= 1) return 0.5;
+  const a2 = 1 - s * s;
+  return 0.5 + a2 / (2 * s) * Math.asinh(s / Math.sqrt(a2));
+};
+
+/** ⟨ℓ·|v̂−n̂|⟩/⟨ℓ⟩, over its own isotropic average — 1 at the centre by design */
+const COMOVE = (s: number) => {
+  const N = 2000;
+  let num = 0, den = 0;
+  for (let i = 0; i < N; i++) {
+    const u = -1 + 2 * (i + 0.5) / N;
+    const l = s * u + Math.sqrt(Math.max(0, 1 - s * s * (1 - u * u)));
+    num += l * Math.sqrt(2 - 2 * u); den += l;
+  }
+  return num / den / (4 / 3);
+};
+
+/**
+ * The screening at the surface itself, which is what the area law is made of:
+ * `CHORD(1)·COMOVE(1) = ½ · (3/(4√2)) = √2/5`, exactly. Everything about a big
+ * body is this number.
+ */
+export const SKIN = Math.SQRT2 / 5;
+
+/**
+ * ∫_{1−w}^{1} (density · comoving) dr, tabulated once — the corrected depth,
+ * written as a function of the DEPTH BELOW THE SURFACE `w = 1 − r/R` rather
+ * than of r/R, because for a big body w is 10⁻²⁴ and `1 − s` would be nothing
+ * but rounding.
+ */
+const DEPTH = (() => {
+  const G = 4000, t = new Float64Array(G + 1);
+  let acc = 0;
+  for (let i = G - 1; i >= 0; i--) { acc += CHORD((i + .5) / G) * COMOVE((i + .5) / G) / G; t[i] = acc; }
+  return (w: number) => {
+    if (w <= 2 / G) return SKIN * Math.max(0, w);               // linear in the skin
+    const f = (1 - w) * G, i = Math.min(G - 1, Math.floor(f));
+    return t[i] + (t[i + 1] - t[i]) * (f - i);
+  };
+})();
+
 export const shows = (
   density: number, R: number, share = 0.5,
 ) => {
   const lam = share > 0 ? 1 / (BITE * share * density * SHEET * R) : Infinity;
   const x = R / lam;
 
-  if (!(x > 1e-3)) return 1 - x / 4 + x * x / 20;    // series; no cancellation
-  // 3∫₀¹ s²e^{−x(1−s)}ds, written without any e^{+x} so it cannot overflow
-  return 3 * (1 / x - 2 / (x * x) + 2 / (x ** 3)) - 6 * Math.exp(-x) / (x ** 3);
+  if (!(x > 1e-9)) return 1 - x * DEPTH(1) * 3 / 4;             // series; no cancellation
+
+  // 3∫₀¹ s²e^{−x·τ(s)}ds. For a big body all of it sits in a skin of thickness
+  // 1/(x·SKIN), which can be 10⁻¹⁰ of the radius — so integrate in `1 − s` on
+  // a log grid, which resolves the skin at any size and costs the same.
+  const N = 6000, LO = Math.max(1e-300, Math.min(1e-12, 1e-2 / (x * SKIN)));
+  let acc = 3 * LO;                                             // the head, where e^−τ ≈ 1
+  const step = Math.log(1 / LO) / N;
+  for (let i = 0; i < N; i++) {
+    const w = LO * Math.exp((i + 0.5) * step);
+    acc += 3 * (1 - 2 * w + w * w) * Math.exp(-x * DEPTH(w)) * w * step;
+  }
+  return acc;
 };
 
 /**
@@ -2393,7 +3130,7 @@ export const sharing = (mass: number, R: number) =>
  *
  * WHICH LEAVES THE BILL SHORTER THAN IT WAS. Dark compact objects form from
  * ordinary collapse. The neutron star keeps its problem — at 1.2·10⁴ m it is
- * twenty orders too big to cohere, so it still shows about half its mass, and
+ * twenty orders too big to cohere, so it still shows two thirds of its mass, and
  * that is still outside any equation of state.
  */
 
@@ -2576,7 +3313,7 @@ export const sharing = (mass: number, R: number) =>
  * advertise horizonlessness as though it did. What remains observable is the
  * shadow, and nothing whatever about the interior.
  *
- * WHAT NEITHER FIXES: the neutron star still shows about half its mass. Route
+ * WHAT NEITHER FIXES: the neutron star still shows two thirds of its mass. Route
  * two makes it marginally worse, since a boost at u ~ 0.2 raises emission and
  * so raises Φ and so screens harder. That bill is outstanding under both.
  *
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
index d9675a2..64a9cc3 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
@@ -1,10 +1,14 @@
 import Post, {
-  Arc, BlueprintIcons16, BlueprintIcons20, JetBrainsMono, PaperProps, Section,
+  Arc, BlueprintIcons16, BlueprintIcons20, BR, JetBrainsMono, PaperProps, Section,
   useCounter,
 } from "../../../lib/post/Post";
 import { RAY_CALCULI_AND_PHYSICS } from "../../references";
+import { bySide, Graph } from "./discrete";
 import { Law } from "./law";
-import { MODELS } from "./models";
+import { lineGroups } from "./lines";
+import { Model } from "./model";
+import { asGroup, MODELS } from "./models";
+import { Polarity } from "./physics";
 import { Models } from "./views";
 
 /**
@@ -39,7 +43,100 @@ const RayCalculiAndPhysics = () => {
     references: referenceCounter,
   };
 
+  // The same strips either way along: `backwards` lays the run out last-state
+  // first, with the arrow AND every charge's heading turned round — which is
+  // how the creation rule is drawn, annihilation being run the other way.
+  const strips = (backwards = false) => lineGroups(2).map((group, i) => asGroup(
+    '',
+    group,
+    { ticks: 1, filmstrip: true, height: 60, density: false, backwards },
+  ));
+
+  const DISCRETE = strips(), BACKWARD = strips(true);
+
   return <Post {...paper}>
+    <Arc head="Introduction">
+      <Section>
+        I should probably preface this by saying that I am not a physicist by training. So my writing will likely not inheret the same culture as you would see in say a typical physics paper. My hope is that these ideas are useful enough to forgive those transgressions.
+        <BR/>
+        So here goes.
+        <BR/>
+        Emergence. That's the topic at play here. The question is: "How do you recover gravity and electromagnetism from local interactions?". I personally wanted a discrete model of physics I could point to which had such properties, and so birthed this idea.
+        <BR/>
+        Specifically, the idea would be the universe's tendency to exhibit XOR behavior on several scales. This is at least how I came to this idea. Two separate examples would be magnetism, and charged matter. In both cases: Opposites attract, Sameness repells. Hence my naming it XOR.
+        <BR/>
+        The model is essentially this idea taken to an extreme. Let me introduce the discrete model first, which (for someone like me) is much easier to understand the *why* of the thing. In order to later introduce the continuous model.
+        <BR/>
+      </Section>
+      <Section head="The Discrete Model">
+        It comes down to three essential rules:
+        <BR/>
+        (1) Annihilation: When two opposite polarities meet, they annihilate, leaving a single neutral spatial point behind. 
+
+        <Models models={[DISCRETE[5]]}/>
+        
+        (2) Repulsion: When two identical polarities meet, they turn around.
+
+        <Models models={[DISCRETE[4]]}/>
+        
+        (3) Creation: A neutral point expands into two points with opposite polarity in all directions. 
+
+        <Models models={[BACKWARD[5]]}/>
+
+        Then the other permutations of the rules are just movement rules (like these two).
+      
+        <Models models={[DISCRETE[1]]}/>
+
+        With this setup, we get aggregate behavior of groups of the same polarities, turning away from each other.
+
+        <Models models={([
+            // [Polarity.Positive, Polarity.Negative],
+            [Polarity.Positive, Polarity.Positive],
+            [Polarity.Negative, Polarity.Negative],
+        ] as [Polarity, Polarity][]).map(([left, right], i): Model => ({
+          name: '',
+          note: '',
+          lattice: {
+            seed: () => Graph.blocks({ charge: bySide(left, right) }),
+            ticks: 15, height: 140, density: false,
+          },
+        }))}/>
+
+        And ones with opposite polarities annihilating each-other.
+
+        <Models models={([
+            [Polarity.Positive, Polarity.Negative],
+            // [Polarity.Positive, Polarity.Positive],
+            // [Polarity.Negative, Polarity.Negative],
+        ] as [Polarity, Polarity][]).map(([left, right], i): Model => ({
+          name: '',
+          note: '',
+          lattice: {
+            seed: () => Graph.blocks({ charge: bySide(left, right) }),
+            ticks: 5, height: 140, density: false,
+          },
+        }))}/>
+
+        Then an interesting thing happens when you alternate polarities (the phase not mattering for this result). You get attraction.
+
+        <Models models={([
+          [Polarity.Positive, Polarity.Negative],
+          [Polarity.Positive, Polarity.Positive],
+        ] as [Polarity, Polarity][]).map(([left, right], i): Model => ({
+          name: '',
+          note: '',
+          lattice: {
+            seed: () => Graph.emitters({ left, right, gap: 20, every: 1, spin: true }),
+            ticks: 22, height: 140,
+          },
+        }))}/>
+
+        In 2D/3D these would of course get a little more complicated, but we can ignore that for now, this is only to form a basis for the idea. Instead: Based on these rules we can start extrapolating, let's continue to the continuous model for that, and afterwards return to the discrete.
+      </Section>
+      <Section head="The Continuous Model">
+
+      </Section>
+    </Arc>
     <Arc head="">
       <Section head="">
         <Law />
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index ee8fdf6..29192a4 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -1658,15 +1658,17 @@ export const Law = () => {
           between <V>e</V><Sup>2<V>u</V></Sup> and (1+<V>u</V>/2)<Sup>4</Sup>,
           and nothing else. Light’s deflection is untouched, since it depends
           on γ alone.</>],
-      [<span style={{ color: BORROWED }}>what is owed instead</span>,
-        <>A different kind of debt, and a smaller one. The checkerboard was
-          measured in <i>flat</i> space, with a reversal amplitude constant
-          everywhere; letting it vary as <V>m e</V><Sup>−<V>u</V><Sub>0</Sub></Sup>{' '}
-          is standard for a slowly varying mass term and{' '}
-          <b style={{ color: INK }}>has not been run</b>. So the chain closes
-          analytically and its last link is unmeasured —{' '}
-          <i>regimes.ts</i> tracks that under <i>untested</i> rather than{' '}
-          <i>borrows</i>.</>],
+      [<span style={{ color: DERIVED }}>the checkerboard in a fold</span>,
+        <>The last link, and it is now measured too. A folded node dilutes{' '}
+          <i>every</i> edge by the same <V>e</V><Sup>−<V>u</V><Sub>0</Sub></Sup>,
+          since it is one count in one denominator — so in cells{' '}
+          <b style={{ color: INK }}>gravity is a position-dependent tick rate
+            and nothing else</b>, <V>H</V> = <V>e</V><Sup>−<V>u</V><Sub>0</Sub></Sup>√(<V>m</V><Sup>2</Sup>+<V>p</V><Sup>2</Sup>),
+          which is <V>A</V> and <V>B</V> both, out of the one number. Run as a
+          lattice walk, a packet through a fold follows the classical path to{' '}
+          <b style={{ color: INK }}>0.3 cells in a 44-cell bend</b>, and the
+          residual halves each time the geometry doubles — the semiclassical
+          1/λ, not a disagreement. <i>untested</i> is now empty as well.</>],
     ]} />
 
     <Head>so is that general relativity</Head>
@@ -1694,8 +1696,9 @@ export const Law = () => {
         <><V>e</V><Sup>−2<V>u</V></Sup> never reaches nought, so{' '}
           <b style={{ color: INK }}>no horizons</b>; the shadow is{' '}
           <b style={{ color: INK }}>4.6% larger</b> at the same mass; and a
-          neutron star shows about half its mass, which is outside any equation
-          of state and is the one place the model is probably just wrong.</>],
+          neutron star shows about two thirds of its mass, which is outside any
+          equation of state and is the one place the model is probably just
+          wrong.</>],
     ]} />
 
     <Note>
@@ -2021,7 +2024,7 @@ export const Law = () => {
       The rules fix one whether or not one was wanted. Matter makes space,
       meetings unmake it, and the net is what escapes — a real expansion, and
       it compounds, so <V>H</V> is constant and the growth exponential. Ask it
-      for the <i>observed</i> <V>H</V> and it fails five separate ways, each
+      for the <i>observed</i> <V>H</V> and it fails seven separate ways, each
       worth recording because each is a fact rather than a failure to try:
     </Note>
 
@@ -2055,13 +2058,43 @@ export const Law = () => {
           clock, and still <V>H</V> = 8·10<Sup>−80</Sup>/s against
           2·10<Sup>−18</Sup>. <b style={{ color: INK }}>Sixty-one orders
             short</b>, wanting 10<Sup>61</Sup> times the matter there is.</>],
+      [<span style={{ color: DERIVED }}>and light cannot tire</span>,
+        <>The escape from needing expansion at all is a photon that loses
+          energy on the way. <i>through</i> gives a charge arriving at an
+          occupied cell exactly two outcomes and no third —{' '}
+          <i>annihilate</i>, or <i>reverse</i> — and both are extinction. A
+          step is one cell and a heading is one of <K>WAYS</K>, so there is no
+          soft forward channel anywhere in the rules:{' '}
+          <b style={{ color: INK }}>the lattice can dim light and cannot redden
+            it</b>. A structural no-go rather than a number coming out
+          wrong.</>],
+      [<span style={{ color: DERIVED }}>and it cannot thermalise</span>,
+        <>The same missing channel, counted a second time. <i>Reversal</i>{' '}
+          redistributes direction, so the model <i>can</i> isotropise; neither
+          outcome moves energy between frequencies, so nothing can make a
+          spectrum. FIRAS has the microwave background as a blackbody to a part
+          in 10<Sup>5</Sup>, and{' '}
+          <b style={{ color: INK }}>this model has no mechanism that would
+            produce one at any temperature</b>. The strongest of the seven,
+          because it is a missing channel rather than a small number.</>],
     ]} />
 
     <Note>
-      <b style={{ color: INK }}>And all five have the same sign</b>, which is
+      And that same fact tightens the first row by thirty orders, because{' '}
+      <V>Φ</V><Sub>0</Sub> sets light’s extinction length too — and we can see
+      quasars. Requiring the sky to be transparent rather than merely requiring
+      gravity to reach 1 AU puts <V>Φ</V><Sub>0</Sub> below
+      1.0·10<Sup>−61</Sup> and <V>H</V> below 3·10<Sup>−80</Sup>/s:{' '}
+      <b style={{ color: INK }}>sixty-two orders</b>, beside the matter route’s
+      sixty-one. The two independent routes now agree on the size of the hole,
+      which they did not before.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And all seven have the same sign</b>, which is
       the thing worth noticing. The usual embarrassment is a vacuum energy
       10<Sup>120</Sup> too <i>large</i>; every mechanism this lattice has runs
-      the other way — 35 orders short on the vacuum route, 61 on the matter
+      the other way — 62 orders short on the vacuum route, 61 on the matter
       route. So the model does not have the cosmological constant problem, it
       has its mirror image, and a model that cannot make the universe expand at
       all is wrong in a way that can be stated and looked for.
@@ -2072,6 +2105,440 @@ export const Law = () => {
       are made in pairs — no matter/antimatter asymmetry either.
     </Note>
 
+    <Note>
+      <b style={{ color: INK }}>How fast, then, and how old?</b> Both routes
+      land together and neither is adjustable: <V>H</V> ~ 10<Sup>−79</Sup>/s,
+      so 1/<V>H</V> = 4·10<Sup>71</Sup> years —{' '}
+      <b style={{ color: INK }}>10<Sup>122</Sup> ticks</b>, which is the
+      cosmological constant problem’s own 10<Sup>120</Sup> arriving from the
+      other side. Whether that is one number twice or two large numbers once,
+      nothing here can tell. And the age is{' '}
+      <b style={{ color: INK }}>eternal</b>, which is derived rather than
+      dodged: the rate is <i>constant</i>, because new points can split too, so
+      the growth is exponential and has no first moment. Over our universe’s
+      13.8 Gyr such a universe grows by one part in 10<Sup>61</Sup>.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And one thing was quietly borrowed</b>, caught
+      while writing that down. <K>REACHES</K> = 0.361 — “gravity reaches a
+      third of the way to the horizon in <i>any</i> universe this model
+      describes” — got the density to cancel by using{' '}
+      <V>ρ</V> = 3<V>H</V><Sup>2</Sup>/8π<V>G</V>. That is <i>Friedmann</i>, and
+      this model has no Friedmann equation. The absolute length survives —{' '}
+      <V>λ</V> = 1.60 Gpc at the observed density — and the universality of the
+      fraction does not. It is a fact about <i>our</i> density, not about any.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>Olbers, with a real sink.</b> A static eternal
+      universe should glow like a stellar surface, and this model is the rare
+      one with an answer: annihilation <i>destroys</i>, and the neutral point it
+      leaves is inert — it has to be, or the universe expands. So nothing
+      re-radiates and the sky saturates at <V>ρ</V><Sub>L</Sub><V>λ</V>/4π
+      rather than at a temperature. Starlight would reach the microwave
+      background’s energy density at <V>λ</V> ≈ 156 Gpc, which is not absurd —
+      and beside the point, because of the seventh closure above.
+    </Note>
+
+    <Head>unless the creation goes somewhere else</Head>
+
+    <Note>
+      Every route above makes space <i>throughout the volume</i>, and every one
+      dies of the same thing — the vacuum that makes the space is the fog that
+      kills the gravity. That is an assumption, and it was never argued for.{' '}
+      <b style={{ color: INK }}>Put the creation only where there is no space
+        yet.</b> A cell on the <i>frontier</i> of the lattice has nothing on one
+      side: a charge emitted outward meets nothing ever, so it never gives its
+      point back and that point is new space. A charge emitted inward meets the
+      bulk and annihilates. The interior makes none at all.
+    </Note>
+
+    <Eq derive={REACH} open={show}
+      note="one emission a cell a tick is the ceiling — so it is also the rate">
+      <Frac over={<>d<V>R</V></>} under={<>d<V>t</V></>} /> = 1
+      <span style={{ padding: '0 0.6em', color: FAINT }}>cell/tick</span> = <V>c</V>
+      <span style={{ padding: '0 1.4em', color: FAINT }}>⇒</span>
+      <V>R</V> = <V>ct</V>
+    </Eq>
+
+    <Note>
+      No density, no <V>Φ</V>, no tuning, nothing fitted — the ceiling{' '}
+      <i>is</i> the rate rather than a bound on it. And the half-way house is
+      worth recording because it is the version that fails: keep creation in the
+      bulk and count the escaping fraction properly and it integrates to a
+      surface, d<V>R</V>/d<V>t</V> = √(<V>C</V>/<V>k</V>), which reaches{' '}
+      <V>c</V> at <V>C</V> = ½ — <i>under</i> the ceiling where the bulk route
+      needed 2. But that same <V>C</V> puts <V>λ</V> at two cells, so gravity
+      dies at two Planck lengths. A bulk vacuum cannot be rescued by counting
+      better. The frontier has to be the only source.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>five of the seven dissolve</span>,
+        <>And for one reason rather than seven, since all five were consequences
+          of making space in the bulk: no bulk vacuum means{' '}
+          <b style={{ color: INK }}>no screening</b>, the attractor’s 3<V>HΦ</V>{' '}
+          term assumed bulk expansion, density no longer sources anything, and
+          one-a-tick <i>is</i> the rate rather than half of what was
+          needed.</>],
+      [<span style={{ color: DERIVED }}>a Hubble law by kinematics</span>,
+        <>Matter that left the origin at <V>t</V> = 0 and free-streams sits at{' '}
+          <V>x</V> = <V>vt</V>, so the relative velocity of two of them is{' '}
+          <V>r</V>/<V>t</V>. Every observer inside sees{' '}
+          <b style={{ color: INK }}><V>v</V> = <V>Hr</V> with <V>H</V> = 1/<V>t</V></b>,
+          linear and isotropic. No metric expansion, no stretched wavelengths,
+          no tired light — the redshift is ordinary Doppler, so the sixth
+          closure stops mattering.</>],
+      [<span style={{ color: DERIVED }}>and the age is forced</span>,
+        <>Not fitted: <V>t</V> = 1/<V>H</V><Sub>0</Sub> exactly. At{' '}
+          <V>H</V><Sub>0</Sub> = 67.4 that is 14.51 Gyr, at 73.0 it is 13.39,
+          and the measured age is{' '}
+          <b style={{ color: INK }}>13.80 ± 0.02 Gyr</b>.{' '}
+          <b style={{ color: INK }}>The Hubble tension brackets it.</b> A model
+          with no freedom to miss does not miss.</>],
+    ]} />
+
+    <Note>
+      In the model’s own units the universe is{' '}
+      <b style={{ color: INK }}>8.49·10<Sup>60</Sup> ticks old and
+        8.49·10<Sup>60</Sup> cells in radius</b> — the same number, which is
+      what <V>R</V> = <V>ct</V> means and is worth seeing written down. That is
+      4.45 Gpc, 2.6·10<Sup>183</Sup> cells, with a frontier
+      9.1·10<Sup>122</Sup> cells across. And a tight consistency check: were
+      that frontier ceiling-density <i>matter</i> rather than fresh neutral
+      space it would weigh 10<Sup>62</Sup> times the universe. It has to make
+      space and not matter — which is what <K>BITE</K> already said.
+    </Note>
+
+    <Head>and where the middle would be</Head>
+
+    <Note>
+      Now that the lattice is finite and growing, the question has an owner.
+      Ask it first the naive way — a <i>static</i> ball of radius <V>R</V>, an
+      observer at <V>d</V> from the middle, and the extinction length{' '}
+      <V>λ</V> — because that version is wrong in an instructive way and the
+      arithmetic is reusable:
+    </Note>
+
+    <Eq derive={REACH} open={show}
+      note="how much universe lies along a given line of sight">
+      <V>B</V>(ψ) = 1 − <V>e</V><Sup>−<V>L</V>(ψ)/<V>λ</V></Sup>
+      <span style={{ padding: '0 1.2em', color: FAINT }}>,</span>
+      <V>L</V>(ψ) = −<V>d</V> cos ψ + √(<V>R</V><Sup>2</Sup> − <V>d</V><Sup>2</Sup> sin<Sup>2</Sup>ψ)
+    </Eq>
+
+    <Note>
+      Brighter looking <i>across</i> the middle, where there is more of it. One
+      function, two parameters — so two measured multipoles fix it and every
+      other one is a prediction. Taking the dipole as entirely positional and
+      the quadrupole as the second constraint gives{' '}
+      <V>R</V>/<V>λ</V> = 2.556 and <V>d</V>/<V>λ</V> = 0.0147, so we would sit{' '}
+      <b style={{ color: INK }}>half a percent of the way out</b>.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>the direction</span>,
+        <>The one thing that is not a floor. Brightness rises where the chord is
+          longest, so the middle lies at the dipole’s <i>hot</i> pole:{' '}
+          <b style={{ color: INK }}>(<V>l</V>, <V>b</V>) = (264.0°, +48.3°)</b>,
+          which is RA 11<Sup>h</Sup>12<Sup>m</Sup>, Dec −7.2° — in Crater.</>],
+      [<span style={{ color: DERIVED }}>the distances</span>,
+        <>Floors, not measurements: <V>λ</V> is bounded below by the sky being
+          clear and not bounded above at all. At <V>λ</V> = 10 Gpc the universe
+          is 25.6 Gpc across and the middle is{' '}
+          <b style={{ color: INK }}>147 Mpc away</b>; at 100 Gpc, ten times
+          each.</>],
+      [<span style={{ color: BORROWED }}>and the octupole kills it</span>,
+        <>One offset fixes every multipole at once — that is the appeal — and
+          fixes them falling as (<V>d</V>/<V>λ</V>)<Sup><V>l</V></Sup>. Fit the
+          dipole and quadrupole and the octupole arrives at{' '}
+          <b style={{ color: INK }}>8.4 nK against an observed 25 µK</b>. Three
+          thousand times too small, with both parameters already spent.</>],
+      [<span style={{ color: BORROWED }}>the dipole is motion anyway</span>,
+        <>A boost aberrates the small-scale pattern and couples neighbouring
+          multipoles; Planck detected exactly that, at a velocity agreeing with
+          the dipole. Standing off-centre aberrates nothing — so the fit above
+          is an upper bound on the offset, not a determination.</>],
+      [<span style={{ color: BORROWED }}>and nothing above <V>l</V> = 3</span>,
+        <>The measured spectrum has acoustic peaks at <V>l</V> ≈ 220, 540, 810
+          at percent precision. No oscillating fluid, no last scattering, no
+          peaks — the seventh closure wearing a different hat.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>But the growing version answers it differently,
+        and better.</b> The dipole cannot measure the offset at all, for a
+      structural reason. An observer at <V>d</V> sees a shell of radius{' '}
+      <V>D</V> around <i>themselves</i>; a point on it sits at{' '}
+      <V>d</V>n̂<Sub>d</Sub> + <V>D</V>n̂ and moves at that over <V>t</V>, and
+      averaging over the shell the <V>D</V>n̂ part vanishes by symmetry —{' '}
+      ⟨<V>v</V>⟩ = <V>d</V>/<V>t</V>, our own velocity.{' '}
+      <b style={{ color: INK }}>We are at rest in its frame.</b> The positional
+      dipole cancels exactly to first order, which is the same cancellation that
+      makes a freely expanding universe look isotropic to everybody in it — and
+      it agrees, from the opposite direction, with Planck’s aberration
+      measurement that the dipole is our own motion.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>The origin is an ordinary place, though.</b>{' '}
+      Our past light cone reaches <V>t</V> = 0 on a sphere of radius{' '}
+      <V>ct</V><Sub>0</Sub> around <i>us</i>, and the origin is a single point
+      at <V>d</V> ≪ <V>ct</V><Sub>0</Sub>, well inside it. The frontier at{' '}
+      <V>t</V>′ sits at <V>ct</V>′ from the origin and our backward cone at{' '}
+      <V>t</V>′ is at <V>c</V>(<V>t</V><Sub>0</Sub>−<V>t</V>′) from us, and both
+      at once give{' '}
+      <V>s</V>(ψ) ≈ <V>ct</V><Sub>0</Sub>/2 − (<V>d</V>/2)cos ψ:{' '}
+      <b style={{ color: INK }}>the frontier appears at half the horizon
+        distance, 6.9 Gly, with its distance dipolar at amplitude{' '}
+        <V>d</V>/<V>R</V></b>. There is a preferred direction.
+    </Note>
+
+    <Note>
+      It is invisible all the same, for a better reason than geometry: the
+      frontier recedes at exactly <V>c</V>, so <V>γ</V> = ∞ and it is
+      infinitely redshifted. Just inside, the redshift is large but finite — so
+      the model <i>does</i> have a surface of last visibility at{' '}
+      <V>z</V> → ∞ whose distance carries a dipole of size <V>d</V>/<V>R</V>.
+      Which is exactly the structure a microwave background would test, if the
+      model could make one.
+    </Note>
+
+    <Note>
+      For the record, the sky <i>does</i> say the soup differs by direction, and
+      it is not the temperature dipole: a{' '}
+      <b style={{ color: INK }}>7% hemispherical power asymmetry</b> below{' '}
+      <V>l</V> = 64, toward (<V>l</V>, <V>b</V>) ≈ (220°, −20°) — the{' '}
+      <i>amplitude</i> of the fluctuations differing by hemisphere, which is the
+      primordial conditions themselves differing. Read as an offset it gives{' '}
+      <V>d</V> ≈ 310 Mpc. Read off the temperature dipole instead it gives 5.5
+      Mpc, a factor of 57 apart, in directions 70° from each other.{' '}
+      <b style={{ color: INK }}>No single geometry does both</b> — which is what
+      the cancellation above already predicted.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>Does gravity decelerate it?</b> Mostly not, and
+      the reason is countable. “It cannot reach because it is moving away” is
+      false as stated — the interior recedes at <V>β</V> &lt; 1 while gravity
+      travels at 1, so it does arrive. But gravity here is a <i>meeting rate of
+        two fluxes</i>, and a receding source is thinned by{' '}
+      <V>D</V> = √((1−<V>β</V>)/(1+<V>β</V>)), which is{' '}
+      <b style={{ color: INK }}>exactly nought beyond <V>ct</V></b>: that mass
+      recedes at or above <V>c</V> and its pull never arrives at all.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>a third of the pull survives</span>,
+        <>The pull is ∫dΩ cos ψ ∫<Sub>0</Sub><Sup>chord</Sup> <V>D</V> d<V>s</V>{' '}
+          — the inverse square’s <V>s</V><Sup>2</Sup> cancels the volume
+          element’s, and at <V>D</V> = 1 it returns −(4/3)π<V>Gρr</V> exactly.
+          With <V>D</V> the ratio runs 0.068 at the centre to 0.399 at the edge,{' '}
+          <b style={{ color: INK }}>0.309 mass-weighted</b>. Strongest in the
+          middle, which is right: there the pull is a small residual of a nearly
+          cancelling sphere, and killing the far side kills the residual.</>],
+      [<span style={{ color: DERIVED }}>so the age survives too</span>,
+        <>Ω is not a choice, and this model has no dark matter particle.
+          Pure free-streaming gives 14.51 Gyr; baryons thinned by recession give{' '}
+          <b style={{ color: INK }}>14.10</b>; baryons unthinned 13.58; ΛCDM’s
+          dark matter 11.66 — <i>younger than the globular clusters</i>, which
+          is the age crisis Λ was invented to fix. The thinned case is exactly
+          13.80 Gyr at <V>H</V><Sub>0</Sub> = 68.9, inside the disputed range.{' '}
+          <b style={{ color: INK }}>Free-streaming is recovered to three
+            percent.</b></>],
+      [<span style={{ color: BORROWED }}>nucleosynthesis, by 5·10<Sup>7</Sup></span>,
+        <>Radiation-dominated BBN has <V>H</V> ∝ <V>T</V><Sup>2</Sup>; coasting
+          has <V>H</V> ∝ <V>T</V> — a different <i>power</i>. 1 MeV arrives at
+          10<Sup>8</Sup> s rather than 1 s, freeze-out drops 85× to 9.5 keV, and{' '}
+          <V>n</V>/<V>p</V> = <V>e</V><Sup>−137</Sup>.{' '}
+          <b style={{ color: INK }}>Zero helium</b> against a measured{' '}
+          <V>Y</V><Sub>p</Sub> = 0.245. Not a tension, an absence.</>],
+      [<span style={{ color: BORROWED }}>and that is the lesser problem</span>,
+        <>It is moot, which is worse: with no hot phase at all the model never
+          gets as far as running BBN badly. The sharpest bill is{' '}
+          <b style={{ color: INK }}>deuterium</b> — stars destroy it, nothing
+          much makes it, and pristine clouds show <V>D</V>/<V>H</V> =
+          2.5·10<Sup>−5</Sup>. One number, and the cleanest evidence there is
+          for an early hot dense phase.</>],
+    ]} />
+
+    <Head>and whether any of that is dark matter</Head>
+
+    <Note>
+      The missing dark matter is what saved the age, so it is worth asking
+      whether the same construction can pay it back. State the target so it can
+      be failed: flat rotation curves want <V>v</V><Sup>2</Sup> = <V>GM</V>(<V>r</V>)/<V>r</V>{' '}
+      constant, so <V>M</V> ∝ <V>r</V>, so{' '}
+      <b style={{ color: INK }}><V>ρ</V> ∝ 1/<V>r</V><Sup>2</Sup>, and the extra
+        pull is <i>inward</i></b>. Both halves matter.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>the shell theorem</span>,
+        <>Space made in a shell <i>outside</i> an orbit has no inside — a
+          uniform shell has no preferred direction within it, so it moves
+          nothing there. Only space made <i>inside</i> the orbit acts, and it
+          pushes <b style={{ color: INK }}>outward</b>. For a circular orbit{' '}
+          <V>v</V><Sup>2</Sup>/<V>r</V> = <V>g</V> − <V>g</V><Sub>push</Sub>, so
+          an outward push <i>lowers</i> the speed a star can hold. Dark matter
+          is missing centripetal force; this supplies the opposite.</>],
+      [<span style={{ color: BORROWED }}>and it undoes the cosmology</span>,
+        <>The whole virtue of the frontier was that{' '}
+          <i>the bulk makes no space</i> — which is what dissolved four
+          closures. Wanting voids to create locally puts it back in the bulk and
+          brings all four failures with it. The two ideas cannot both hold.</>],
+      [<span style={{ color: DERIVED }}>but the screening objection was never about this</span>,
+        <>A bulk vacuum was fatal because one <V>Φ</V> both makes space and
+          stops gravity — priced at the density <i>expansion</i> needs. Dark
+          matter needs <V>Φ</V> = 1.4·10<Sup>−118</Sup> per cell, whose
+          screening length is 10<Sup>57</Sup> Hubble radii.{' '}
+          <b style={{ color: INK }}>Eighty-eight orders below</b> what killed
+          it. A gravitating vacuum at this density is perfectly fine — the whole
+          question is the <i>profile</i>.</>],
+    ]} />
+
+    <Note>
+      And three profiles are available. A <i>uniform</i> vacuum gives{' '}
+      <V>ρ</V> = const, <V>v</V> ∝ <V>r</V>. A vacuum <i>depleted</i> by the
+      galaxy’s own field — screening, <V>Φ</V> ≈ <V>C</V>/<V>kΦ</V><Sub>gal</Sub>{' '}
+      — gives <V>ρ</V> ∝ <V>r</V><Sup>2</Sup>, worse. But a vacuum{' '}
+      <i>stimulated</i> by it — a neutral point splitting when a charge{' '}
+      <i>arrives</i>, which is rule 3 made stimulated rather than spontaneous —
+      gives <V>Φ</V> ∝ <V>Φ</V><Sub>gal</Sub> ∝ <V>M</V>/<V>r</V><Sup>2</Sup>:{' '}
+      <b style={{ color: INK }}>an isothermal halo, exactly, with no new
+        constant</b>.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And that dies on Tully–Fisher.</b> With{' '}
+      <V>ρ</V> = <V>κM</V>/4π<V>r</V><Sup>2</Sup> the enclosed halo is{' '}
+      <V>κMr</V>, so <V>v</V><Sup>2</Sup> = <V>GκM</V> and{' '}
+      <V>v</V><Sup>4</Sup> ∝ <V>M</V><Sup>2</Sup>. The baryonic Tully–Fisher
+      relation is <V>v</V><Sup>4</Sup> = <V>GMa</V><Sub>0</Sub> — that is{' '}
+      <V>v</V><Sup>4</Sup> ∝ <V>M</V>, under 0.1 dex of scatter across five
+      decades. Anchored at 10<Sup>10</Sup> M☉ the two run apart by a factor of
+      ten at each end. Not a tension, a different law. The model can make flat
+      rotation curves and cannot make them scale.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>The one hook that is native is an
+        acceleration.</b> <V>a</V><Sub>0</Sub> = 1.20·10<Sup>−10</Sup> m/s²,{' '}
+      <V>c</V>/<V>t</V><Sub>0</Sub> = 6.88·10<Sup>−10</Sup>, and their ratio is
+      0.174 against 1/2π = 0.159 — so{' '}
+      <V>a</V><Sub>0</Sub> ≈ <V>c</V>/(2π<V>t</V><Sub>0</Sub>) to ten percent.
+      Everywhere else that is an embarrassment: why should a galaxy know the age
+      of the universe?{' '}
+      <b style={{ color: INK }}>Here it is structural</b>, because the frontier
+      makes <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> exactly and{' '}
+      <V>t</V><Sub>0</Sub> a <i>count of ticks</i>. “An acceleration of order{' '}
+      <V>c</V> per age” and “one unit of velocity per tick, delivered once over
+      the whole run” become the same sentence — and the second is the smallest
+      acceleration a discrete lattice can represent at all.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the other try: a wake.</b> If the vacuum
+      pulses, a star <i>moving</i> through it meets the space ahead differently
+      from the space behind, and that asymmetry should be a force. Good
+      instinct — it is the test that killed Le Sage’s gravity — and it fails
+      four ways, each a different lesson.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>zero for uniform motion, and it must be</span>,
+        <>A source moving steadily through a homogeneous isotropic vacuum
+          carries the <i>boosted static</i> field — flattened transversely, but
+          still symmetric under reflection through the source perpendicular to{' '}
+          <V>v</V>. Fore and aft balance term by term, at{' '}
+          <i>every</i> order in <V>β</V>. And if they did not, the model would
+          have an <b style={{ color: INK }}>aether</b>: a pulsing vacuum defines
+          a rest frame, and preferred-frame effects are bounded at
+          10<Sup>−17</Sup>. It would die on a bench in a basement long before it
+          got near a galaxy.</>],
+      [<span style={{ color: BORROWED }}>and it points the wrong way</span>,
+        <>A force along ±<V>v̂</V> is <i>tangential</i> on a circular orbit, so
+          it adds nothing centripetal — it spins the star up or down. At{' '}
+          <V>a</V><Sub>0</Sub> for 10 Gyr that is{' '}
+          <b style={{ color: INK }}>Δ<V>v</V> = 3.8·10<Sup>4</Sup> km/s</b>{' '}
+          against an orbital 220. Not a halo, a demolition.</>],
+      [<span style={{ color: BORROWED }}>velocity is the wrong variable</span>,
+        <>The Earth and a star at 30 kpc differ by{' '}
+          <b style={{ color: INK }}>6.7× in velocity and 1.4·10<Sup>8</Sup> in
+            acceleration</b>. Velocity cannot tell a planet from a galactic
+          outskirt, which is why every scheme that works is written in
+          accelerations.</>],
+      [<span style={{ color: BORROWED }}>so it is already excluded</span>,
+        <>Tuned to matter at 200 km/s it gives 1.8·10<Sup>−11</Sup> m/s² at the
+          Earth’s 30 if it scales as <V>v</V>, 2.7·10<Sup>−12</Sup> as{' '}
+          <V>v</V><Sup>2</Sup>, 4·10<Sup>−13</Sup> as <V>v</V><Sup>3</Sup> —
+          against an ephemeris bound near 10<Sup>−13</Sup>. No exponent switches
+          off fast enough between 30 and 200 km/s, because there is nothing to
+          switch off on.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>What survives, and it is not nothing.</b> The
+      instinct that <i>motion through the field matters</i> is right, and the
+      model already says so — <i>carry</i> <b style={{ color: INK }}>is</b>{' '}
+      that, and its 1 + 2<V>v</V><Sup>2</Sup>/<V>c</V><Sup>2</Sup> is the whole
+      difference between one sixth of Mercury’s perihelion advance and six
+      sixths. But it enters at <V>O</V>(<V>v</V><Sup>2</Sup>/<V>c</V><Sup>2</Sup>)
+      and through the <i>metric</i> rather than as a wake, and at 220 km/s that
+      is 5.4·10<Sup>−7</Sup> — nine orders under what a rotation curve wants.
+      The model has the velocity-dependent gravity this asks for; it is
+      measured, it is right, and it is far too small.
+    </Note>
+
+    <Note>
+      What would have to be shown: <i>spend</i> gives accel = <K>BIAS</K> ×
+      (annihilation rate), and a rate below one meeting per{' '}
+      <V>t</V><Sub>0</Sub> is not a small acceleration but <i>no</i>{' '}
+      acceleration, since there is no such event. So a floor is expected near{' '}
+      <K>BIAS</K>/<V>t</V><Sub>0</Sub> = 2.6·10<Sup>−11</Sup> m/s² against{' '}
+      <V>a</V><Sub>0</Sub> = 1.2·10<Sup>−10</Sup> — the right{' '}
+      <i>size</i>, with the counting factor unfixed at 4.5.{' '}
+      <b style={{ color: INK }}>A hint and not a derivation</b>, and a factor of
+      4.5 is exactly what gets fitted rather than counted. But it is the only
+      place in the model where a galactic number and a cosmological one are
+      forced to be the same number.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So what is left owed</b>, ranked: the light
+      elements, with no mechanism and no room for one; the microwave background,
+      untouched by any of this; the rotation curves, which the missing dark
+      matter costs; and the initial condition, since{' '}
+      <V>v</V> = <V>x</V>/<V>t</V> still needs everything to have left the
+      origin at once with a spread of velocities. What is{' '}
+      <i>not</i> owed any more is the deceleration — the reason to doubt the
+      free-streaming, and a third of an already small number.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>What is worth keeping out of it.</b> The{' '}
+      <i>shape</i> this predicts is a dipole, quadrupole and octupole all
+      aligned on one axis with amplitudes falling geometrically — and that is
+      the shape of the known anomaly, the “axis of evil”: the quadrupole and
+      octupole aligned with each other and roughly with the dipole, both
+      anomalously low, unexplained in ΛCDM. The model gets the shape and misses
+      the size by three orders. Which is a more interesting kind of wrong than
+      usual, and the only place in the whole cosmology where it says something
+      specific about a measurement nobody can currently account for.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>Which is a claim and not a silence.</b> A static
+      universe predicts surface brightness ∝ (1+<V>z</V>)<Sup>0</Sup> against
+      the observed (1+<V>z</V>)<Sup>−4</Sup>, no microwave background at all,
+      and — sharpest of the three — supernova light curves the{' '}
+      <i>same width</i> at every redshift, where the measurement finds them
+      stretched by (1+<V>z</V>). At <V>z</V> = 1 that is a factor of two, not a
+      percent. It is the one place in this model that is not merely short but{' '}
+      <b style={{ color: INK }}>contradicted</b>.
+    </Note>
+
     <Head>what you can switch off</Head>
 
     <Note>
@@ -2122,16 +2589,17 @@ export const Law = () => {
 
     <Rows of={[
       [<span style={{ color: BORROWED }}>argued, not measured</span>,
-        <><i>carry</i> matches stationary phase to 10<Sup>−7</Sup>, but the
-          checkerboard behind it was run in <i>flat</i> space. A
-          position-dependent reversal amplitude has not been tried. Likewise{' '}
-          <i>hold</i> rests on one emitter per edge, and <i>boost</i> on a
-          threshold nothing fixes. <i>regimes.ts</i> lists these under{' '}
-          <i>untested</i>.</>],
+        <>Only the two optional routes to a dark object now: <i>hold</i> rests
+          on one emitter per edge, and <i>boost</i> on a threshold nothing
+          fixes. <i>carry</i> has left this list — the position-dependent
+          checkerboard was run and the packet follows the classical path.{' '}
+          <i>regimes.ts</i> lists what remains under <i>untested</i>, and for
+          the model’s own setting that is nothing.</>],
       [<span style={{ color: BORROWED }}>probably just wrong</span>,
-        <>A neutron star shows about half its mass — outside any equation of
-          state, and pulsar timing measures those directly. And cosmology comes
-          out empty five separate ways, every one of them short rather than
+        <>A neutron star shows about two thirds of its mass — outside any
+          equation of state, and pulsar timing measures those directly. And
+          cosmology comes
+          out empty seven separate ways, every one of them short rather than
           long.</>],
       [<span style={{ color: DERIVED }}>and one thing to shoot at</span>,
         <>The shadow, 4.6% larger than general relativity’s at the same mass.
@@ -2308,55 +2776,71 @@ export const Law = () => {
           to six figures. Nothing changes anywhere the model was tested.</>],
       [<span style={{ color: BORROWED }}>a neutron star is not</span>,
         <><V>R</V>/<V>λ</V> = 3.4, so it shows{' '}
-          <b style={{ color: INK }}>about half its mass</b>. Pulsar timing
-          measures those masses directly and a factor of two in baryon content
-          is outside any equation of state. The second falsifiable claim, and
-          it looks worse for the model than the first.</>],
+          <b style={{ color: INK }}>about two thirds of its mass</b> — it was a
+          half until the screening’s geometry was done properly, and that
+          correction is worth a third of the gap and no more. Pulsar timing
+          measures those masses directly and a third of the baryon content is
+          outside any equation of state. The second falsifiable claim, and it
+          looks worse for the model than the first.</>],
       [<span style={{ color: DERIVED }}>and it is holographic</span>,
         <>For <V>R</V> ≫ <V>λ</V>, <V>M</V><Sub>eff</Sub> → 4π<V>R</V><Sup>2</Sup><V>λρ</V>{' '}
-          — the <i>area</i>, not the volume (0.029406 against 3<V>λ</V>/<V>R</V>{' '}
-          = 0.030000). The interior is sealed off by its own opacity rather
+          — the <i>area</i>, not the volume (10.6066 against{' '}
+          <V>k</V> = 3/<K>SKIN</K> = 15/√2). The interior is sealed off by its
+          own opacity rather
           than by a horizon, and what the universe knows about a big clump is a
           surface.</>],
     ]} />
 
     <Eq derive={REACH} open={show}
       note="the densest thing the lattice permits, and where it sits">
-      <V>M</V><Sub>eff</Sub> = <V>πR</V>
+      <V>M</V><Sub>eff</Sub> = <Frac over={<V>k</V>} under={<>3</>} /><V>πR</V>
       <span style={{ padding: '0 1.4em', color: FAINT }}>⇒</span>
       <Frac over={<V>R</V>} under={<><V>R</V><Sub>s</Sub></>} /> =
-      <Frac over={<>1</>} under={<>2π<V>G</V></>} /> =
-      <Frac over={<>2π<K>WAYS</K></>} under={<><K>SHEET</K><Sup>2</Sup></>} /> = 2.5525
+      <Frac over={<>3</>} under={<>2π<V>Gk</V></>} /> = 0.7219
     </Eq>
 
     <Note>
       Once a tick is the ceiling, so the densest matter is one emitter a cell.
       Then <V>M</V><Sub>eff</Sub> ∝ <V>R</V> — Schwarzschild’s own scaling — so
-      the ratio is the same at every size, measured at 2.5525 from{' '}
-      10<Sup>10</Sup> to 10<Sup>40</Sup> cells, and it is a pure count.{' '}
-      <b style={{ color: INK }}>The densest thing the lattice permits sits at
-        two and a half of its own Schwarzschild radii and can never be
-        inside.</b> So black holes do not fail to form because the metric lacks
-      a horizon — they fail because matter runs out of room first, and those are
-      two independent facts that happen to agree.
+      the ratio is the same at every size, measured flat from 10<Sup>5</Sup> to
+      10<Sup>30</Sup> cells, and it is a pure count.{' '}
+      <b style={{ color: INK }}>The densest thing the lattice permits sits
+        inside its own Schwarzschild radius.</b>{' '}
+      Which is a reversal: with the fog counted as still and even, the same
+      arithmetic gave <V>M</V><Sub>eff</Sub> = π<V>R</V> and 2.5525, and this
+      page used to say in bold that matter ran out of room before a black hole
+      could form. It does not.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And it is inside its own photon sphere, which
+        is the part that matters.</b> A ray leaves radius <V>r</V> with impact
+      parameter <V>r·e</V><Sup>2<V>u</V></Sup>, whose extremum is at{' '}
+      <V>u</V> = ½ and whose value there is 2<V>e·GM</V>/<V>c</V><Sup>2</Sup>{' '}
+      — the shadow this page already had. The surface sits at{' '}
+      <V>u</V> = 0.693, past it, so the object{' '}
+      <b style={{ color: INK }}>casts a shadow of the full size</b> and keeps
+      all but a 70° cone of its own light: a third gets out, at half frequency.
+      Under the other defensible measure of what “meeting” means it is{' '}
+      <V>u</V> = 1.18, a 37° cone and a tenth of the light. The threshold is{' '}
+      <V>k</V> = 3/(2π<V>G</V>) = 7.66 and both clear it, so the convention
+      moves how dark it is and not whether.
     </Note>
 
     <Note>
-      <b style={{ color: INK }}>And the leakage is not Hawking radiation.</b> At
-      the surface <V>u</V> = <V>πG</V> = 0.1959, so light leaves redshifted by
-      0.822 — an 18% shift, and <i>M-independent</i>, the same for a
-      stellar-mass object and a galactic one. Hawking needs <V>T</V> ∝ 1/<V>M</V>{' '}
-      and a lifetime ∝ <V>M</V><Sup>3</Sup>; this gives <V>T</V> ∝ <V>M</V><Sup>0</Sup>{' '}
-      and no evaporation at all, because nothing is trapped to begin with. The
-      “never quite vanishing” path is ordinary light out of a shallow well, and
-      it is not even slow.
+      <b style={{ color: INK }}>Still not Hawking radiation, though.</b>{' '}
+      <V>u</V> is <i>M-independent</i> — the same for a stellar-mass object and
+      a galactic one — so <V>T</V> ∝ <V>M</V><Sup>0</Sup> where Hawking needs{' '}
+      <V>T</V> ∝ 1/<V>M</V> and a lifetime ∝ <V>M</V><Sup>3</Sup>. No
+      evaporation, because nothing is trapped to begin with. And dark is not
+      black: a tenth to a third of the surface’s light does escape, which
+      something ought to see in a hot merger remnant.
     </Note>
 
     <Note>
-      Which reads as a bill until you ask what is actually blocking it — and it
-      is not the metric.{' '}
+      What would take it further is not the metric.{' '}
       <b style={{ color: INK }}>It is the self-screening.</b> With it,{' '}
-      <V>R</V>/<V>R</V><Sub>s</Sub> = 2.55 at every size, a floor. Without it,{' '}
+      <V>R</V>/<V>R</V><Sub>s</Sub> = 0.72 at every size, a floor. Without it,{' '}
       <V>M</V> = (4/3)π<V>R</V><Sup>3</Sup> and the ratio falls as{' '}
       <V>R</V><Sup>2</Sup>, crossing one at 1.384 cells — after which{' '}
       <V>u</V> grows without bound and <V>e</V><Sup>−<V>u</V></Sup> does the
@@ -2398,8 +2882,8 @@ export const Law = () => {
           thousandth of a fermi. No exotic matter needed.</>],
       [<span style={{ color: BORROWED }}>what it does not fix</span>,
         <>A neutron star is twenty orders too big to cohere, so it still shows
-          about half its mass, and that is still outside any equation of
-          state.</>],
+          about two thirds of its mass, and that is still outside any equation
+          of state.</>],
     ]} />
 
     <Note>
@@ -2417,7 +2901,7 @@ export const Law = () => {
       <b style={{ color: INK }}>And the collapse has nothing to stop it.</b> In
       general relativity a star reaches its horizon and is done; here no radius
       is marked, so it continues. On the way it passes through the screened
-      regime as a compact object with <V>u</V> pinned at 0.196 — which is{' '}
+      regime as a compact object with <V>u</V> pinned at 0.693 — which is{' '}
       <i>not</i> a support, since screening attenuates only what <i>leaves</i>{' '}
       while the field between neighbours is short-range and unscreened. So it
       runs to the lattice ceiling, and a solar mass ends as a ball
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
index 428cf49..3e62865 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
@@ -135,6 +135,23 @@ export type Lattice = {
    */
   filmstrip?: boolean;
 
+  /**
+   * And which way along the strip time runs.
+   *
+   * The seed is normally leftmost and the arrows point right. Set this and the
+   * strip is laid out the other way round — last state first, arrows pointing
+   * back — which is what a sentence wants when it is naming the OUTCOME before
+   * the arrangement that produced it, as the annihilation rule does.
+   *
+   * The arrow is flipped with the order, and so is every charge's HEADING —
+   * reversing the order alone is not enough, because a charge drawn mid-run is
+   * still drawn going the way it was going, and a run played backwards would
+   * show two charges converging on a neutral point rather than leaving one.
+   * Reversing time reverses velocities, and only both together read as the
+   * rule run the other way.
+   */
+  backwards?: boolean;
+
   /**
    * How many times to run it. The dynamics are stochastic, and where the
    * arrangement itself is a draw rather than a case — every point charged on
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
index 09e3ed7..34b0781 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -815,14 +815,14 @@ const blocks: Model[] = [
       + 'between them, the second in bursts rather than steadily.',
     lattice: {
       seed: () => Graph.emitters({ left, right, gap: 20, every: 1, spin: true }),
-      ticks: 22, height: 140,
+      ticks: 22, height: 160,
     },
   })),
 ];
 
 // A group of lines drawn in one block: the experiment on matter, and the same
 // experiment on antimatter, one under the other.
-const asGroup = (
+export const asGroup = (
   name: string, group: Parameters<typeof Graph.line>[0][], lattice: Model['lattice'],
 ): Model => {
   const of = (line: Parameters<typeof Graph.line>[0]): Model => ({
@@ -837,6 +837,32 @@ const asGroup = (
   };
 };
 
+/**
+ * The same group, drawn the other way up.
+ *
+ * `asGroup` puts the first line of a group in the model itself and the rest in
+ * `alongside`, and `views.tsx` draws them in that order — so a line and its
+ * anti-line come out matter-on-top. Which of the two reads better depends on
+ * what the surrounding sentence is pointing at, and that is a decision about
+ * the prose rather than about the arrangement.
+ *
+ * The group's LABEL stays at the top where it belongs, rather than travelling
+ * with the line it happened to be attached to: the name and note move to
+ * whichever model is now first, and the one that used to be first gives its
+ * name up. Otherwise reversing a group silently moves its heading into the
+ * middle of it.
+ */
+export const reversed = (model: Model): Model => {
+  const all: Model[] = [{ ...model, name: '', note: undefined },
+    ...(model.alongside ?? [])];
+
+  if (all.length < 2) return model;
+
+  const [head, ...rest] = all.reverse();
+
+  return { ...head, name: model.name, note: model.note, alongside: rest };
+};
+
 const lines: Model[] = [
   // Every arrangement of two, three and four charges in a row. Each runs for
   // as many steps as there are charges, since that is roughly how long it
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
index 156582a..5296a74 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
@@ -113,9 +113,20 @@ export type Regime = {
    * it begins above u², at a depth nothing has yet fixed. Route one costs
    * nothing and follows from rules already here.
    *
-   * BOTH ARE KEPT because they differ observationally: route one leaves a
-   * SURFACE (ringdown echoes, no information loss), route two does not. Neither
-   * fixes the neutron star. See the foot of `gravity.ts`.
+   * BOTH ARE KEPT, but NOT because they differ observationally — they do not.
+   * Route one leaves a surface and route two a horizon, and the surface is so
+   * deep that the echo delay carries e^(9·10³⁷), so nothing ever comes back
+   * from either (see `echoes.tsx`). The image is the same too, since they share
+   * the exterior down to the photon sphere. The only candidate discriminator is
+   * Hawking radiation, and it rests on an unsettled question. Neither fixes the
+   * neutron star. See the foot of `gravity.ts`.
+   *
+   * AND BOTH ARE NOW OPTIONAL IN A SECOND SENSE. They were built because the
+   * model appeared to have no dark objects at all — the densest ordinary matter
+   * capping at u = 0.196. With the screening's geometry corrected that cap is
+   * u = 0.693, past the photon sphere at u = ½, so ordinary matter at the
+   * ceiling already casts a full-size shadow. These two are now ways of going
+   * FURTHER than that rather than the only way of getting anywhere.
    */
   boost: number;
 
@@ -263,10 +274,12 @@ export const borrows = (r: Regime): string[] => {
 export const untested = (r: Regime): string[] => {
   const owed: string[] = [];
 
-  if (r.fold > 0 && r.compose > 0) owed.push(
-    '`carry` is the stationary-phase limit of the path sum — shown to match to '
-    + '1e-7 — but the checkerboard behind it was measured in FLAT space. A '
-    + 'position-dependent reversal amplitude has not been run.');
+  // `carry` used to sit here: the stationary-phase limit of a path sum that
+  // had only ever been run in FLAT space. The position-dependent checkerboard
+  // has now been built and run (see `gravity.ts`) — the packet follows the
+  // classical path, and the residual halves each time the geometry doubles,
+  // which is the semiclassical 1/λ and not a disagreement. So it is off this
+  // list, and this list is EMPTY for the model's own setting.
 
   if (r.hold > 0) owed.push(
     '`hold` rests on one emitter per edge, which is a reading of what a cell '
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
index 3a86b22..4b4acab 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
@@ -156,12 +156,39 @@ const LatticePlayer = ({
  * is stepped through, and each state along the way is cloned out of it, so
  * the strip really is consecutive states of a single universe.
  */
+/**
+ * Every ray in a state turned round, for drawing a run the other way along.
+ *
+ * A ray's heading is which of its two boundaries is the `moving` one, so
+ * turning it is picking the other. Safe to do in place: these are clones kept
+ * only to be drawn, never ticked again.
+ *
+ * It is NOT a claim that the dynamics are reversible. Annihilation loses which
+ * side carried which polarity, so the run backwards is one of the states that
+ * COULD have led here rather than the one that did — which is exactly what the
+ * creation rule is, since nothing says which way round a new pair comes out.
+ */
+const turned = (graph: Graph) => {
+  for (const nd of graph.nodes)
+    for (const ray of nd) {
+      if (!ray.moving) continue;
+
+      const other = ray.boundaries.find(b => b !== ray.moving);
+      if (other) ray.moving = other;
+
+      if (ray.heading) ray.heading = ray.heading.map(v => -v);
+    }
+
+  return graph;
+};
+
 const LatticeFilmstrip = ({
   seed = () => Graph.grid(),
   ticks = 8,
   height = 150,
   density = true,
   mode = 'lattice',
+  backwards = false,
 }: Lattice) => {
   const frames = useMemo(() => {
     const graph = seed();
@@ -172,14 +199,24 @@ const LatticeFilmstrip = ({
       states.push(graph.clone());
     }
 
-    return states;
+    // Reversed here rather than at the draw, so `i > 0` still means "not the
+    // first one shown" and the arrow lands between the same pairs either way.
+    //
+    // AND EVERY HEADING TURNED WITH IT, which reversing the order alone does
+    // not do: a charge drawn mid-run is still drawn going the way it was
+    // going, so a run played backwards shows two charges converging on a
+    // neutral point rather than leaving one. Reversing time reverses
+    // velocities, and only both together read as the rule run the other way.
+    return backwards ? states.reverse().map(turned) : states;
   }, []);
 
   return <div style={{ display: 'flex', flexWrap: 'wrap', alignItems: 'center' }}>
     {frames.map((graph, i) => (
       <Fragment key={i}>
         {i > 0
-          ? <div style={{ flex: '0 0 auto', padding: '0 0.5em', color: '#515254' }}>→</div>
+          ? <div style={{ flex: '0 0 auto', padding: '0 0.5em', color: '#515254' }}>
+            {backwards ? '←' : '→'}
+          </div>
           : null}
         <div style={{ flex: '1 1 120px', height }}>
           <GraphCanvas graph={() => graph} density={density} mode={mode} />
@@ -243,7 +280,7 @@ export const ModelView = ({ model }: { model: Model }) => {
   // A run repeated, where the arrangement is a draw rather than a case.
   const runs = Array.from({ length: lattice?.runs ?? 1 }, (_, i) => i);
 
-  return <div style={{ marginBottom: '1.5rem' }}>
+  return <div>
     <div style={{
       display: 'grid',
       gridTemplateColumns: many ? 'repeat(auto-fit, minmax(280px, 1fr))' : '1fr',
diff --git a/orbitmines.com/src/routes/references.tsx b/orbitmines.com/src/routes/references.tsx
index 8305d5e..7e08da4 100644
--- a/orbitmines.com/src/routes/references.tsx
+++ b/orbitmines.com/src/routes/references.tsx
@@ -209,8 +209,8 @@ export const ETHERS_ALMANAC: Content & { UPDATES: Content[] } = { reference: {
 }
 
 export const RAY_CALCULI_AND_PHYSICS: Content = { reference: {
-  title: "2026 Notes on Ray Calculi & Physics",
-  subtitle: "An initial look at a Ray Calculus for programs and physics.",
+  title: "2026 Physics: Notes on an XOR Universe",
+  subtitle: "An initial look at a discrete Ray Calculus for physics: specifically for gravity and electromagnetism, and a continuous model based on ideas of that discrete setup.",
   draft: true,
   date: "2026-12-31",
   year: "2026",

From c907c79fecc1848473b2a27821be242274aa5948 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Tue, 11 Aug 2026 23:06:28 +0200
Subject: [PATCH 28/47] Thinking about matter

---
 .../2026.RayCalculiAndPhysics/gravity.ts      | 1587 ++++++++++++++++-
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 1503 +++++++++++++++-
 .../2026.RayCalculiAndPhysics/rotation.tsx    |  267 +++
 3 files changed, 3345 insertions(+), 12 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index cf114cd..b231b8a 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -2698,6 +2698,1584 @@ export const REACHES = Math.sqrt(
  * only native hook already was.
  */
 
+/**
+ * AND THEN STOP TESTING MECHANISMS ONE AT A TIME. Every idea so far — the void
+ * expansion, the wake, the spatial-density gradient — died on a number rather
+ * than on a story, and it was the SAME number each time. So enumerate instead:
+ * every dimensionless quantity the model can build at galactic scale, from G,
+ * c, the cell, the tick, the age, and the galaxy's own M, r and v. Closing the
+ * gap needs +195%, which needs an O(1) number. At 20 kpc in the Milky Way:
+ *
+ *     quantity        what it is                        value
+ *     GM/rc²          how folded the place is           1.70e−7
+ *     v²/c²           how fast the star goes            5.39e−7
+ *     r/λ_reach       against gravity's Yukawa range    1.25e−5
+ *     r/ct₀           against the horizon               4.73e−6
+ *     ℓ_P/r           the lattice spacing               2.62e−56
+ *     t_P/(r/v)       a tick against an orbit           1.92e−59
+ *     M/M_universe    against everything there is       1.41e−12
+ *     g·t₀/c          the pull against c per age        3.86e−2
+ *
+ * AND THAT IS THE WHOLE LIST. Seven of the eight sit between 10⁻⁵ and 10⁻⁵⁶.
+ * EXACTLY ONE is anywhere near unity, and it is the last. So no mechanism built
+ * out of the others can work, whatever its story, because it has nothing to
+ * make an O(1) correction from — which closes the entire family at once instead
+ * of one idea at a time, and is worth more than any of the individual tests.
+ *
+ * AND THE ENUMERATION POINTS AT ITS OWN ANSWER. The survivor is an ACCELERATION
+ * against c per age. Set it to one:
+ *
+ *     c/t₀ = 6.884·10⁻¹⁰ m/s²      a₀ = 1.200·10⁻¹⁰
+ *     a₀·t₀/c = 0.1743             against 1/2π = 0.1592
+ *
+ * The one number this model has at galactic scale IS the MOND scale, to 2π.
+ * Not a mechanism and not a derivation — but the search space is now ONE
+ * DIMENSIONAL. Anything that works here has to be a statement about the
+ * smallest acceleration the lattice can represent, because there is no other
+ * handle.
+ *
+ * WHERE THAT LEAVES DARK MATTER HERE — two options, exactly as for general
+ * relativity, and it is worth saying that plainly:
+ *
+ *   PARTICLE CONTENT   permitted and not predicted. `inStep` already says a
+ *                      bound object needs m < 2π/R to cohere, which at 30 kpc
+ *                      is 1.3·10⁻²⁷ eV — the ultralight window. GR does exactly
+ *                      this, and pays exactly this price.
+ *
+ *   A FLOOR            the acceleration above. Native, unique, and a factor of
+ *                      4.5 short of being counted.
+ *
+ * AND THE COMPARISON THAT MATTERS: Newton, general relativity and this model
+ * give the SAME rotation curve to six decimal places — GR's correction to a
+ * circular orbit is `u = 1.7·10⁻⁷`, which shifts 220 km/s by 4·10⁻⁵ — and all
+ * three miss by a factor of 3 at 20 kpc and 4.5 at 30. This is not a strike
+ * against the model. It is the bill every theory of gravity has carried since
+ * the 1970s, and this one inherits it exactly BECAUSE it reproduces general
+ * relativity. What would count against it is failing where GR succeeds, and it
+ * does not do that here.
+ */
+
+/**
+ * CAN THE FLOOR BE FOUND BY ENUMERATING? Twice over, and the two enumerations
+ * have opposite worth — which is the point of doing both.
+ *
+ * THE SEARCH OVER NUMBERS IS WORTHLESS, AND THAT IS MEASURABLE. If the
+ * mechanism is one `BIAS` kick per age then `a₀ = BIAS·κ/t₀`, so
+ * `κ = a₀t₀/(c·BIAS) = 4.5323`, and the job is to find 4.5323 from the lattice
+ * constants. Building every expression of the form a·b/c, a/(b·c) and √(ab)/c
+ * out of sixteen constants the file already owns — SHEET, WAYS, HALF, DIMS,
+ * FLOOR, G_LATTICE, π, e, √2, √3, 2π, 4π and friends — gives 12816 expressions,
+ * of which:
+ *
+ *     within 20%    661 expressions, 107 distinct values
+ *     within 10%    341              60
+ *     within  5%    175              31
+ *     within  2%     95              12
+ *     within  1%     20               4
+ *
+ * — the closest being `√(WAYS·π)/2 = 4.51889`, at −0.30%. TWENTY EXPRESSIONS
+ * LAND INSIDE A PERCENT. A search over numbers cannot tell a derivation from an
+ * accident here, so a hit is worth nothing even when it is close, and
+ * `√(WAYS·π)/2` is recorded as a curiosity and nothing else. This is the one
+ * place where the file's habit — count it, do not fit it — has to be enforced
+ * by REFUSING TO LOOK rather than by looking carefully.
+ *
+ * THE SEARCH OVER CONSTRAINTS IS NOT. What must the floor DO?
+ *
+ *   UNIVERSAL. The same a₀ for every galaxy, mass and composition. So it cannot
+ *   depend on m_test, m_source or constituent — which kills the per-particle
+ *   reading outright, since there a heavier body would have a LOWER floor.
+ *
+ *   AN ACCELERATION, not a length and not a velocity. The transition is
+ *   observed at fixed g; low-surface-brightness galaxies deviate at SMALL
+ *   radius, which a length scale forbids outright.
+ *
+ *   A SQUARE ROOT: `g → √(a₀·g_N)` deep down, not `g_N + a₀`. A constant
+ *   addition gives `v ∝ √r` rather than flat, and misses Tully–Fisher entirely.
+ *
+ *   IT MUST SWITCH OFF faster than linearly above a₀ — the solar system bounds
+ *   anomalies at 10⁻¹³ m/s² where g/a₀ is already 5·10⁷.
+ *
+ *   AN EXTERNAL FIELD EFFECT, since a floor on the TOTAL acceleration makes a
+ *   system's internal dynamics depend on the field it sits in. That breaks
+ *   strong equivalence, separates modified inertia from modified gravity, and
+ *   is measurable in wide binaries.
+ *
+ *   AND IT MUST RUN WITH TIME — which is the one that pays.
+ */
+
+/**
+ * BECAUSE a₀ = c/2πt MAKES a₀ A FUNCTION OF THE AGE, AND THAT IS TESTABLE NOW.
+ *
+ * In the coasting model `a ∝ t` exactly, so `1 + z = t₀/t`: the redshift IS the
+ * age ratio, with nothing fitted. Then
+ *
+ *     a₀(z) = a₀(0)·(1 + z)      and      v_flat = (G·M·a₀)^¼ ∝ (1+z)^¼
+ *
+ *     z     age (Gyr)   a₀(z)/a₀   v_flat ratio   BTFR offset
+ *     0.0   13.80       1.00       1.0000         0.000 dex
+ *     0.5    9.20       1.50       1.1067         0.176
+ *     1.0    6.90       2.00       1.1892         0.301
+ *     2.0    4.60       3.00       1.3161         0.477
+ *     3.0    3.45       4.00       1.4142         0.602
+ *
+ * At z = 2 the same baryonic mass should rotate 32% FASTER, and the baryonic
+ * Tully–Fisher relation should sit half a dex off its local place. Locally that
+ * relation is measured to under 0.1 dex, so 0.48 is not subtle — it is the sort
+ * of thing a survey either sees or excludes.
+ *
+ * AND THE SIGN IS THE INTERESTING PART. High-redshift discs at z ~ 1–2 are
+ * reported with DECLINING rotation curves — more baryon-dominated, more
+ * Keplerian, which is what a SMALLER a₀ would give. This model wants a LARGER
+ * one. If that reading holds, `a₀ ∝ 1/t` is excluded, and with it the only
+ * native hook the model has at galactic scale.
+ *
+ * WHICH IS THE RIGHT KIND OF TROUBLE, and the reason to have chased it. The
+ * coincidence `a₀ ≈ cH₀` is normally filed as an ornament precisely because
+ * nothing forces it to hold at any other epoch. Here the frontier construction
+ * forces it — H is 1/t, and t is a count of ticks — so the model cannot decline
+ * the test. It turns a curiosity into something that can be taken away, which
+ * is the only thing that makes it worth having.
+ */
+
+/**
+ * AND WHAT EXACTLY HAS TO BE SQUARE-ROOTED — which turns out to be the sharpest
+ * thing in this whole section, and to explain every failure above as one
+ * failure rather than several.
+ *
+ * FIRST, THE NUMBER, SINCE IT IS ASKED. Is the missing factor 1/SHEET?
+ *
+ *     constant         a₀ = K·c/t₀    against 1.200e−10
+ *     1/SHEET          8.605e−11      −28.3%
+ *     1/WAYS = BIAS    2.648e−11      −77.9%
+ *     1/2π             1.096e−10       −8.7%
+ *     HALF/DIMS        1.147e−10       −4.4%
+ *
+ * 1/SHEET is 28% low. And by the count already made — twenty expressions inside
+ * one percent — even a hit would not be evidence, so the number is not the way
+ * in and it is worth not pretending otherwise.
+ *
+ * SECOND, AND THIS IS THE POINT: IT IS NOT √r THAT IS WANTED. Write the deep
+ * law out and the two halves come apart:
+ *
+ *     g = √(a₀·g_N) = √(a₀·GM/r²) = √(a₀GM)/r
+ *
+ *     g ∝ 1/r    instead of 1/r²    — EASY, lots of things give 1/r
+ *     g ∝ √M     instead of M       — HARD, and this is the whole problem
+ *
+ * THE RADIUS IS NOT SQUARE-ROOTED AT ALL. THE MASS IS.
+ *
+ * AND THAT THE EXPONENT IS FORCED IS PROVABLE RATHER THAN FELT. Take any law
+ * whose deep limit is a power, `g → k·g_N^p`. Then `v² = g·r = k(GM)^p r^{1−2p}`:
+ *
+ *     a flat rotation curve   needs   1 − 2p = 0   ⇒   p = ½
+ *     v⁴ ∝ M                  needs   4p = 1       ⇒   p = ½
+ *
+ * BOTH LAND ON THE SAME EXPONENT, which is why MOND has no freedom in its deep
+ * limit at all. Measured across the candidate forms:
+ *
+ *     form                        deep p    v⁴ ∝ M^   verdict
+ *     g_N + a₀                    0.004     0.009     ✗
+ *     max(g_N, a₀)                0.000     0.000     ✗
+ *     g_N/(1 − e^{−g_N/a₀})       0.002     0.005     ✗
+ *     √(g_N² + a₀·g_N)            0.502     1.005     ✓
+ *     √(a₀·g_N) pure              0.500     1.000     ✓
+ *     g_N/(1 − e^{−√(g_N/a₀)})    0.516     1.032     ✓
+ *
+ * — only the forms containing a GEOMETRIC MEAN of g_N and a₀ survive, and that
+ * is not an accident of the list: p = ½ IS the geometric mean and everything
+ * else is an arithmetic one. (`g_N + √(a₀g_N)` measures 0.530 here only because
+ * 100 kpc is not yet deep enough for g_N to have dropped out; asymptotically it
+ * is fine.)
+ *
+ * WHICH IS EXACTLY WHAT THIS MODEL CANNOT DO, AND NOW THE REASON IS NAMEABLE.
+ * Every force here is a MEETING RATE of two fluxes:
+ *
+ *     shortfall ∝ m_a · m_b        strictly BILINEAR in the two sources
+ *
+ * and a rate is linear in each emitter because each emitter emits
+ * independently. So any change to the GEOMETRY (how flux spreads), the
+ * PROPAGATION (ballistic, diffusive, screened) or the COUNTING (SHEET, WAYS,
+ * dimension) moves the r-dependence and LEAVES THE MASS LINEAR:
+ *
+ *     change                        gives         Tully–Fisher
+ *     flux ∝ 1/r² both              Newton        g ∝ M/r², p = 1
+ *     flux ∝ 1/r both (diffusive)   g ∝ M ln/r    flat curve, v⁴ ∝ M²
+ *     effective dimension 2         g ∝ M/r       flat curve, v⁴ ∝ M²
+ *     stimulated halo, ρ ∝ M/r²     g ∝ M/r       flat curve, v⁴ ∝ M²
+ *
+ * ALL OF THEM LAND ON v⁴ ∝ M², FOR ONE REASON. Bilinearity forces `v² ∝ M`
+ * whatever the geometry does, so `v⁴ ∝ M²` always. WHICH MEANS THE THREE
+ * MECHANISMS THAT FAILED ABOVE DID NOT FAIL SEPARATELY — the halo, the wake and
+ * the spatial gradient are one failure wearing three hats, and it was worth
+ * finding that out.
+ *
+ * SO THE REQUIREMENT IS SHARP. The model needs a response NONLINEAR IN THE
+ * SOURCE: going as √M below a₀ and back to M above it. Nothing built out of how
+ * the flux TRAVELS can do that, because travel does not know how much was
+ * emitted. It has to be something about the EMISSION or the RESPONSE saturating
+ * — and the model has exactly one saturating quantity, the one-emission-a-tick
+ * ceiling, which acts at the other end of the scale entirely.
+ *
+ * WHICH IS A CLEANER PLACE TO BE STUCK THAN "FIND 4.5323". It says what to look
+ * for, it says where not to look, and it explains every failure so far as the
+ * same failure.
+ */
+
+/**
+ * AND IT IS WORSE THAN BILINEARITY — IT IS A THEOREM. Two things this model
+ * already satisfies, and would not want to give up:
+ *
+ *     ACTION AND REACTION   F(a,b) = F(b,a), because the force IS a count of
+ *                           meetings and both parties count the same ones
+ *     EQUIVALENCE           a_a = F/m_a depends on m_b and r, not on m_a
+ *
+ * The second gives `F = m_a·h(m_b, r)`. Feed that into the first:
+ *
+ *     m_a·h(m_b) = m_b·h(m_a)  ⇒  h(m)/m = const  ⇒  F ∝ m_a·m_b, EXACTLY
+ *
+ * SO NO TWO-BODY FORCE LAW CAN GIVE √M. Not a modified one, not a screened one,
+ * not one with a different geometry — none. The mechanisms that failed above
+ * were not unlucky, they were forbidden before they started. And this is why
+ * MOND has never been written as a pairwise law by anybody: it cannot be.
+ *
+ * WHICH LEAVES EXACTLY ONE DOOR. The theorem is about a force between TWO
+ * things. It says nothing about whether the field of a COMPOSITE is the sum of
+ * its parts' fields. In this model it is, for a definite reason — every emitter
+ * emits independently, so the fluxes just add. BREAK SUPERPOSITION AND THE
+ * THEOREM DOES NOT APPLY: a galaxy is then not the sum of its stars.
+ */
+
+/**
+ * A SECOND GRAPH, THEN — a layer over the spatial one, with its own ±
+ * polarities and its own XOR, moving under its own dynamics, deciding WHERE
+ * MASS IS. Can it recover the root?
+ *
+ * IT IS THE RIGHT SHAPE, AND IT IS THE FIRST THING HERE THAT IS. A layer that
+ * decides where mass is makes the emitters NON-INDEPENDENT — whether one
+ * contributes now depends on what the layer is doing, which depends on the
+ * others. That is superposition failing, which is the one door the theorem
+ * leaves open. Every earlier proposal tried to modify the geometry around the
+ * obstruction; this one goes through it.
+ *
+ * AND THE XOR GIVES THE ROOT FOR NOTHING, which is the point. N contributions
+ * with random ± signs do not sum to N — they sum to a walk:
+ *
+ *     N        ⟨|net|⟩ measured   √(2N/π) expected
+ *     1e+2       7.91               7.98
+ *     1e+4      80.01              79.79
+ *     1e+6     800.42             797.88
+ *
+ * If gravity couples to the NET polarity rather than the COUNT, the source
+ * enters as √M with nothing put in by hand — out of the same XOR the whole
+ * model is built on, rather than out of a new postulate.
+ *
+ * BUT √M ALONE IS NOT ENOUGH, and it is worth being exact. An effective mass
+ * `M_eff = √(M·M₀)` gives `G√(MM₀)/r²`, hence `v ∝ r^−½` — not flat. Deep MOND
+ * needs `√(a₀GM)/r`, so the RADIUS has to move too. What the layer must
+ * actually produce is a halo:
+ *
+ *     ρ_halo(r) ∝ √M / r²      ⇒     M_halo(r) = r·√(a₀M/G)
+ *
+ * — the isothermal profile that failed on Tully–Fisher, with √M in place of M.
+ * Checked: that gives v = 182.7 km/s flat from 10 to 30 kpc and `v⁴ = G·M·a₀`
+ * exactly, both conditions from the one exponent. THE XOR SUPPLIES THE FIRST
+ * HALF AND NOTHING HERE SUPPLIES THE SECOND — why the layer's excitation should
+ * fall as 1/r² around a source is not fixed by anything yet.
+ *
+ * AND THERE IS A COST THAT IS MEASURABLE AND NEARLY FATAL. A random walk has a
+ * WIDTH as well as a mean: `|Σ±1|` is Rayleigh, mean `√(2N/π)`, standard
+ * deviation `0.655√N`. So a single realisation scatters by 76% in the net, 19%
+ * in `v = M_eff^¼`, which is 0.244 dex of Tully–Fisher scatter — against a
+ * relation measured to UNDER 0.1 dex across five decades. A STATIC random walk
+ * is excluded outright.
+ *
+ * IT SURVIVES ONLY IF THE LAYER RE-RANDOMISES FAST, averaging K independent
+ * samples over an orbit and cutting the scatter by √K:
+ *
+ *     correlation time   samples per orbit   scatter
+ *     1 tick             1.3e+59             <1e−4 dex
+ *     1 year             2.2e+8              <1e−4 dex
+ *     1 Myr              2.2e+2               0.021 dex
+ *     1 Gyr              0.22                 0.415 dex
+ *
+ * (an orbit at the Sun's radius is 223 Myr). Anything faster than about a
+ * megayear washes it out entirely, and a lattice layer would decorrelate in
+ * ticks — so this is not a close call, but it IS a real constraint, and it says
+ * the layer must be FAST-MOVING. Which is what "moves on its own" already
+ * proposed, so the idea passes its own first test.
+ *
+ * WHAT IT WOULD OWE IF IT WERE BUILT:
+ *
+ *   THE CROSSOVER      why the cancellation turns on below a₀ and off above it.
+ *                      This is still the whole of the unexplained part — the
+ *                      second graph makes the √ POSSIBLE and does not make it
+ *                      HAPPEN at the right scale.
+ *   THE 1/r² REACH     why the layer's excitation falls as 1/r² and not another
+ *                      power.
+ *   THE SOLAR SYSTEM   superposition holds there exquisitely, so the breaking
+ *                      must vanish above a₀ faster than linearly.
+ *   WHAT MASS IS       the layer decides where mass is, so `mass = pulse rate`
+ *                      has to be re-derived on it rather than assumed — which
+ *                      reaches back into `physics.ts` and is not a small edit.
+ *
+ *   AN EXTERNAL FIELD EFFECT is NOT a cost. It is unavoidable once superposition
+ *   fails, it is MOND's own signature, and it is measurable in wide binaries and
+ *   dwarf satellites — so it arrives as a prediction rather than a bill.
+ *
+ * VERDICT: structurally the right shape, and the only proposal so far that can
+ * evade the theorem. The XOR hands over the root for free. It does not hand
+ * over the crossover, which is where all the difficulty actually lives.
+ */
+
+/**
+ * AND IF THE SECOND LAYER HAS EMITTERS TOO, THE OTHER HALF ARRIVES FROM THE
+ * SAME PLACE — which closes the shape completely.
+ *
+ * The spatial graph already gets its inverse square from emitters:
+ * `chance(m,r) = m·SHEET/shell(r)`, a point spreading over a sphere. Give the
+ * second layer emitters as well and the same geometry follows, with the XOR
+ * doing the rest:
+ *
+ *     N emitters, each ∝ 1/r²     each spreads over the sphere
+ *     random ± polarity           XOR, so they do not add — they WALK
+ *     ⇒ net(r) ∝ √N/r² = √M/r²   BOTH HALVES, out of one construction
+ *
+ * Neither piece is put in by hand. The XOR gives the root, the emitters give
+ * the inverse square, and both are rules the model already has.
+ *
+ * AND THAT IS EXACTLY THE PROFILE THAT WORKS. With `ρ = κ√M/r²`:
+ *
+ *     M_halo(r) = ∫4πr²ρ dr = 4πκ√M·r
+ *     g_halo    = G·M_halo/r² = 4πGκ√M/r
+ *     v²        = g·r = 4πGκ√M          ⇒  FLAT
+ *     v⁴        = (4πGκ)²·M             ⇒  v⁴ ∝ M, TULLY–FISHER
+ *
+ * Matching `v⁴ = GMa₀` fixes `κ = √(a₀/G)/4π = 0.10670 kg^½/m`, and the check
+ * closes: 182.7 km/s from the profile against 182.7 from `(GMa₀)^¼`, flat at
+ * every radius. BOTH CONDITIONS, ONE EXPONENT, nothing fitted but κ ↔ a₀. The
+ * SHAPE of the dark matter problem is closed.
+ *
+ * BUT WITHOUT A CROSSOVER IT IS DEAD IN THE SOLAR SYSTEM, and by a lot. The
+ * same halo forms around the Sun:
+ *
+ *     around      within    M_halo (kg)   as a fraction
+ *     the Sun     1 AU      2.83e+26      1.42e−4
+ *     the Sun     30 AU     8.49e+27      4.27e−3
+ *     the Earth   4e8 m     1.31e+21      2.19e−4
+ *
+ * Planetary ephemerides pin GM☉ to a part in 10¹⁰, so 1.4·10⁻⁴ inside the
+ * Earth's orbit is out by SIX ORDERS — and it would show as an anomalous
+ * precession, since the added mass is distributed rather than central, which is
+ * the most tightly measured thing in the solar system. So the crossover is not
+ * an optional extra: it is the difference between a mechanism and a refutation.
+ * It is also now THE ONLY MISSING PIECE.
+ *
+ * AND THE OBVIOUS CROSSOVER IS RULED OUT, which is a real result. The natural
+ * story is that a strong field ALIGNS the layer's polarities so they add (net =
+ * N, Newton) while a weak field leaves them random (net = √N, MOND), with the
+ * alignment accumulating over the age so the measure is `g·t₀/c` — the one O(1)
+ * number the model has. THE PROBLEM: the switch happens where the aligned part
+ * overtakes the random part, `α·N ≈ √N`, so `α ≈ 1/√N`, WHICH COUNTS
+ * CONSTITUENTS:
+ *
+ *     body               N (protons)   1/√N       threshold moves by
+ *     the Sun            1.19e+57      2.90e−29   —
+ *     a dwarf, 1e8 M☉    1.19e+65      2.90e−33   10⁴
+ *     the Milky Way      8.32e+67      1.10e−34   10⁵·⁴
+ *
+ * — so a₀ would be MASS-DEPENDENT, and a₀ is measured universal to well inside
+ * a factor of two across five decades. The alignment story is out.
+ *
+ * WHICH IS A CONSTRAINT RATHER THAN A DEAD END. It says the crossover cannot be
+ * a competition between an aligned part and a random part, because any such
+ * competition counts constituents and a₀ must not. It has to switch the WHOLE
+ * layer between two regimes without reference to how many emitters sit in it —
+ * A PROPERTY OF THE PLACE, NOT OF THE BODY. Which is suggestive rather than
+ * hopeless, since "a property of the place" is exactly what `fold` already is,
+ * and `g·t₀/c` is already a statement about a place.
+ *
+ * WHERE IT LEAVES THINGS:
+ *
+ *     √M in the source     DONE — XOR on the second layer, nothing added
+ *     1/r² in the reach    DONE — emitters on it, same as the spatial graph
+ *     a flat curve         follows, exactly
+ *     v⁴ ∝ M               follows, exactly
+ *     the scale a₀         sets κ; still not counted, still 4.5 off BIAS/t₀
+ *     the crossover        OPEN — and now the only open thing, with one whole
+ *                          class of answers eliminated
+ *
+ * Three turns ago this was five separate unknowns. It is one.
+ */
+
+/**
+ * SO MUST THE TWO LAYERS TOUCH? YES, AND WHICH WAY DECIDES EVERYTHING. Three
+ * couplings, and only the last works.
+ *
+ * A. INDEPENDENT — and this is the property that has to go. If the second layer
+ * evolves entirely on its own and the first on its own, the second is a
+ * RELABELLING and nothing more: layer one still sums over whatever sources it
+ * sees, superposition still holds inside it, and the theorem applies word for
+ * word. Independence is not a detail of the picture; it is the thing standing
+ * between the picture and working.
+ *
+ * B. ONE-WAY — the second layer says WHERE THE MASS IS and layer one does the
+ * rest. This is the reading one falls into by default, and it fails by an
+ * amount that can be computed exactly. Gravity in layer one is annihilation, so
+ * it counts + against −. Write a body's counts as `N± = N/2 ± s/2` with s the
+ * NET polarity; then for two bodies with nets s and u,
+ *
+ *     rate ∝ N₊M₋ + N₋M₊ = (N·M − s·u)/2
+ *
+ * THE ROOT IS THERE — `s·u ~ √(NM)` — but as a CORRECTION to the bilinear term
+ * rather than a replacement for it, and carrying a random sign:
+ *
+ *     pair                     √(N·M)     s·u/(N·M)
+ *     a star and the Galaxy    3.15e+62   3.18e−63
+ *     the Sun and the Earth    2.06e+54   4.85e−55
+ *     two protons              1.00e+0    1.00e+0
+ *
+ * For a star in a galaxy the root term is 3·10⁻⁶³ of the Newtonian one, where
+ * MOND wants it COMPARABLE — at 20 kpc `√(a₀g_N)/g_N = 2.13`. Out by
+ * sixty-three orders, and no crossover rescues that: suppressing the product by
+ * 10⁶³ is not a switch, it is a deletion.
+ *
+ * C. TWO-WAY — the second layer has ITS OWN FIELD, and that field gravitates in
+ * the first. This is the picture as described, and it is the only one that
+ * works. The halo is then not a correction to layer one's counting but layer
+ * TWO's own emitted field, with its own reach, which layer one feels. Its size
+ * is set by an INTER-LAYER COUPLING κ rather than by 1/√(NM), so it is free to
+ * be whatever a₀ says:
+ *
+ *     ρ_halo = κ·√M/r²,   κ = √(a₀/G)/4π = 0.10670 kg^½/m
+ *     v⁴ = (4πGκ)²·M = G·M·a₀     flat, and Tully–Fisher, exactly
+ *
+ * AND THAT IS THE REAL COST, stated plainly: a₀ BECOMES A NEW FUNDAMENTAL
+ * CONSTANT — the strength with which layer two's field gravitates in layer one
+ * — rather than something counted out of SHEET and WAYS. For a model whose
+ * whole method is counting, that is a genuine loss, and it belongs in the
+ * ledger rather than hidden inside a κ.
+ *
+ * D. AND A REQUIREMENT NOBODY ASKED FOR, WHICH IS A POINT IN FAVOUR. The net
+ * polarity has a RANDOM SIGN:
+ *
+ *     coupling to    goes as   sign       verdict
+ *     net            √M        random     ✗ antigravity half the time
+ *     net²           M         positive   ✗ linear again, no root
+ *     |net|          √M        positive   ✓ the only one left
+ *
+ * An absolute value is a strange thing to couple to — AND IT IS EXACTLY WHAT
+ * MOND ALREADY HAS. AQUAL's field equation is `∇·[μ(|∇φ|/a₀)∇φ] = 4πGρ`, whose
+ * nonlinearity is an absolute value of a field, for precisely this reason: it
+ * makes the response sub-linear without making it signed. So the second layer
+ * is not being asked for something exotic. It is being asked for MOND's own
+ * nonlinearity, arrived at from the other side — `|net polarity of a random ±
+ * layer|` in place of `|∇φ|`. Two constructions with nothing in common landing
+ * on the same odd requirement is the one encouraging thing in this whole
+ * section.
+ *
+ * WHAT IS ACTUALLY LEFT:
+ *
+ *     THE COUPLING    two-way. Not independence, not a relabelling — both fail,
+ *                     one of them by sixty-three orders.
+ *     a₀              the inter-layer coupling constant. Fitted, not counted.
+ *     |net|           required, and it is MOND's |∇φ|.
+ *     THE CROSSOVER   still open, and now stated exactly: not "why does the
+ *                     root appear" but WHY DOES THE PRODUCT SWITCH OFF — and it
+ *                     cannot count constituents, or a₀ moves with mass.
+ *     A BONUS         layer two carrying "pulse = which particle" is where a
+ *                     PARTICLE SPECTRUM could come from, and this model has
+ *                     none. Worth having whatever happens to a₀.
+ */
+
+/**
+ * AND IS THE COMPOUNDING THE NONLINEARITY? Layer two moves THROUGH layer one,
+ * so layer one's fold decides where layer two can go, and the effects feed each
+ * other. That is the right SHAPE of argument — it is the one that already paid
+ * once, since `1 + u = e^{u₀}` came from precisely this move: a folded node has
+ * more edges, edges point both ways, so it is easier to arrive at, so the
+ * folding feeds itself. It remains the only nonlinearity this file has DERIVED
+ * rather than assumed.
+ *
+ * BUT THE COMPOUNDING ALREADY IN THE FILE IS THE WRONG FUNCTION, AND THE SHAPE
+ * MATTERS MORE THAN THE SIZE:
+ *
+ *     u at 20 kpc in the Milky Way       1.675e−7
+ *     the compounded part, e^u − 1 − u   1.405e−14
+ *     ratio                              8.4e−8
+ *
+ * Fourteen orders under a linear term that is itself seven orders under what is
+ * wanted. And `e^u = 1 + u + u²/2 + …` is integer powers forever — THERE IS NO
+ * LIMIT OF AN EXPONENTIAL THAT BEHAVES LIKE A SQUARE ROOT. So the compounding
+ * the model already has cannot be it, whatever its size.
+ *
+ * THE VERSION THAT COULD WORK IS A DIFFERENT COMPOUNDING, and it aims at
+ * exactly the obstruction that was left open. Not "the fold compounds itself"
+ * but THE FOLD DECIDES HOW FAST LAYER TWO FORGETS. Layer two moves through
+ * layer one, and `slowing = e^{−2u}` holds motion back where the fold is deep:
+ *
+ *     deep in a well   layer two is held    polarities stay ALIGNED   net ~ N
+ *     far out          layer two runs free  polarities RANDOMISE      net ~ √N
+ *
+ * WHICH IS A PROPERTY OF THE PLACE AND NOT OF THE BODY — precisely what the
+ * constituent-counting argument demanded, and the first candidate crossover
+ * that survives it.
+ *
+ * AND IT HAS A SHARP NUMERICAL TENSION, which is the useful part. The
+ * decorrelation time τ has to do two jobs at once:
+ *
+ *   THE CROSSOVER. Alignment accumulates as `g·t/c`, so it beats randomisation
+ *   when `g·τ/c ≳ 1` and the switch sits at `g = c/τ`. For that to be a₀,
+ *   `τ = c/a₀ = 2.50·10¹⁸ s = 79 Gyr` — 5.7 times the age of the universe, i.e.
+ *   essentially FROZEN.
+ *
+ *   THE SCATTER. `|Σ±1|` has 76% relative width whatever N is, so one frozen
+ *   realisation gives 0.244 dex of Tully–Fisher scatter. Staying under 0.1 dex
+ *   needs more than 8.5 independent draws an orbit, and an orbit at the Sun's
+ *   radius is 223 Myr — so `τ < 8.3·10¹⁴ s = 26 Myr`, i.e. FAST.
+ *
+ *     the crossover     τ = 2.50e+18 s    79 Gyr, frozen
+ *     the scatter       τ < 8.28e+14 s    26 Myr, fast
+ *     apart by          3.0e+3            3.5 orders
+ *
+ * THE CROSSOVER WANTS LAYER TWO FROZEN AND THE SCATTER WANTS IT FAST. That is
+ * the next thing to settle, and it is A NUMBER RATHER THAN A STORY — the first
+ * time in this whole line of argument that has been true.
+ *
+ * AND ONE ESCAPE, WHICH FOLLOWS FROM THE |net| RESULT RATHER THAN BEING ADDED
+ * TO SAVE IT. The scatter argument assumed ONE walk for the whole body. But the
+ * sign argument already forced the coupling to be to `|net|` — and if that is
+ * LOCAL, the halo sums `|net|` over K patches instead of taking `|Σ|` once:
+ *
+ *     one global walk    total ~ √N       relative width 76%, N-independent
+ *     K local |nets|     total ~ √(K·N)   relative width 76%/√K
+ *
+ *     patch ℓ    K = (30 kpc/ℓ)³   scatter (dex)   √K in the magnitude
+ *     10 kpc     2.70e+1           0.0590          5.2
+ *     3 kpc      1.00e+3           0.0103          31.6
+ *     1 kpc      2.70e+4           0.0020          164
+ *
+ * SPATIAL averaging suppresses the scatter without needing fast forgetting, so
+ * τ is freed to be long and the tension dissolves — at the price of a new
+ * length. Any patch under about ten kiloparsecs already kills the scatter. What
+ * it then owes is that the `√K` be absorbed into κ WITHOUT introducing a mass or
+ * radius dependence, or Tully–Fisher moves.
+ *
+ * AND CHECKED, THAT ESCAPE DOES NOT SURVIVE. Three lines: `M_eff = √(K·N)` with
+ * `K = V/ℓ³` and `N = M/m_p` gives `M_eff = √(V·M/(ℓ³m_p))`. Tully–Fisher wants
+ * `M_eff ∝ √M` AND NOTHING ELSE, so `V/ℓ³` must not depend on the system —
+ * meaning `ℓ³ ∝ V`, i.e. THE SAME NUMBER OF PATCHES FOR EVERY SYSTEM, dwarf to
+ * cluster. That is not a length, it is a fixed fraction of whatever it sits in,
+ * which no local rule produces. With a fixed ℓ instead the halo picks up the
+ * galaxy's SIZE as well as its mass and Tully–Fisher moves by whole dex between
+ * a dwarf and a giant. So the spatial escape is out, and the temporal tension
+ * stands: 79 Gyr against 26 Myr.
+ */
+
+/**
+ * SO SAY THE WHOLE THING IN ONE LINE, because the machinery has got ahead of
+ * the question.
+ *
+ * Strip out the layers, the polarities and the patches. What is left is a
+ * statement about WHICH FLUX IS CONSERVED:
+ *
+ *     regime      law               conserved through a sphere
+ *     Newton      g = GM/r²         g·r²  = GM
+ *     deep MOND   g = √(GMa₀)/r     g²·r² = GM·a₀
+ *
+ * Both checked flat at 10, 20 and 40 kpc, both equal to 1.3919e+41 kg, which is
+ * the Milky Way's baryons. So:
+ *
+ *     NEWTON CONSERVES THE FLUX OF g.  DEEP MOND CONSERVES THE FLUX OF g².
+ *
+ * and the interpolation is exactly AQUAL, `μ(g/a₀)·g·r² = GM`. THAT IS THE
+ * ENTIRE PROBLEM. The second layer, the ± polarities, the random walk, the
+ * patches — all of it is machinery for making that one switch happen.
+ *
+ * AND IT COLLAPSES THREE QUESTIONS INTO ONE. "Where does √M come from", "where
+ * does 1/r come from" and "what switches at a₀" are the same question, because
+ * `g²r² = GMa₀` contains all three at once: the square gives the root, the
+ * square gives the 1/r, and a₀ is only the constant that makes two conserved
+ * quantities carry the same units.
+ *
+ * A WRONG TURN WORTH RECORDING, since it looks right for about a minute. "Count
+ * PAIRS instead of charges — pairs among n go as n², so a conserved pair-flux
+ * makes the charge-count its root." It does not survive: pair density goes as
+ * `n² ∝ M²/r⁴`, so pairs in a shell go as `4πr²n² ∝ M²/r²`, which FALLS with
+ * radius instead of being conserved. Counting pairs concentrates at the centre,
+ * which is the opposite of a halo.
+ *
+ * THE RIGHT STATEMENT IS SIMPLER. `g²r² = const` is just `g ∝ 1/r`, and g here
+ * is the density of whatever mediates — so the whole requirement is about how
+ * that density falls:
+ *
+ *     how it travels      density   gives
+ *     ballistic in 3D     1/r²      Newton
+ *     diffusive in 3D     1/r       the MOND radial law
+ *     ballistic in 2D     1/r       the same
+ *
+ * with the amplitude needing to be √M, which random ± signs already give. So
+ * the deep law is exactly RANDOM SIGNS (√M) × A 1/r PROFILE (diffusive, or
+ * effectively two-dimensional) — two ingredients the model already has words
+ * for, since `SPREAD` is diffusion and the XOR is the signs. A much smaller ask
+ * than a second layer with its own gravity.
+ *
+ * AND THE REMAINING TRAP, worth seeing now rather than later: the natural
+ * switch from ballistic to diffusive is the MEAN FREE PATH — one regime inside
+ * λ and the other outside. THAT IS A LENGTH, and a length is already excluded,
+ * because low-surface-brightness galaxies deviate from Newton at SMALL radius
+ * and no r-threshold can do that. The switch has to be driven by the field
+ * STRENGTH, not by distance.
+ *
+ * WHICH LEAVES ONE QUESTION, IN ONE SENTENCE:
+ *
+ *     WHAT MAKES THE MEDIATOR STOP TRAVELLING STRAIGHT WHEN g FALLS BELOW a₀?
+ *
+ * Everything above is scaffolding for that, and anything that answers it makes
+ * most of the scaffolding unnecessary.
+ */
+
+/**
+ * "BELOW WHAT", THOUGH — because "below a₀" is circular, a₀ being the thing to
+ * be derived. Said in the model's own units it stops being circular, and starts
+ * saying something.
+ *
+ * FIRST, WHY "WEAK FIELD" AND "FEW CARRIERS" ARE ONE SENTENCE HERE. The model
+ * has one carrier: charges emitted by mass, at occupancy `chance(m,r) =
+ * m·SHEET/shell(r)`, with the pull `g = GRAVITY·m/r²`. Divide them:
+ *
+ *     g / chance = 4π·GRAVITY/SHEET = 0.097942     — a CONSTANT, m and r gone
+ *
+ * SO g IS THE CARRIER DENSITY, times a fixed number. In general relativity the
+ * field strength is not a density of anything; here it is exactly one, and that
+ * is why this model can state the condition LOCALLY at all. "The field is weak"
+ * and "the carriers are sparse" are not two facts about a place.
+ *
+ * SO THE THRESHOLD HAS AN ANSWER IN CARRIERS PER CELL:
+ *
+ *     the lattice's acceleration unit   ℓ_P/t_P² = 5.561e+51 m/s²
+ *     a₀ in those units                 2.158e−62
+ *     the crossover occupancy           2.203e−61 carriers a cell
+ *     i.e. ONE carrier per              4.539e+60 cells
+ *
+ * AND THE STATEMENT IS ABOUT A PATH, NOT A VOLUME — the first version of this
+ * said "one carrier per horizon", which compared a volume count against a
+ * linear one, and those differ by 10¹²¹ here. The occupancy is right and the
+ * phrase was not. Correctly:
+ *
+ *     mean spacing between carriers     1.656e+20 cells = 2.68 fm
+ *     the horizon                       8.078e+60 cells across
+ *     carriers met over a whole life    n_c × t₀ = 1.78
+ *
+ * A carrier moves one cell a tick, so over the age of the universe it crosses
+ * t₀ cells and meets about TWO others in its entire lifetime:
+ *
+ *     THE CROSSOVER IS WHERE A CARRIER MEETS ABOUT ONE OTHER IN THE WHOLE
+ *     HISTORY OF THE UNIVERSE. Below it, a carrier travels its life alone.
+ *
+ * which is `a₀ ≈ c/t₀` said in the model's own words, but now saying something
+ * physical rather than numerological: A CARRIER THAT NEVER MEETS ANOTHER ONE
+ * HAS NOTHING TO KEEP IT STRAIGHT.
+ *
+ * (The 2.68 fm spacing is close to the classical electron radius, 2.82 fm.
+ * Recorded and NOT claimed — the enumeration above already showed that hundreds
+ * of expressions land within a percent of anything at this game.)
+ * That is a condition ON THE CARRIER, evaluated where the carrier is, with no
+ * reference to the mass that sent it or the distance it has come — the shape
+ * the constraints demanded, a property of the place and not of the body. And it
+ * is not a length, so the low-surface-brightness objection does not touch it.
+ *
+ * CHECKED AGAINST REAL PLACES, which is the whole point:
+ *
+ *     where                      g (m/s²)   carriers a cell   per horizon
+ *     Earth's surface            9.81e+0    1.801e−50         1.46e+11
+ *     the Sun at 1 AU            5.93e−3    1.089e−53         8.80e+7
+ *     the Galaxy at 8 kpc        1.96e−10   3.599e−61         2.91
+ *     the Galaxy at 20 kpc       2.66e−11   4.884e−62         0.395
+ *     the Galaxy at 100 kpc      1.06e−12   1.946e−63         0.016
+ *
+ * The solar system runs at 10⁸ carriers per horizon; the solar circle at 2.9;
+ * 20 kpc at 0.40. THE SWITCH AT ONE SITS BETWEEN THE SOLAR CIRCLE AND 20 kpc,
+ * which is exactly where rotation curves start to depart, and the solar system
+ * is eight orders clear of it. That separation is what every earlier candidate
+ * failed to produce, and here it falls out of the counting rather than being
+ * asked for.
+ *
+ * SO THE QUESTION IN ITS SMALLEST FORM, and it is no longer circular:
+ *
+ *     WHAT DOES A CARRIER DO WHEN THERE IS LESS THAN ONE OTHER CARRIER WITHIN
+ *     REACH OF IT — AND WHY WOULD THAT BE A WANDER RATHER THAN NOTHING AT ALL?
+ *
+ * Which is answerable by SIMULATION rather than by argument, for the first time
+ * in this whole line of work: two carriers, a lattice, and whatever rule makes
+ * one of them notice the other.
+ */
+
+/**
+ * SO THE SEARCH, RUN. Every family of local rule that could bend the radial
+ * law, and how each one dies.
+ *
+ *     family                       gives         fails on
+ *     free streaming               n ∝ 1/r²      nothing — it IS Newton
+ *     scattering, λ = 1/σn         dense → 1/r   SIGN BACKWARDS, and λ = r is
+ *                                                a length
+ *     scattering, λ ∝ n            right sign    still λ = r, still a length
+ *     creation ∝ n^p, p < 2        runs away     exponential, no power law
+ *     creation ∝ n², meetings      knife edge    saturates or runs away
+ *     creation ∝ n^p, p > 2        n ∝ 1/r²      saturates back to Newton
+ *     carriers slowing, v ∝ 1/r    n ∝ 1/r  ✓    everything moves at c
+ *     effective 2D                 n ∝ 1/r  ✓    no rule offered that does it
+ *
+ * THE MODEL'S OWN SCATTERING RULE HAS THE WRONG SIGN, which is worth naming
+ * first. `through` says a carrier arriving at an occupied cell annihilates or
+ * reverses — so meetings DEFLECT, giving dense → diffusive → 1/r and thin →
+ * ballistic → 1/r². Exactly backwards. Whatever the rule is, MEETINGS MUST
+ * STRAIGHTEN rather than deflect: carriers keeping each other in line and
+ * losing it when alone.
+ *
+ * AND THE WHOLE MEAN-FREE-PATH FAMILY IS DEAD WHICHEVER WAY IT POINTS. Such a
+ * rule switches where `λ(n) = r`, but the switch must sit at a FIXED occupancy
+ * n_c, and at fixed n_c the radius `r_c = √(GM/a₀)` moves with mass — 0.3, 3.4
+ * and 34 kpc for 10⁸, 10¹⁰ and 10¹² M☉. λ(n_c) is one number and r_c is three.
+ * A rule that only sees n cannot know which to switch at. That is the sharp
+ * form of "a length is excluded".
+ *
+ * THE CREATION FAMILY LOOKED BETTER AND IS NOT. `dΦ/dr = γn^p` with `Φ ∝ r`
+ * needs p = 2 by dimensions — and p = 2 is a MEETING RATE, which is the only
+ * interaction the model has, so this looked like the answer for about a minute.
+ * But integrating it, `1/Φ = 1/Φ₀ + (γ/4π)(1/r − 1/r₀)`: as r → ∞ either 1/Φ
+ * settles on a positive constant (Φ SATURATES, back to Newton) or reaches zero
+ * at finite r (Φ RUNS AWAY). `Φ ∝ r` sits exactly on the knife edge between
+ * them and nothing puts a real source there — every p ≥ 2 lands on −2 from
+ * generic data. AND THE THRESHOLD IT DOES HAVE IS THE WRONG ONE: the split is
+ * at `Φ₀ ≈ 4πr₀/γ`, a threshold in the SOURCE STRENGTH, which would say heavy
+ * galaxies have halos and light ones do not. Tully–Fisher says all of them do.
+ *
+ * TWO SURVIVORS, AND BOTH ARE STATEMENTS RATHER THAN MECHANISMS. Carriers that
+ * SLOW as 1/r — which contradicts the model outright, since everything moving
+ * at c is what gives the metric and the checkerboard. And carriers that spread
+ * in TWO DIMENSIONS instead of three, which nothing forbids and nothing here
+ * supplies.
+ *
+ * SO THE SEARCH RETURNS ONE LIVE CANDIDATE: something that makes the carrier
+ * field effectively TWO-DIMENSIONAL where carriers are thin. Which is at least
+ * a definite question to ask of a lattice, and `FLOOR` and the fractional-
+ * dimension work at the foot of `regimes.ts` is where the vocabulary for it
+ * already exists.
+ *
+ * AND THE MASS IS STILL A SEPARATE PROBLEM. None of these produce √M — they are
+ * all rates, so they are all bilinear, so the theorem still holds over them.
+ * The radial law and the mass law are two problems and this search only ever
+ * addressed the first.
+ */
+
+/**
+ * AND THE ONE LIVE CANDIDATE HAS A CANDIDATE MECHANISM — LOCK LAYER TWO TO
+ * LAYER ONE'S SHEET.
+ *
+ * SHEET IS ALREADY THE MODEL'S TWO-DIMENSIONAL OBJECT. `WAYS = 3³ − 1 = 26` is
+ * every direction out of a cell; `SHEET = 3² − 1 = 8` is the directions in ONE
+ * PLANE through it. And `chance(m,r) = m·SHEET/shell(r)` already uses SHEET
+ * rather than WAYS — the pull was always counted through a plane. So this is
+ * not adding a structure; it is taking one the file already has and making it
+ * BIND.
+ *
+ * BUT "ALWAYS 2D" IS THE ONE THING IT CANNOT BE. A source spreading into a
+ * plane gives `n ∝ 1/r` at EVERY radius, including the solar system where 1/r²
+ * holds to a part in 10¹⁰. The locking has to be conditional, and the condition
+ * is the whole content of the proposal.
+ *
+ * AND THE NATURAL CONDITION RUNS THE RIGHT WAY ROUND, which nothing else in
+ * this search managed. A plane needs TWO independent directions to be defined:
+ *
+ *     MANY carriers met   many planes, all disagreeing → isotropic → 3D → 1/r²
+ *     ~ONE carrier met    one plane, uncontested       → locked    → 2D → 1/r
+ *
+ * Dense is Newtonian and thin is not. And the threshold is A COUNT OF MEETINGS
+ * — not a length, not a mass — which is exactly what the constraints demanded.
+ *
+ * SO IT PREDICTS a₀ WITH NOTHING FITTED. The rule is "about one meeting in a
+ * carrier's life". A carrier crosses one cell a tick, so over the age it
+ * crosses t₀ cells and meets `n·t₀` others. Set that to one:
+ *
+ *     the age                t₀ = 8.078e+60 ticks
+ *     so n_c = 1/t₀          1.238e−61 carriers a cell
+ *     and g = 4πG/SHEET·n    a₀ = 6.742e−11 m/s²
+ *     measured                    1.200e−10 m/s²
+ *     ratio                       1.780
+ *
+ * A FACTOR OF 1.78, WITH NO FREE PARAMETER. The inputs are GRAVITY and SHEET,
+ * both counted, and the age, which the frontier construction already fixes at
+ * 1/H₀. Against `BIAS/t₀`, which was 4.53 out, that is a real improvement — and
+ * unlike the expression search it comes from a STATED RULE rather than from
+ * trying combinations until one fits. (1.78 is close to √π = 1.772. NOT
+ * claimed; the enumeration that killed the last coincidence kills this one.)
+ *
+ * CHECKED WHERE IT MATTERS, in meetings over a carrier's whole life:
+ *
+ *     Earth's surface          1.46e+11    3D, Newton
+ *     the Sun at 1 AU          8.80e+7     3D, Newton
+ *     the Galaxy at 8 kpc      2.91        crossing
+ *     the Galaxy at 20 kpc     0.395       2D
+ *     the Galaxy at 100 kpc    0.0157      2D
+ *
+ * — eight orders of margin in the solar system, crossing between 8 and 20 kpc.
+ * The separation is not asked for; it falls out of the counting.
+ *
+ * AND THE MASS, WHERE THE SECOND HALF OF THE IDEA POINTS. Two dimensions alone
+ * is not enough and fails the familiar way: a source of strength M over 2πr
+ * gives `n ∝ M/r`, so `v² = const·M` and `v⁴ ∝ M²` — the third appearance of
+ * that exact failure. Two dimensions buys the RADIAL law and not the mass law,
+ * exactly as the search said it would.
+ *
+ * THE SECOND HALF IS WHERE THE MASS WOULD COME FROM: layer one's pulses both
+ * CONSTITUTE the mass and SET the sheet. If the sheet a carrier locks to is
+ * chosen by the pulse it met, and pulses carry ± which XOR, then the sheet
+ * directions inherit the cancellation — N pulses agree on a direction only to
+ * √N, so the coherently-locked fraction is √N/N and the effective source is
+ * `N·(√N/N) = √N`.
+ *
+ * THAT WOULD BE THE √M, and it would tie both halves to ONE mechanism instead
+ * of two. IT IS A SKETCH AND NOT A RESULT — nothing here shows that sheet
+ * directions XOR the way polarities do, and everything turns on that. But it is
+ * the first version in which the radial law and the mass law have the SAME
+ * cause, which is worth more than either of them separately.
+ */
+
+/**
+ * BUT THE SHEET ROTATES — so what stops it being 3D again? The objection is
+ * right, and answering it pins the mechanism down rather than breaking it.
+ *
+ * FIRST, WHAT "2D" HAS TO MEAN. A straight line is one-dimensional and lies in
+ * infinitely many planes, so confining a carrier to a plane does nothing on its
+ * own. The distinction is about SPREADING — how a beam widens as it goes:
+ *
+ *     widens in 2 transverse directions   area ∝ r²   n ∝ 1/r²   Newton
+ *     widens in 1 transverse direction    area ∝ r    n ∝ 1/r    MOND
+ *
+ * The plane in question contains the carrier's OWN outward line, so every
+ * direction on the sky is still covered — the picture stays isotropic in angle
+ * and only the widening is flattened. (Which also disposes of the obvious
+ * worry: a globally fixed plane would make halos discs and rotation curves
+ * depend on sky direction, and they do not.)
+ *
+ * AND THEN THE ROTATION MATTERS EXACTLY AS SAID: if the plane turns about the
+ * RADIAL AXIS during the journey, the widening fills both transverse directions
+ * and 1/r² comes straight back. So the sheet must hold about that axis for the
+ * whole trip.
+ *
+ * AND "RESET ONLY BY A MEETING" IS PRECISELY THAT STABILITY — and it pays a
+ * dividend nobody asked for. Meetings are independent and rare, so they are
+ * POISSON with mean `x = g/a₀` over a carrier's life:
+ *
+ *     never reset            e^{−x}       stays 2D
+ *     reset at least once    1 − e^{−x}   has sampled both directions, 3D
+ *
+ * THE FRACTION THAT HAS GONE 3D IS THE INTERPOLATION FUNCTION:
+ *
+ *     μ(x) = 1 − e^{−x}
+ *
+ *     x      1−e^{−x}   x/(1+x)   x/√(1+x²)
+ *     0.01   0.00995    0.00990   0.01000
+ *     0.5    0.39347    0.33333   0.44721
+ *     2      0.86466    0.66667   0.89443
+ *     5      0.99326    0.83333   0.98058
+ *     20     1.00000    0.95238   0.99875
+ *
+ * `μ → x` as x → 0 (deep MOND) and `μ → 1` as x → ∞ (Newton). BOTH LIMITS
+ * CORRECT AND NEITHER PUT IN — they are what "at least one reset" means when
+ * resets are Poisson. Every MOND paper picks an interpolation function by hand
+ * out of a family; this one picks itself out of the counting statistics of the
+ * mechanism, which is the difference between a fit and a derivation.
+ *
+ * AND IT IS DISTINGUISHABLE, WHICH MAKES IT A TEST. Solving `μ(g/a₀)·g = g_N`
+ * for the Milky Way's baryons:
+ *
+ *     r (kpc)   g_N/a₀   v: Poisson   simple   standard   spread
+ *     5         3.252    249.7        274.0    250.6      24.3 km/s
+ *     10        0.813    208.7        227.3    201.7      25.6 km/s
+ *     20        0.203    194.2        204.3    187.4      16.9 km/s
+ *     80        0.013    185.4        187.9    183.0       4.9 km/s
+ *
+ * The three agree deep down — they must, same limit — and differ by up to
+ * 25 km/s through the transition at 5 to 20 kpc, which is exactly where
+ * rotation curves are best measured. SPARC-quality fits do distinguish
+ * interpolation functions at that level, so this is checkable against work
+ * already published. AND THE SHAPE IS DISTINCTIVE: `1−e^{−x}` reaches Newton
+ * much faster than either standard form, so the model says the transition is
+ * SHARPER than the usual fits assume — a statement about the INNER parts of
+ * galaxies rather than the outskirts, which is the opposite end from where
+ * these arguments usually live.
+ *
+ * WHERE THE MECHANISM STANDS:
+ *
+ *     the radial law         1D transverse widening gives n ∝ 1/r
+ *     isotropy               the plane holds the carrier's own line, so every
+ *                            sky direction is covered; only the widening flattens
+ *     the rotation problem   ANSWERED — the sheet holds about the radial axis,
+ *                            and "resets only on meetings" supplies exactly that
+ *     the crossover          Poisson resets, μ(x) = 1 − e^{−x}, both limits right
+ *     a₀ itself              predicted to a factor of 1.78, nothing fitted
+ *     a new test             a sharper transition than the standard μ, at 5–20 kpc
+ *     the mass, √M           STILL OPEN — the one thing none of this touches
+ *
+ * Six of seven. The seventh is the one the theorem says needs superposition to
+ * fail, and that is a different kind of thing entirely: the sheet story is about
+ * how carriers TRAVEL, and √M is about how many of them there effectively ARE.
+ */
+
+/**
+ * HOW MANY EMITTERS, THEN — PER BODY, OR IN THE UNIVERSE? The question has a
+ * fork in it, and one side of it is already settled by data.
+ *
+ * IT IS PER BODY, AND THAT IS FORCED RATHER THAN PREFERRED:
+ *
+ *     √ over the BODY        M_eff ∝ √M     v⁴ ∝ M     ✓ Tully–Fisher
+ *     √ over the UNIVERSE    M_eff = const  v⁴ ∝ M⁰    ✗ every galaxy alike
+ *
+ * A universal count would make every galaxy rotate at the same speed whatever
+ * its mass. Tully–Fisher holds across five decades with under 0.1 dex of
+ * scatter, so the root runs over the body's own constituents.
+ *
+ * THE UNIVERSE TOTAL IS WORTH HAVING ANYWAY, and the model fixes its own rather
+ * than borrowing one:
+ *
+ *     the ball, radius c·t₀        4.23 Gpc
+ *     volume                       9.322e+78 m³
+ *     baryons at 4.2e−28 kg/m³     3.915e+51 kg
+ *     emitters, if a proton        2.341e+78
+ *     the lattice                  2.208e+183 cells, one emitter per 9.4e+104
+ *
+ * The familiar "10⁸⁰ protons" is quoted for ΛCDM's comoving observable
+ * universe, 14.3 Gpc rather than 4.2 — a volume 39× larger, giving 9.0e+79.
+ * Consistent, and a good check that the frontier cosmology's smaller ball is
+ * not quietly losing matter.
+ *
+ * AND THE NUMBER THAT FALLS OUT, WITH THE WARNING ATTACHED. `√N_universe =
+ * 1.53e+39`, beside the proton-electron electric-to-gravitational ratio of
+ * 2.27e+39 — Dirac's large numbers, in Eddington's version. RECORDED AND NOT
+ * CLAIMED: the enumeration above measured exactly how worthless this is, with
+ * 341 of 12816 expressions landing within 10% of an arbitrary target and 20
+ * within 1%. A large number near another large number is not evidence, and it
+ * is the same discipline that made `a₀ ≈ c/t₀` worth something only once a RULE
+ * produced it rather than a search.
+ *
+ * WHERE THE UNIVERSE DOES LEGITIMATELY ENTER IS NOT THE COUNT. The halo is
+ * `ρ = κ√M/r²`, and κ is fixed by a₀ — 0.10670 from the measured value, 0.07998
+ * from the predicted one, the ratio being √1.78 = 1.334, which is the same 1.78
+ * arriving under a square root. And a₀ is where t₀ lives. So:
+ *
+ *     the ROOT runs over the BODY        → which is what makes Tully–Fisher
+ *     the COEFFICIENT runs over the HORIZON → which is what makes a₀
+ *
+ * A tidier division than it looked: the mass scaling is local, the scale is
+ * cosmological, and nothing has to count the universe's emitters to get either.
+ *
+ * AND IT SAYS SOMETHING CHECKABLE ABOUT WHAT AN EMITTER IS, which is the real
+ * catch. If the root is over constituents, the answer depends on what counts as
+ * one — same galaxy, different bookkeeping:
+ *
+ *     an emitter is…    N for 7e10 M☉   √N          M_eff/M
+ *     a proton          8.322e+67       9.122e+33   1.10e−34
+ *     a Planck mass     6.395e+48       2.529e+24   3.95e−25
+ *     a solar mass      7.000e+10       2.646e+5    3.78e−6
+ *
+ * TWENTY-NINE ORDERS between "proton" and "solar mass". Since κ is fixed by a₀,
+ * CHOOSING THE EMITTER FIXES a₀ — they are the same choice made twice. So the
+ * mechanism cannot be agnostic about what an emitter is, and `mass = pulse
+ * rate` in `physics.ts` has to be turned into a COUNT before any of this is
+ * more than a shape.
+ *
+ * WHICH IS THE NEXT CONCRETE THING, and it is not "how many in the universe"
+ * but WHAT IS ONE. The model already believes there is a smallest emitter — the
+ * ceiling is one emission per cell per tick — so that is where the count has to
+ * come from, and it is a question about `physics.ts` rather than about
+ * galaxies.
+ */
+
+/**
+ * SO POSIT THE RATIO — one layer-two pulse for every x of layer one's — and
+ * check whether it works before asking why. It does not, in the obvious
+ * reading, and the way it fails says what the rule has to be.
+ *
+ * A FIXED RATIO CANNOT GIVE A ROOT, and that is one line. N pulses in, N/x out;
+ * for the output to be √N you need x = √N, so x is not a ratio at all — it
+ * grows with the body. "One in a thousand" gives N/1000, still LINEAR, and just
+ * rescales the mass. Enumerated:
+ *
+ *     rule                            scaling    v⁴ ∝ M^
+ *     1 for 1                         N¹         4.00
+ *     1 for every 1000                N¹         4.00
+ *     1 per dead-time (saturates)     N⁰         0.00
+ *     1 per coincidence of two        N²         8.00
+ *     XOR cancellation                N^½        2.00
+ *
+ * Only cancellation gives ½. Saturation gives 0, coincidence gives 2, every
+ * fixed ratio gives 1. THE ROOT IS SPECIFICALLY CANCELLATION, not a rate ratio
+ * — which is worth having, because it means the rule is forced rather than
+ * chosen.
+ *
+ * BUT THERE IS A VERSION OF THE IDEA THAT WORKS, AND IT IS A RATIO AFTER ALL —
+ * just not of COUNTS. Let the trigger be PHASE rather than tally: one layer-two
+ * pulse per 2π of accumulated layer-one phase. Phase is SIGNED, so it
+ * random-walks where a tally cannot:
+ *
+ *     N pulses, each ±δ of phase   →   accumulated |phase| ≈ δ√N
+ *     pulses out = δ√N/2π          →   √N, FROM A FIXED RULE
+ *
+ * "One per x" is exactly right; x is a phase and not a number, and the root
+ * appears because phases cancel and counts do not. The model already carries
+ * `phase` on a source, and `inStep` already turns on whether phases add — so
+ * this is vocabulary the file has rather than machinery it needs.
+ *
+ * GRANT IT AND SEE WHAT IT COSTS. With `N = M/m₀` constituents,
+ *
+ *     M₂ = √N·m₀ = √(M·m₀)      the GEOMETRIC MEAN of the body and the
+ *                                elementary emitter
+ *
+ * and layer two spreading as 1/r over a length L gives `g₂ = G√(Mm₀)/(Lr)`.
+ * Matching deep MOND, `g = √(GMa₀)/r`:
+ *
+ *     m₀ = a₀·L²/G
+ *
+ * ONE EQUATION, TWO UNKNOWNS — choosing the emitter chooses the length and vice
+ * versa. Which is the same "choosing the emitter fixes a₀" as before, but with
+ * the length now visible, and that makes it checkable:
+ *
+ *     if the emitter is…      L must be        if L is…        m₀ must be
+ *     a proton                3.05e−14 m       a cell          4.70e−70 kg
+ *     an electron             7.12e−16 m       2.68 fm         7.2 MeV
+ *     a Planck mass           1.10e−4 m        0.1 mm          1.07e+19 protons
+ *     a 0.1 eV neutrino       3.15e−19 m
+ *
+ * TWO OF THOSE ARE WORTH A SECOND LOOK AND NEITHER IS A CLAIM. A Planck-mass
+ * emitter wants L = 0.11 mm — the length short-range gravity experiments were
+ * built to probe, and the one the dark-energy density already picks out. And
+ * the 2.68 fm crossover spacing wants an emitter of 7.24 MeV. The enumeration
+ * above settled what such matches are worth, which is nothing until a rule
+ * produces one; they are recorded here so they are not rediscovered later and
+ * mistaken for evidence.
+ *
+ * AND WHAT IT ACTUALLY BUYS IS REAL. Before, κ was one fitted number with no
+ * interpretation. Now it is `m₀ = a₀L²/G`, a RELATION between two things the
+ * model already owes an opinion on:
+ *
+ *     `physics.ts` owes a smallest emitter — the one-a-tick ceiling implies one
+ *     the sheet mechanism owes a length — how far a locked plane holds
+ *
+ * Two separate debts, now ONE equation. Fix either and a₀ follows; fix a₀ and
+ * they are locked to each other. That is worth more than the ratio itself, and
+ * it is exactly what "check it works before asking why" was supposed to produce.
+ *
+ * STILL MISSING: why phases should CANCEL rather than add. Which is the same
+ * question `inStep` asks — already in this file, already measured for two
+ * identical emitters, and never once asked of a whole body.
+ */
+
+/**
+ * AND IF THE UNIVERSE REUSES ITS ABSTRACTIONS, `inStep` ALREADY ANSWERS IT.
+ *
+ * The criterion is in the file, derived and measured for two identical
+ * emitters: phases hold together only closer than a Compton wavelength,
+ * `R < 2π/m`, and beyond it they drift through every phase and cancel:
+ *
+ *     constituent          2π/m         a galaxy is … across
+ *     a proton             1.32e−15 m   7.0e+35 of them
+ *     an electron          2.43e−12 m   3.8e+32
+ *     a 0.1 eV neutrino    1.24e−5 m    7.5e+25
+ *
+ * Ten to the thirty-six Compton wavelengths. Utterly out of step, so the phases
+ * cancel completely and the surviving net is √N. THAT IS THE MODEL'S OWN
+ * CRITERION AND NOT A NEW POSTULATE — which is exactly what "the same
+ * abstraction is reused" would predict, so the reuse assumption pays for itself
+ * immediately rather than costing something.
+ *
+ * BUT THE SAME CRITERION MUST NOT APPLY TO LAYER ONE, OR NEWTON DIES. The Sun
+ * is 1.19e+57 protons; √N is 3.45e+28, so `M_eff/M = 2.9e−29`. Gravity would be
+ * ten to the minus twenty-nine of itself. So the two layers cannot read the
+ * pulse train the same way, and the resolution is economical rather than
+ * awkward:
+ *
+ *     LAYER ONE reads the COUNT    how many pulses. Unsigned. This is mass.
+ *     LAYER TWO reads the PHASE    where in the cycle. Signed. This cancels.
+ *
+ * ONE OBJECT, TWO OBSERVABLES. A pulse train has both, and this file already
+ * carries both — `mass = pulse rate` is the count and `phase` is on the Source
+ * type. So the abstraction IS shared, at the level of the thing, while the two
+ * layers differ only in which aspect of it they couple to. That is a far
+ * weaker assumption than a second set of rules.
+ *
+ * WHICH MAY MEAN THERE IS NO SECOND LAYER AT ALL. If layer two is the PHASE of
+ * layer one's pulses, it is not a new graph over the old one — it is the same
+ * graph read differently. That is the most economical version of the whole
+ * idea, and it removes the part that was hardest to justify: a second set of
+ * emitters with their own gravity. It also explains why the coupling had to be
+ * TWO-WAY, since a phase cannot be independent of the pulses carrying it.
+ *
+ * ---------------------------------------------------------------------------
+ * AND IS IT THE CHARGE OF AN ELECTRON? Probably not, and the reason is not the
+ * obvious one.
+ *
+ * THE COMPOSITION TEST IS TOO WEAK TO SETTLE IT, which is worth knowing before
+ * relying on it. If the count were of CHARGES rather than of mass, what matters
+ * is charges per kilogram — and ordinary matter is nearly uniform in that:
+ *
+ *     composition             charges/kg   against hydrogen
+ *     pure hydrogen           1.196e+27    1.0000
+ *     Y = 0.24, primordial    1.053e+27    0.8808
+ *     Y = 0.28, enriched      1.029e+27    0.8609
+ *     pure helium             6.018e+26    0.5033
+ *
+ * Across the real range of helium fractions the spread is 2.3%, which is 1.15%
+ * in √N and 0.57% in v — twenty times under Tully–Fisher's own scatter. So
+ * composition cannot tell charge from mass, because in ordinary matter they are
+ * proportional to better than a percent.
+ *
+ * WHAT KILLS IT IS THE OPPOSITE END. If layer two is CHARGE, a body of NEUTRAL
+ * constituents gets no halo at all. But the most dark-dominated systems known —
+ * clusters and dwarf spheroidals — show the LARGEST discrepancies, and they are
+ * the ones with the fewest charges per unit mass. The mechanism would predict
+ * exactly the reverse ordering.
+ *
+ * SO LAYER TWO IS PROBABLY NOT ELECTRIC CHARGE, and the phase reading is better
+ * on this point too: A PHASE BELONGS TO EVERY PULSE, so every gram of anything
+ * has one, charged or not. The count-versus-phase split gives the halo to all
+ * matter equally, which is what is observed.
+ */
+
+/**
+ * AND THEN IT WAS TESTED, WHICH RETIRES HALF OF IT.
+ *
+ * TEST A — DO THE MODEL'S OWN PHASES CANCEL TO √N? Not assumed random: `inStep`
+ * says two emitters differ in phase by `ω·Δr/c = m·Δr`. So N emitters at random
+ * places in a ball of radius R, each given the phase its position implies,
+ * summed:
+ *
+ *     m·R      N       |Σ| measured   √N        N          which
+ *     1.0e−2   1e+3    1.000e+3       3.16e+1   1.00e+3    N
+ *     1.0e+0   1e+5    9.814e+4       3.16e+2   1.00e+5    N
+ *     6.3e+0   1e+5    5.012e+4       3.16e+2   1.00e+5    between
+ *     1.0e+4   1e+3    3.278e+1       3.16e+1   1.00e+3    √N
+ *     1.0e+4   1e+5    3.164e+2       3.16e+2   1.00e+5    √N
+ *
+ * COHERENT BELOW A COMPTON WAVELENGTH, CANCELLING TO √N ABOVE IT, with the
+ * crossover at `m·R ≈ 2π` exactly where `inStep` puts it. The √M half is real,
+ * and it is not an assumption about randomness — it is what `m·Δr` does once Δr
+ * covers many wavelengths.
+ *
+ * TEST B — DOES LOCKING TO A PLANE CHANGE THE RADIAL LAW? IT DOES NOT.
+ *
+ * (The first run of this had a bug worth recording: the per-step turn was
+ * 0.25 rad, so after 300 steps every case had diffused through 4.3 rad and all
+ * four came out identical. The regime was set by the turn angle, not by the
+ * locking. Done properly:)
+ *
+ *     turn/step   persistence      LOCKED (1 dof)   FREE (2 dof)   difference
+ *     0.002       250000 steps     −2.000           −2.000         0.000
+ *     0.010       10000            −2.000           −1.998         0.002
+ *     0.050       400              −1.964           −1.929         0.034
+ *
+ * LOCKED AND FREE AGREE TO THREE DECIMAL PLACES. The number of transverse
+ * directions makes no difference to the radial law at all. (A fourth row at
+ * turn = 0.2 gave −3.2 and −5.4; that is a truncation artefact — the walkers do
+ * not reach the outer bins, so the fit runs off the end. The diffusive slope
+ * was not measured cleanly here and is not claimed.)
+ *
+ * AND THE REASON IS FLUX CONSERVATION, WHICH SIDEWAYS WANDERING CANNOT BEAT. N
+ * carriers leave, N cross every sphere, the sphere has area 4πr², so
+ * `n = N/4πr²c` whatever they do transversely. The 1/r appears only when the
+ * walk becomes DIFFUSIVE, because then radial progress slows as `dr/dt = cλ/2r`
+ * and carriers pile up. Slowing was always one of the two ways to get 1/r —
+ * diffusion is what supplies it, and diffusion needs MANY resets, not few.
+ *
+ * SO THE SHEET CLAIM WAS WRONG, AND IT IS WORTH SAYING WHERE. "The plane holds
+ * the carrier's own line, so only the widening flattens" does not give 1/r;
+ * widening does not touch the radial profile. The permutation search two steps
+ * earlier had this right — dense → 1/r, thin → 1/r², SIGN BACKWARDS — and the
+ * sheet story talked its way out of a correct result. The simulation puts it
+ * back.
+ *
+ * WHAT THAT RETIRES: the 2D transport mechanism, and with it the a₀ prediction
+ * that rode on it (6.742e−11, the factor of 1.78) and the derived interpolation
+ * function `μ(x) = 1 − e^{−x}`, both of which assumed the locking worked. They
+ * are kept above as a route that was tried, not as results.
+ *
+ * WHAT SURVIVES: TEST A. Phase cancellation is real, measured, and follows from
+ * the model's own `inStep` rather than from a new assumption — so the √M half
+ * stands on its own. The radial law is unexplained again, and the obstruction
+ * is exactly what it was before any of this: `n ∝ 1/r` needs the carriers to
+ * slow.
+ */
+
+/**
+ * — AND "EVERYTHING MOVES AT c" WAS TOO BLUNT, WHICH REOPENS ALL OF IT.
+ *
+ * The file rejects IDLING for massive particles: moving on a fraction β of
+ * ticks gives `(1−β)` where relativity wants `√((1−β)(1+β))`, and picks a
+ * frame. But the ZIGZAG says a thing steps EVERY tick and its NET speed is the
+ * imbalance, and that "the updates ARE the reversals". So a net drift below c
+ * is not forbidden — it is this model's own account of what speed IS. Saying
+ * carriers cannot slow was quoting half the file at the other half.
+ *
+ * AND IT MATTERS BECAUSE FLUX CONSERVATION READS `Φ = 4πr²·n·v`. With v
+ * constant, `n ∝ 1/r²` and no amount of wandering changes it — which is what
+ * Test B showed. WITH v VARYING, the whole question reopens, and what is needed
+ * is `v ∝ 1/r`.
+ *
+ * AND THE MODEL HAS A REASON FOR THE DRIFT TO DEPEND ON DENSITY. The chain is
+ * all pieces already here:
+ *
+ *     speed is the share of ticks spent moving rather than updating
+ *     a carrier accumulates internal state (phase) while travelling free
+ *     `through` says a MEETING resets it
+ *     so the accumulated state ∝ distance since the last meeting = λ = 1/σn
+ *     update cost ∝ accumulated state, so the moving share ∝ 1/λ = σn
+ *
+ *     ⇒   v = c·min(1, n/n_c)
+ *
+ * Dense, and the budget is capped at c. Thin, and the carrier spends most of
+ * its ticks on itself and crawls. "CARRIERS KEEP EACH OTHER MOVING" — the same
+ * intuition as the sheet story, finally in the right variable.
+ *
+ * SOLVE IT AND BOTH BRANCHES COME OUT RIGHT:
+ *
+ *     DENSE, n > n_c:   v = c        ⇒ n = Φ/(4πr²c)       ∝ 1/r²   NEWTON
+ *     THIN,  n < n_c:   v = cn/n_c   ⇒ n = √(Φn_c/4πc)/r   ∝ 1/r    MOND
+ *
+ * AND LOOK AT THE MASS. In the thin branch `n ∝ √Φ`, and `Φ ∝ M`:
+ *
+ *     n ∝ √M/r    ⇒   g ∝ √M/r   ⇒   v_rot⁴ ∝ M    TULLY–FISHER
+ *
+ * BOTH HALVES FROM ONE MECHANISM, and the √M is not the phase cancellation at
+ * all — it falls out because FLUX CONSERVATION BECOMES QUADRATIC IN n once the
+ * speed is proportional to n. That is the non-linearity the theorem demanded,
+ * and it lives in the TRANSPORT rather than in the source, which is why every
+ * earlier attempt to put it in the source failed.
+ *
+ * AND THE SWITCH IS AT `n = n_c`, A FIXED OCCUPANCY — hence at fixed g, since
+ * `g ∝ n`. Not a length, not a mass, not a count of constituents. Every
+ * requirement the search accumulated, at once.
+ *
+ * MEASURED, by integrating the transport rather than trusting the algebra:
+ *
+ *     Φ (∝ mass)   slope inner   slope outer   n at r = 100
+ *     1            −2.0000       −1.0000       8.921e−5
+ *     10           −2.0000       −1.0000       2.821e−4
+ *     100          −2.0000        —            8.921e−4
+ *
+ * −2.0000 inside and −1.0000 outside, and the outer density against √Φ comes to
+ * 10.0000 for a hundredfold mass, against √100 = 10. Exact. (The blank cells
+ * are a windowing artefact: at larger Φ the crossover radius runs past the grid
+ * so the outer fit window is empty.)
+ *
+ * WHAT IT COSTS, BECAUSE SOMETHING HAS TO. A carrier that crawls is a carrier
+ * that is LATE. At 20 kpc, `n/n_c ≈ 0.4`, so the drift is 0.4c and a galaxy's
+ * crossing time goes from 98 to 244 kyr — harmless. Further out it is not: at
+ * `n/n_c = 10⁻³` the drift is 10⁻³c and a cluster-scale field takes 10⁷ years
+ * to establish. THAT IS A REAL PREDICTION — gravity should LAG in the deep-field
+ * regime — and merging systems are where it would show.
+ *
+ * AND IT IS NOT RELATIVITY BROKEN. The carriers still step one cell a tick;
+ * what falls is the NET drift, exactly as a massive particle's does in the
+ * zigzag. Nothing exceeds c, and nothing picks a frame, since the density
+ * setting the drift is a scalar.
+ *
+ * WHAT IS STILL OWED IS ONE LINK: that the update cost goes as the accumulated
+ * phase. Everything above hangs on it, and it is the only part not already in
+ * the file. Which is a considerably better position than "no mechanism at all",
+ * and it is a question about `physics.ts` — what a tick is spent on — rather
+ * than about galaxies.
+ */
+
+/**
+ * AND CHASING THAT LINK TURNS UP A SIGN CONFLICT IN THE CHAIN ABOVE, WHICH HAS
+ * TO BE SAID BEFORE ANYTHING ELSE.
+ *
+ * The chain used "a MEETING resets the accumulated state, so meetings free up
+ * ticks and the carrier moves faster". But `through` — the model's own rule,
+ * and a measured one — says a charge arriving at an occupied cell ANNIHILATES
+ * OR REVERSES. A reversal does not clear internal state; it turns the carrier
+ * round, which SLOWS the net drift:
+ *
+ *     `through`    more meetings → more reversals → v FALLS with n
+ *     the chain    more meetings → state cleared  → v RISES with n
+ *
+ * And `v ∝ n` is exactly what the √M depends on. So the mechanism as written
+ * contradicts the file on the DIRECTION of the effect. That is a real problem
+ * rather than a detail, and it is the sort that would have gone unnoticed for a
+ * long time if the link had been left as an IOU.
+ *
+ * BUT THERE IS A CONNECTION WITH THE RIGHT SIGN, AND IT IS ALREADY HERE:
+ * `inStep`. It says emitters closer than a Compton wavelength hold a common
+ * phase, and further apart drift through every phase independently. READ AS A
+ * BUDGET RATHER THAN AS AN INTERFERENCE CONDITION:
+ *
+ *     IN STEP       one phase shared between many carriers — the update is paid
+ *                   ONCE, and each is free to spend its ticks moving. DENSE → FAST.
+ *     OUT OF STEP   each carrier carries its own phase and pays its own update
+ *                   every tick. THIN → SLOW.
+ *
+ * Right sign, no new rule, and it does not fight `through`: reversals still
+ * happen, but what sets the drift here is what a tick is SPENT ON rather than
+ * which way the step points. Those are two different bookkeepings of the same
+ * carrier and they can both hold.
+ *
+ * AND IT MAKES THE CROSSOVER A COMPTON WAVELENGTH — a fixed DENSITY, which is
+ * the shape every earlier candidate failed to have:
+ *
+ *     in step  ⇔  spacing < 2π/m  ⇔  n > (m/2π)³      so n_c = (m/2π)³
+ *
+ * WHICH FIXES THE EMITTER, AND THAT IS THE BILL:
+ *
+ *     required n_c            2.203e−61 per cell
+ *     ⇒ m = 2π·n_c^⅓          5.150e−29 kg = 28.9 MeV/c²
+ *
+ *     particle    mass (MeV)   n_c it gives   against needed
+ *     electron      0.51       1.219e−66      5.5e−6
+ *     muon        105.66       1.078e−59      4.9e+1
+ *     pion        134.98       2.247e−59      1.0e+2
+ *     proton      938.26       7.548e−57      3.4e+4
+ *
+ * THE PROTON IS 3.4·10⁴ TOO DENSE AND THE ELECTRON 5.5·10⁻⁶ TOO THIN, and what
+ * the mechanism wants sits between them at about 29 MeV — WHICH IS NOT A
+ * PARTICLE. The muon and the pion are the nearest things and both are four to
+ * eight times too heavy.
+ *
+ * WHICH IS THE GOOD KIND OF FAILURE:
+ *
+ *     the sign              FIXED — `inStep` gives dense → fast, where the
+ *                           meeting story gave dense → slow and fought `through`
+ *     the crossover shape   FIXED — a Compton wavelength is a fixed density
+ *     no new rule           FIXED — `inStep` was derived and measured already;
+ *                           this only reads it as a budget
+ *     the number            NOT FIXED — it wants a 29 MeV emitter, and there
+ *                           is not one
+ *
+ * Three of the four structural requirements are met by a rule already in the
+ * file, and the fourth is a single number wrong by a stateable amount. That
+ * says exactly what to look for: EITHER an emitter near 29 MeV, OR a reason the
+ * relevant Compton wavelength is not the constituent's own.
+ *
+ * AND THERE IS AN OBVIOUS PLACE TO LOOK FOR THE SECOND. `inStep` takes the mass
+ * of what is EMITTING. If the phase that matters belongs to the CARRIER rather
+ * than to the source, then 29 MeV is a statement about the carrier — and this
+ * model has never assigned the carrier a mass at all. The pull is carried by
+ * charges whose own rate was never fixed, which makes this a GAP rather than a
+ * contradiction, and the first thing `physics.ts` would have to answer.
+ */
+
+/**
+ * SO DERIVE n_c WITHOUT LOOKING AT a₀ — and first, A CORRECTION: THE a₀
+ * PREDICTION WAS OVER-RETRACTED.
+ *
+ * It was written off along with the 2D transport, but look at what it actually
+ * used: `g ∝ n` with the constant `4πG/SHEET`, which is the geometry of
+ * emission and mentions no transport at all; and `n_c = 1/t₀`, one meeting per
+ * carrier lifetime, which mentions none either. THE TRANSPORT FAILED AND THE
+ * PREDICTION DOES NOT DEPEND ON IT. Retracting both together was too broad.
+ *
+ * WHAT INPUTS EXIST AT ALL — this is the whole list, and a derivation can use
+ * nothing else:
+ *
+ *     counted      SHEET = 8, WAYS = 26, BITE = 1, G_LATTICE = 0.0623515
+ *     units        cell = ℓ_P, tick = t_P, fixed by the calibration
+ *     dynamical    t₀ = 8.078e+60 ticks — an AGE, not a constant
+ *
+ * SO ENUMERATE WHAT THEY CAN BUILD:
+ *
+ *     route                                 n_c           against needed
+ *     the ceiling, one emission a tick      1.000e+0      4.5e+60
+ *     the floor, one emission per age       7.649e−186    3.5e−125
+ *     ONE MEETING PER CARRIER LIFETIME      1.238e−61     5.6e−1
+ *     what a₀ requires                      2.203e−61     1
+ *
+ * ONLY ONE ROUTE LANDS. The ceiling is 61 orders too dense, the floor 184
+ * orders too thin, and "one meeting per lifetime" is out by 1.78. That is not a
+ * fit surviving among many — IT IS THE ONLY CANDIDATE THE AVAILABLE INGREDIENTS
+ * CAN EVEN BUILD AT THE RIGHT SIZE, which is the same kind of argument the rest
+ * of this file makes and the opposite of the expression search.
+ *
+ * THE DERIVATION, WITH NO DATA IN IT:
+ *
+ *     a carrier crosses one cell a tick and lives t₀ ticks
+ *     it sweeps BITE cells of cross-section, so it meets n·BITE·t₀ others
+ *     the crossover is where that count is ONE — the boundary between a carrier
+ *       whose history contains an interaction and one whose does not
+ *     ⇒ n_c = 1/(BITE·t₀)
+ *     and g = (4π·G/SHEET)·n from the emission geometry
+ *     ⇒ a₀ = 4π·G/(SHEET·t₀) = 6.742e−11 m/s²,  against 1.200e−10 measured
+ *
+ * AND IT THEN PREDICTS THE CARRIER MASS, which was the open number. `inStep`
+ * wants `n_c = (m/2π)³`; setting the two equal,
+ *
+ *     m = 2π·(1/t₀)^⅓ = 3.131e−20 lattice units = 23.8 MeV/c²
+ *     against the 28.9 MeV that a₀ demands — a ratio of 1.212
+ *
+ * TWO INDEPENDENT ROUTES TO THE SAME NUMBER, AGREEING TO 21%. One counts
+ * meetings over a lifetime; the other asks when carriers fall out of step. They
+ * did not have to agree at all, and this is the first time in this line of work
+ * that two derivations have met.
+ *
+ * THE BILLS, AND THEY ARE SPECIFIC:
+ *
+ *   THE 1.78 IS UNCOUNTED. And it is the SAME 1.78 at every step, so it is one
+ *   missing factor rather than several — somewhere a 2, a π or a √π is not
+ *   being counted.
+ *
+ *   t₀ IS NOT A CONSTANT, so `a₀ ∝ 1/t` and the carrier mass goes as `t^{−⅓}`.
+ *   A mass that changes with the age is a strange object, and it is the same
+ *   prediction already flagged: rotation curves at z ~ 1–2 should differ, and
+ *   the reported ones go the wrong way.
+ *
+ *   24 MeV IS NOT A PARTICLE. The muon is 106 and the pion 135. Either
+ *   something sits there, or the Compton wavelength that matters is not a
+ *   particle's at all.
+ *
+ * WHICH IS THE ANSWER TO "HOW, WITHOUT DATA": enumerate the inputs the model
+ * actually has — four counted numbers, two units, one age — and see which
+ * combinations can reach the size at all. Only one can.
+ */
+
+/**
+ * AND THE 1.78 IS MOSTLY COUNTABLE — it was never one number.
+ *
+ * The count was "a carrier sweeps BITE cells a tick for t₀ ticks, so it meets
+ * n·BITE·t₀ others; set that to one". TWO THINGS IN IT WERE LEFT AT ONE AND
+ * SHOULD NOT HAVE BEEN, and both are already derived elsewhere in this file:
+ *
+ *   `share`      only OPPOSITE polarities annihilate; `opposed` decides, and
+ *                pairing at random gives ½. `reach`, `shows` and `met` all
+ *                carry it already.
+ *   ⟨|v_rel|⟩    both things move at c, so the rate carries their RELATIVE
+ *                speed: `½∫√(2−2cosθ)sinθ dθ = 4/3` for isotropic directions,
+ *                which is the same average that corrected the screening
+ *                geometry at the head of `shows`.
+ *
+ * They pull OPPOSITE WAYS — fewer meetings means the threshold sits at a higher
+ * density and a₀ goes up; a larger relative speed means more meetings and a₀
+ * goes down:
+ *
+ *     counted in            n_c          a₀ (m/s²)   against measured
+ *     nothing               1.238e−61    6.742e−11   0.562
+ *     `share` = ½           2.476e−61    1.348e−10   1.124
+ *     ⟨|v_rel|⟩ = 4/3       9.285e−62    5.057e−11   0.421
+ *     both                  1.857e−61    1.011e−10   0.843
+ *     measured                           1.200e−10   1.000
+ *
+ * AND THE RELATIVE-SPEED FACTOR IS NOT ACTUALLY 4/3 HERE, which is the
+ * interesting part rather than a nuisance. 4/3 is the ISOTROPIC average, but a
+ * source's own carriers all stream radially outward — nearly COMOVING, and two
+ * things moving the same way at c never meet. So the true factor sits between 1
+ * (an isotropic ambient sea) and 4/3 (full average), and below 1 if what a
+ * carrier mostly runs into is its own source's outflow. With `share` counted:
+ *
+ *     a₀ ∈ [1.011e−10, 1.348e−10],  measured 1.200e−10 — INSIDE, 56% across
+ *
+ * SO THE 1.78 WAS A FACTOR OF 2 FROM `share` AND A VELOCITY FACTOR THAT IS
+ * BRACKETED RATHER THAN KNOWN. Counting the first and bracketing the second
+ * puts the measured value inside, which is as far as counting goes until "what
+ * does a carrier meet" is settled.
+ *
+ * AND IT TIGHTENS THE TWO ROUTES AGAINST EACH OTHER, which is the better test
+ * because neither involves a₀. Each n_c predicts a carrier mass through
+ * `n_c = (m/2π)³`:
+ *
+ *     counted in         carrier mass   against the 28.9 MeV a₀ wants
+ *     nothing            23.8 MeV       1.212
+ *     `share` = ½        30.0 MeV       0.962
+ *     both               27.3 MeV       1.059
+ *
+ * BARE, THE TWO ROUTES DISAGREED BY 21%; WITH `share` COUNTED THEY AGREE TO 4%,
+ * and with both they straddle. Two derivations that share no steps now meet
+ * inside the uncertainty of either.
+ *
+ * WHAT IS FIXED AND WHAT IS NOT:
+ *
+ *     the 1.78                 mostly counted — a 2 from `share`, the rest
+ *                              bracketed, with the measurement inside
+ *     the two routes           tightened from 21% apart to 4%
+ *     WHAT A CARRIER MEETS     OPEN, and now the only thing between this and a
+ *                              number. Its own source's outflow (comoving,
+ *                              suppressed) or an ambient sea (isotropic, 4/3)?
+ *                              A question about `field.ts`, answerable by
+ *                              simulation
+ *     t₀ is not a constant     unfixable — `a₀ ∝ 1/t` is a prediction and the
+ *                              high-redshift curves are the test
+ *     ~28 MeV                  unfixed. The bracket is 27–30 MeV and nothing
+ *                              sits there
+ *
+ * AND A DISCIPLINE NOTE. `(4/3)² = 1.7778` against the observed 1.7799, a match
+ * to 0.1%. IT IS NOT CLAIMED AND SHOULD NOT BE: a₀ itself is quoted at ~10%, so
+ * 0.1% is far inside the noise, and √π = 1.772 fits just as well. The two
+ * factors above are worth having because each was DERIVED SOMEWHERE ELSE in
+ * this file — not because their product lands well.
+ */
+
+/**
+ * SO SIMULATE THE LAST OPEN THING — WHAT DOES A CARRIER MEET? — AND IT BREAKS
+ * THE MECHANISM. Which is what the simulation was for.
+ *
+ * THE SUPPRESSION IS REAL AND STRONG. A source of radius R, a field point at r,
+ * two carriers arriving there from random parts of it, each moving along
+ * `(P−S)/|P−S|` weighted by the flux that part contributes:
+ *
+ *     r/R      ⟨|v_rel|⟩/c    against isotropic 4/3
+ *     1.5      0.55974        4.2e−1
+ *     5        0.16197        1.2e−1
+ *     30       0.02692        2.0e−2
+ *     100      0.00808        6.1e−3
+ *
+ * It falls as R/r exactly as the geometry says: far out, the source subtends a
+ * small angle and its own carriers all go the same way. A POINT SOURCE IS THE
+ * LIMIT — its carriers are perfectly comoving and never meet each other at all.
+ *
+ * BUT A CARRIER DOES NOT ONLY MEET THOSE. The rest of the universe is emitting
+ * too, and that sea arrives isotropically:
+ *
+ *     the ambient sea, ρ·SHEET·R_h        1.732e−60 per cell
+ *
+ *     where                    the galaxy's own n    against the sea
+ *     the Sun at 1 AU          1.089e−53             6.3e+6
+ *     the Galaxy at 8 kpc      3.599e−61             2.1e−1
+ *     the Galaxy at 20 kpc     4.884e−62             2.8e−2
+ *     the Galaxy at 100 kpc    1.946e−63             1.1e−3
+ *
+ * Inside the solar system the local field is a million times the sea; by 8 kpc
+ * they are comparable; by 20 kpc THE SEA IS THIRTY-FIVE TIMES DENSER than the
+ * galaxy's own carriers.
+ *
+ * AND THAT BREAKS IT. The crossover wants `n_c = 2.476e−61` and the sea alone
+ * is `1.732e−60` — SEVEN TIMES ABOVE IT, EVERYWHERE. A carrier anywhere in the
+ * universe meets 7.0 others in its life from the background alone, so the "has
+ * it met anything" switch is thrown in every direction at every radius. No MOND
+ * regime; Newton everywhere.
+ *
+ * AND HERE IS THE CONFLATION THAT HID IT, which is the real lesson: `g ∝ n` is
+ * about the SOURCE'S OWN carriers, while the meeting rate is about ALL of them.
+ * Two different densities, one symbol. The crossover was supposed to depend on
+ * the source, so that it happens at a radius — but the meeting rate does not
+ * depend on the source at all, so it happens nowhere, or everywhere.
+ *
+ * WHAT WOULD HAVE TO BE TRUE. Either the horizon is 7× smaller than it is, or
+ * distant matter's carriers do not count — and `reach` is exactly such a
+ * reason, screening the sea with a Yukawa length of 1.6 Gpc. Redone with the
+ * cut-off, `∫ρ·SHEET·e^{−r/λ}dr = ρ·SHEET·λ = 6.549e−61`, against `n_c =
+ * 2.476e−61` — a ratio of 2.65. STILL ABOVE, but only by a factor of two-ish,
+ * which is inside the uncertainty of everything feeding it.
+ *
+ * SO THE VERDICT IS MARGINAL RATHER THAN DEAD, and it turns on `reach` — a
+ * length this file derived for entirely unrelated reasons, and called its one
+ * genuine prediction. The mechanism does not have a comfortable MOND regime; it
+ * has one that switches on barely, and only because gravity's own range cuts
+ * the sea off. That is a much weaker claim than the section above it makes, and
+ * it is what the simulation actually supports.
+ *
+ * (And the alternative branch — that only the source's own carriers count, so
+ * the crossover IS radial — fails differently: the rate then goes as
+ * `n·(R/r) ∝ R/r³`, giving a crossover radius ∝ M^⅓ rather than √M, so
+ * Tully–Fisher goes wrong again. Neither branch works, for different reasons.)
+ */
+
 /**
  * WHAT A BLACK HOLE IS, IF THERE ARE NO HORIZONS.
  *
@@ -2815,9 +4393,12 @@ export const REACHES = Math.sqrt(
  * R = 1.384 cells:
  *
  *     R (cells)   screened R/R_s   unscreened R/R_s   u = GM/R
- *     1.38        2.5525           1.005e+0           4.974e−1
- *     10          2.5525           1.914e−2           2.612e+1
- *     1e+6        2.5525           1.914e−12          2.612e+11
+ *     1.38        0.7219           1.005e+0           4.974e−1
+ *     10          0.7219           1.914e−2           2.612e+1
+ *     1e+6        0.7219           1.914e−12          2.612e+11
+ *
+ * (the screened column was 2.5525 before the geometry of `shows` was
+ * corrected; it is now inside one, which is the reversal recorded above)
  *
  * and u grows without bound, so `e^−u` becomes arbitrarily extreme:
  *
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 29192a4..73c0ecf 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -2,6 +2,7 @@ import { Fragment, ReactNode, useEffect, useRef, useState } from "react";
 
 import { GRAIN } from "./gravity";
 import { Echoes } from "./echoes";
+import { Rotation, Split } from "./rotation";
 import { Overlay, Routes, Seam, Shadows } from "./shadow";
 
 /**
@@ -2367,9 +2368,49 @@ export const Law = () => {
 
     <Note>
       The missing dark matter is what saved the age, so it is worth asking
-      whether the same construction can pay it back. State the target so it can
-      be failed: flat rotation curves want <V>v</V><Sup>2</Sup> = <V>GM</V>(<V>r</V>)/<V>r</V>{' '}
-      constant, so <V>M</V> ∝ <V>r</V>, so{' '}
+      whether the same construction can pay it back. And rather than argue it,
+      run it: below is the Milky Way put through the model’s own force law,{' '}
+      <b style={{ color: INK }}>summed directly over its baryons, ring by ring
+        and angle by angle</b> — no shell theorem, no enclosed-mass shortcut,
+      so nothing about what the outside does is assumed.
+    </Note>
+
+    <Rotation />
+
+    <Note>
+      Every other term the model owns is checked and negligible: <i>reach</i>{' '}
+      costs 2·10<Sup>−3</Sup>% at 30 kpc, <i>carry</i> 1.1·10<Sup>−6</Sup> at
+      220 km/s, <i>shows</i> nothing at all — a galaxy is transparent. So the
+      model’s prediction here is Newton on the baryons, and it{' '}
+      <b style={{ color: INK }}>peaks at 192 km/s and falls to 104 by 30 kpc</b>{' '}
+      where the disc is measured flat at 220. The gap to close at 20 kpc is
+      +195%; the largest correction the model has is five orders under that.
+      There is no dial in it that reaches.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So does the mass outside the orbit cancel?</b>{' '}
+      It does not — a disc is not a sphere, and only for a sphere is an exterior
+      shell worth exactly nothing. But the sign runs the other way from the
+      intuition, and the sum says so directly:
+    </Note>
+
+    <Split />
+
+    <Note>
+      The exterior pulls <b style={{ color: INK }}>outward</b>, because the near
+      arc of an exterior ring is closer than the far arc and wins the inverse
+      square. It takes 27% off the pull at 2 kpc and 4% off at 30. So the
+      missing gravity cannot come from the outside failing to cancel:{' '}
+      <b style={{ color: INK }}>the outside is already counted, already fails to
+        cancel, and already subtracts</b>. The curve above is what is left after
+      that is included.
+    </Note>
+
+    <Note>
+      Which fixes the target so it can be failed: flat rotation curves want{' '}
+      <V>v</V><Sup>2</Sup> = <V>GM</V>(<V>r</V>)/<V>r</V> constant, so{' '}
+      <V>M</V> ∝ <V>r</V>, so{' '}
       <b style={{ color: INK }}><V>ρ</V> ∝ 1/<V>r</V><Sup>2</Sup>, and the extra
         pull is <i>inward</i></b>. Both halves matter.
     </Note>
@@ -2377,12 +2418,13 @@ export const Law = () => {
     <Rows of={[
       [<span style={{ color: BORROWED }}>the shell theorem</span>,
         <>Space made in a shell <i>outside</i> an orbit has no inside — a
-          uniform shell has no preferred direction within it, so it moves
-          nothing there. Only space made <i>inside</i> the orbit acts, and it
-          pushes <b style={{ color: INK }}>outward</b>. For a circular orbit{' '}
-          <V>v</V><Sup>2</Sup>/<V>r</V> = <V>g</V> − <V>g</V><Sub>push</Sub>, so
-          an outward push <i>lowers</i> the speed a star can hold. Dark matter
-          is missing centripetal force; this supplies the opposite.</>],
+          uniform <i>spherical</i> shell has no preferred direction within it.
+          A disc does, and as measured above it points{' '}
+          <b style={{ color: INK }}>outward</b>. Either way the sign is wrong:
+          for a circular orbit <V>v</V><Sup>2</Sup>/<V>r</V> = <V>g</V> −{' '}
+          <V>g</V><Sub>push</Sub>, so an outward push <i>lowers</i> the speed a
+          star can hold. Dark matter is missing centripetal force; this supplies
+          the opposite.</>],
       [<span style={{ color: BORROWED }}>and it undoes the cosmology</span>,
         <>The whole virtue of the frontier was that{' '}
           <i>the bulk makes no space</i> — which is what dissolved four
@@ -2491,6 +2533,67 @@ export const Law = () => {
       measured, it is right, and it is far too small.
     </Note>
 
+    <Note>
+      <b style={{ color: INK }}>And a third try: more space gathers around
+        mass, so the outskirts have less of it.</b> The model already says the
+      first half — that is <i>thickness</i>,{' '}
+      <V>B</V> = <V>e</V><Sup>+2<V>u</V></Sup>, more proper length per unit
+      coordinate exactly where the node is folded. It is not a missing
+      ingredient; it is the metric, derived rather than borrowed, and it is what
+      gives six sixths of Mercury’s perihelion advance. At 20 kpc it is worth{' '}
+      √<V>B</V> − 1 = 1.7·10<Sup>−7</Sup> — one part in six million, far under
+      the width of the line on the plot above.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So stop testing mechanisms one at a time.</b>{' '}
+      Every idea has died on a number rather than a story, and it has been the
+      same number each time. Enumerate instead: every dimensionless quantity the
+      model can build at 20 kpc in a galaxy, out of <V>G</V>, <V>c</V>, the
+      cell, the tick, the age, and the galaxy’s own <V>M</V>, <V>r</V> and{' '}
+      <V>v</V>. Closing the gap needs +195%, which needs an{' '}
+      <V>O</V>(1) number.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}><V>GM</V>/<V>rc</V><Sup>2</Sup></span>,
+        <>how folded the place is — 1.70·10<Sup>−7</Sup></>],
+      [<span style={{ color: FAINT }}><V>v</V><Sup>2</Sup>/<V>c</V><Sup>2</Sup></span>,
+        <>how fast the star goes — 5.39·10<Sup>−7</Sup></>],
+      [<span style={{ color: FAINT }}><V>r</V>/<V>λ</V><Sub>reach</Sub></span>,
+        <>against gravity’s Yukawa range — 1.25·10<Sup>−5</Sup></>],
+      [<span style={{ color: FAINT }}><V>r</V>/<V>ct</V><Sub>0</Sub></span>,
+        <>against the horizon — 4.73·10<Sup>−6</Sup></>],
+      [<span style={{ color: FAINT }}>ℓ<Sub>P</Sub>/<V>r</V>, <V>t</V><Sub>P</Sub><V>v</V>/<V>r</V></span>,
+        <>the lattice spacing and the tick — 10<Sup>−56</Sup>, 10<Sup>−59</Sup></>],
+      [<span style={{ color: DERIVED }}><V>g·t</V><Sub>0</Sub>/<V>c</V></span>,
+        <>the pull against <V>c</V> per age —{' '}
+          <b style={{ color: INK }}>3.86·10<Sup>−2</Sup></b></>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>And that is the whole list.</b> Seven of the
+      eight sit between 10<Sup>−5</Sup> and 10<Sup>−56</Sup>. Exactly one is
+      anywhere near unity, and it is the last. So{' '}
+      <b style={{ color: INK }}>no mechanism built from the others can work</b>,
+      whatever its story, because it has nothing to make an{' '}
+      <V>O</V>(1) correction out of — which closes the whole family at once
+      instead of one idea at a time, and is worth more than any of the
+      individual tests.
+    </Note>
+
+    <Note>
+      The survivor is an <i>acceleration</i>, measured against <V>c</V> per age.
+      Set it to one and it reads{' '}
+      <V>c</V>/<V>t</V><Sub>0</Sub> = 6.88·10<Sup>−10</Sup> m/s², against a
+      measured <V>a</V><Sub>0</Sub> = 1.20·10<Sup>−10</Sup> —{' '}
+      <V>a</V><Sub>0</Sub><V>t</V><Sub>0</Sub>/<V>c</V> = 0.174 against
+      1/2π = 0.159.{' '}
+      <b style={{ color: INK }}>The one number this model has at galactic scale
+        is the MOND scale, to 2π.</b> Not a mechanism, not a derivation — but
+      the search space is now one-dimensional.
+    </Note>
+
     <Note>
       What would have to be shown: <i>spend</i> gives accel = <K>BIAS</K> ×
       (annihilation rate), and a rate below one meeting per{' '}
@@ -2505,6 +2608,1388 @@ export const Law = () => {
       forced to be the same number.
     </Note>
 
+    <Note>
+      <b style={{ color: INK }}>So can the floor be found by enumerating?</b>{' '}
+      Twice over, and the two enumerations have opposite worth. If the mechanism
+      is one <K>BIAS</K> kick per age then{' '}
+      <V>a</V><Sub>0</Sub> = <K>BIAS</K>·<V>κ</V>/<V>t</V><Sub>0</Sub>, so{' '}
+      <V>κ</V> = 4.5323 and the job is to find that from the lattice constants.
+      Building every <V>ab</V>/<V>c</V>, <V>a</V>/<V>bc</V> and √(<V>ab</V>)/<V>c</V>{' '}
+      out of sixteen constants the file already owns gives 12816 expressions:
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}>within 20%</span>, <>661 expressions, 107 distinct values</>],
+      [<span style={{ color: FAINT }}>within 10%</span>, <>341, 60</>],
+      [<span style={{ color: FAINT }}>within 5%</span>, <>175, 31</>],
+      [<span style={{ color: FAINT }}>within 2%</span>, <>95, 12</>],
+      [<span style={{ color: BORROWED }}>within 1%</span>,
+        <><b style={{ color: INK }}>20 expressions, 4 distinct values</b> — the
+          closest √(<K>WAYS</K>·π)/2 = 4.51889, at −0.30%</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>Twenty expressions land inside a percent.</b> A
+      search over numbers cannot tell a derivation from an accident here, so a
+      hit is worth nothing even when it is close, and √(<K>WAYS</K>·π)/2 goes
+      down as a curiosity and nothing else. This is the one place where{' '}
+      <i>count it, do not fit it</i> has to be enforced by refusing to look
+      rather than by looking carefully.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>The search over constraints is not worthless.</b>{' '}
+      The floor must be <i>universal</i> — so it cannot depend on the test mass,
+      which kills the per-particle reading where a heavier body would have a{' '}
+      <i>lower</i> floor. It must be an <i>acceleration</i>, since
+      low-surface-brightness galaxies deviate at <i>small</i> radius and a length
+      scale forbids that. It must be a <i>square root</i>, since a constant
+      addition gives <V>v</V> ∝ √<V>r</V> rather than flat. It must{' '}
+      <i>switch off</i> faster than linearly, since the solar system bounds
+      anomalies at 10<Sup>−13</Sup> where <V>g</V>/<V>a</V><Sub>0</Sub> is
+      5·10<Sup>7</Sup>. It implies an <i>external field effect</i>, measurable in
+      wide binaries. And it must <i>run with time</i> — which is the one that
+      pays.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>Because a₀ = c/2π<V>t</V> makes it a function of
+        the age.</b> In a coasting universe <V>a</V> ∝ <V>t</V> exactly, so
+      1 + <V>z</V> = <V>t</V><Sub>0</Sub>/<V>t</V> — the redshift{' '}
+      <i>is</i> the age ratio, nothing fitted. Then{' '}
+      <V>a</V><Sub>0</Sub>(<V>z</V>) = <V>a</V><Sub>0</Sub>(1+<V>z</V>) and{' '}
+      <V>v</V><Sub>flat</Sub> ∝ (1+<V>z</V>)<Sup>¼</Sup>: at{' '}
+      <V>z</V> = 2 the same baryonic mass should rotate{' '}
+      <b style={{ color: INK }}>32% faster</b>, putting Tully–Fisher{' '}
+      <b style={{ color: INK }}>0.48 dex</b> off its local place — which is
+      measured to under 0.1 dex. Not subtle.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And is the missing factor 1/<K>SHEET</K>?</b>{' '}
+      Taken literally, no: <V>K</V> = 1/<K>SHEET</K> gives
+      8.61·10<Sup>−11</Sup> against a measured 1.20·10<Sup>−10</Sup>, 28% low.
+      (1/2π is 8.7% low, <K>HALF</K>/<K>DIMS</K> 4.4% — and by the count above,
+      none of that is evidence.) But the question underneath it is the sharpest
+      one in this section, because{' '}
+      <b style={{ color: INK }}>it is not √<V>r</V> that is wanted</b>.
+    </Note>
+
+    <Eq derive={REACH} open={show}
+      note="the two halves have very different costs">
+      <V>g</V> = √(<V>a</V><Sub>0</Sub>·<V>g</V><Sub>N</Sub>) =
+      <Frac over={<>√(<V>a</V><Sub>0</Sub><V>GM</V>)</>} under={<V>r</V>} />
+    </Eq>
+
+    <Note>
+      <V>g</V> ∝ 1/<V>r</V> instead of 1/<V>r</V><Sup>2</Sup> is{' '}
+      <i>easy</i> — plenty of things give 1/<V>r</V>. <V>g</V> ∝ √<V>M</V>{' '}
+      instead of <V>M</V> is the whole problem.{' '}
+      <b style={{ color: INK }}>The radius is not square-rooted at all. The mass
+        is.</b> And the exponent is forced rather than chosen: for any deep
+      limit <V>g</V> → <V>k·g</V><Sub>N</Sub><Sup><V>p</V></Sup>, a flat curve
+      needs 1 − 2<V>p</V> = 0 and Tully–Fisher needs 4<V>p</V> = 1 —{' '}
+      <b style={{ color: INK }}>both land on <V>p</V> = ½</b>, which is why MOND
+      has no freedom in its deep limit at all. Measured across the forms, only
+      those containing a <i>geometric mean</i> of{' '}
+      <V>g</V><Sub>N</Sub> and <V>a</V><Sub>0</Sub> survive — <V>p</V> = ½{' '}
+      <i>is</i> the geometric mean, and everything else is an arithmetic one.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>Which is exactly what this model cannot do, and
+        now the reason has a name.</b> Every force here is a meeting rate of two
+      fluxes, <i>shortfall</i> ∝ <V>m</V><Sub>a</Sub>·<V>m</V><Sub>b</Sub> —{' '}
+      strictly <i>bilinear</i>, because each emitter emits independently. So any
+      change to the geometry, the propagation or the counting moves the{' '}
+      <V>r</V>-dependence and leaves the mass linear.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}>flux ∝ 1/<V>r</V><Sup>2</Sup> both</span>,
+        <>Newton — <V>g</V> ∝ <V>M</V>/<V>r</V><Sup>2</Sup>, <V>p</V> = 1</>],
+      [<span style={{ color: FAINT }}>diffusive, ∝ 1/<V>r</V> both</span>,
+        <>flat curve, but <V>v</V><Sup>4</Sup> ∝ <V>M</V><Sup>2</Sup></>],
+      [<span style={{ color: FAINT }}>effective dimension 2</span>,
+        <>flat curve, but <V>v</V><Sup>4</Sup> ∝ <V>M</V><Sup>2</Sup></>],
+      [<span style={{ color: FAINT }}>stimulated halo, <V>ρ</V> ∝ <V>M</V>/<V>r</V><Sup>2</Sup></span>,
+        <>flat curve, but <V>v</V><Sup>4</Sup> ∝ <V>M</V><Sup>2</Sup></>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>All of them land on v⁴ ∝ M², for one reason.</b>{' '}
+      Bilinearity forces <V>v</V><Sup>2</Sup> ∝ <V>M</V> whatever the geometry
+      does. Which means the three mechanisms above{' '}
+      <i>did not fail separately</i> — the halo, the wake and the spatial
+      gradient are one failure wearing three hats, and that was worth finding
+      out. So the requirement is sharp: a response{' '}
+      <b style={{ color: INK }}>nonlinear in the source</b>, going as √<V>M</V>{' '}
+      below <V>a</V><Sub>0</Sub> and back to <V>M</V> above it. Nothing built
+      from how the flux <i>travels</i> can do it, because travel does not know
+      how much was emitted. It has to be the emission or the response
+      saturating — and the model has exactly one saturating quantity, the
+      one-a-tick ceiling, which acts at the other end of the scale entirely.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And it is worse than bilinearity — it is a
+        theorem.</b> Two things the model already satisfies and would not want
+      to give up: <i>action and reaction</i>, since the force <i>is</i> a count
+      of meetings and both parties count the same ones; and{' '}
+      <i>equivalence</i>, since <V>a</V><Sub>a</Sub> = <V>F</V>/<V>m</V><Sub>a</Sub>{' '}
+      must not depend on <V>m</V><Sub>a</Sub>. The second gives{' '}
+      <V>F</V> = <V>m</V><Sub>a</Sub>·<V>h</V>(<V>m</V><Sub>b</Sub>). Feed it
+      into the first and{' '}
+      <V>m</V><Sub>a</Sub><V>h</V>(<V>m</V><Sub>b</Sub>) ={' '}
+      <V>m</V><Sub>b</Sub><V>h</V>(<V>m</V><Sub>a</Sub>), so{' '}
+      <V>h</V>(<V>m</V>)/<V>m</V> is constant and{' '}
+      <b style={{ color: INK }}><V>F</V> ∝ <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub>{' '}
+        exactly</b>, with no freedom at all.
+    </Note>
+
+    <Note>
+      So <b style={{ color: INK }}>no two-body force law can give √<V>M</V></b> —
+      not a modified one, not a screened one, not one with a different geometry.
+      The mechanisms above were not unlucky, they were forbidden before they
+      started, which is why nobody has ever written MOND as a pairwise law.{' '}
+      <b style={{ color: INK }}>And that leaves exactly one door.</b> The theorem
+      is about a force between <i>two</i> things; it says nothing about whether
+      the field of a <i>composite</i> is the sum of its parts. Here it is,
+      because every emitter emits independently. Break superposition and the
+      theorem does not apply — a galaxy is then not the sum of its stars.
+    </Note>
+
+    <Head>a second graph</Head>
+
+    <Note>
+      Which is what a <i>second layer</i> would buy: a graph over the spatial
+      one, with its own ± polarities and its own XOR, moving under its own
+      dynamics, deciding <i>where mass is</i>. That makes the emitters{' '}
+      <b style={{ color: INK }}>non-independent</b> — whether one contributes
+      now depends on what the layer is doing, which depends on the others. It is
+      the first proposal here that goes <i>through</i> the obstruction rather
+      than around it.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the XOR hands over the root for free.</b>{' '}
+      <V>N</V> contributions with random ± signs do not sum to <V>N</V>; they
+      sum to a walk, √(2<V>N</V>/π) — measured at 7.91, 80.01, 800.42 against
+      7.98, 79.79, 797.88 for <V>N</V> = 10<Sup>2</Sup>, 10<Sup>4</Sup>,
+      10<Sup>6</Sup>. If gravity couples to the <i>net</i> polarity rather than
+      the <i>count</i>, the source enters as √<V>M</V> with nothing put in by
+      hand — out of the same XOR the whole model is built on.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>but √M alone is not enough</span>,
+        <>An effective mass gives <V>G</V>√(<V>MM</V><Sub>0</Sub>)/<V>r</V><Sup>2</Sup>,
+          hence <V>v</V> ∝ <V>r</V><Sup>−½</Sup> — not flat. The layer must
+          produce a <i>halo</i>,{' '}
+          <V>ρ</V> ∝ √<V>M</V>/<V>r</V><Sup>2</Sup>, which then gives{' '}
+          <b style={{ color: INK }}>182.7 km/s flat from 10 to 30 kpc and{' '}
+            <V>v</V><Sup>4</Sup> = <V>GMa</V><Sub>0</Sub> exactly</b>. The XOR
+          supplies the √; nothing yet supplies the 1/<V>r</V><Sup>2</Sup>.</>],
+      [<span style={{ color: BORROWED }}>and a walk has a width</span>,
+        <>|Σ±1| is Rayleigh — mean √(2<V>N</V>/π), deviation 0.655√<V>N</V>. A
+          single realisation scatters 76% in the net, 19% in{' '}
+          <V>v</V> = <V>M</V><Sub>eff</Sub><Sup>¼</Sup>, i.e.{' '}
+          <b style={{ color: INK }}>0.244 dex</b> of Tully–Fisher scatter
+          against a relation measured under 0.1. A <i>static</i> walk is
+          excluded outright.</>],
+      [<span style={{ color: DERIVED }}>unless the layer is fast</span>,
+        <>Averaging <V>K</V> samples an orbit cuts it by √<V>K</V>: at a
+          megayear correlation time the scatter is 0.021 dex, at a year or below
+          it is under 10<Sup>−4</Sup>. A lattice layer decorrelates in{' '}
+          <i>ticks</i>, so this is not close — but it is a real constraint, and
+          it says the layer must be <b style={{ color: INK }}>fast-moving</b>,
+          which is what “moves on its own” already proposed.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>What it would still owe.</b> The{' '}
+      <i>crossover</i> — why the cancellation turns on below{' '}
+      <V>a</V><Sub>0</Sub> and off above it — which is the whole of the
+      unexplained part, and the second graph makes the root <i>possible</i>{' '}
+      without making it <i>happen</i> at the right scale. The{' '}
+      1/<V>r</V><Sup>2</Sup> reach. The solar system, where superposition holds
+      exquisitely, so the breaking must vanish above <V>a</V><Sub>0</Sub> faster
+      than linearly. And <i>what mass is</i> — the layer decides where mass sits,
+      so <i>mass = pulse rate</i> has to be re-derived on it rather than
+      assumed, which reaches back into <i>physics.ts</i> and is not a small edit.
+      An <i>external field effect</i> is not a cost: it is unavoidable once
+      superposition fails, it is MOND’s own signature, and it is measurable in
+      wide binaries — so it arrives as a prediction.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And if that layer has emitters too, the other
+        half arrives from the same place.</b> The spatial graph already gets its
+      inverse square from emitters — <i>chance</i> = <V>m</V><K>SHEET</K>/<i>shell</i>,
+      a point spreading over a sphere. Give the second layer emitters as well
+      and the geometry follows, with the XOR doing the rest:{' '}
+      <V>N</V> emitters each ∝ 1/<V>r</V><Sup>2</Sup>, random ± polarity, so
+      they do not add — they <i>walk</i>:{' '}
+      <b style={{ color: INK }}>net ∝ √<V>N</V>/<V>r</V><Sup>2</Sup> =
+        √<V>M</V>/<V>r</V><Sup>2</Sup></b>. Both halves, out of one
+      construction, neither put in by hand.
+    </Note>
+
+    <Eq derive={REACH} open={show}
+      note="κ is fixed by a₀, and everything else follows">
+      <V>ρ</V> =
+      <Frac over={<><V>κ</V>√<V>M</V></>} under={<><V>r</V><Sup>2</Sup></>} />
+      <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+      <V>v</V><Sup>4</Sup> = (4π<V>Gκ</V>)<Sup>2</Sup><V>M</V> = <V>GMa</V><Sub>0</Sub>
+    </Eq>
+
+    <Note>
+      Flat at every radius, and <V>v</V><Sup>4</Sup> ∝ <V>M</V> exactly —{' '}
+      182.7 km/s from the profile against 182.7 from (<V>GMa</V><Sub>0</Sub>)<Sup>¼</Sup>.{' '}
+      <b style={{ color: INK }}>Both conditions, one exponent, nothing fitted
+        but κ ↔ a₀.</b> The <i>shape</i> of the dark matter problem is closed.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>but the solar system kills it</span>,
+        <>The same halo forms around the Sun:{' '}
+          <b style={{ color: INK }}>1.4·10<Sup>−4</Sup> of a solar mass inside
+            the Earth’s orbit</b>, 4.3·10<Sup>−3</Sup> inside 30 AU.
+          Ephemerides pin <V>GM</V><Sub>☉</Sub> to a part in 10<Sup>10</Sup> —
+          out by six orders, and it would show as an anomalous{' '}
+          <i>precession</i>, since the mass is distributed rather than
+          central.</>],
+      [<span style={{ color: BORROWED }}>and the obvious crossover is out</span>,
+        <>The natural story — a strong field <i>aligns</i> the polarities so
+          they add, a weak one leaves them random — switches where{' '}
+          <V>αN</V> ≈ √<V>N</V>, so <V>α</V> ≈ 1/√<V>N</V>, which{' '}
+          <i>counts constituents</i>. Between the Sun and the Galaxy that
+          threshold moves by <b style={{ color: INK }}>10<Sup>5.4</Sup></b>, so{' '}
+          <V>a</V><Sub>0</Sub> would be mass-dependent — and it is measured
+          universal well inside a factor of two across five decades.</>],
+      [<span style={{ color: DERIVED }}>which is a constraint, not a wall</span>,
+        <>It says the crossover cannot be a competition between an aligned part
+          and a random part, because any such competition counts constituents
+          and <V>a</V><Sub>0</Sub> must not. It has to switch the{' '}
+          <i>whole layer</i> without reference to how many emitters sit in it —{' '}
+          <b style={{ color: INK }}>a property of the place, not of the
+            body</b>. Which is suggestive, since that is exactly what{' '}
+          <i>fold</i> already is, and <V>g·t</V><Sub>0</Sub>/<V>c</V> is already
+          a statement about a place.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>So must the two layers touch?</b> Yes, and
+      which way decides everything.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>independent</span>,
+        <>The property that has to go. If each layer evolves entirely on its
+          own, the second is a <i>relabelling</i> — layer one still sums over
+          whatever sources it sees, superposition still holds inside it, and the
+          theorem applies word for word. Independence is not a detail of the
+          picture; it is what stands between it and working.</>],
+      [<span style={{ color: BORROWED }}>one-way — “it says where the mass is”</span>,
+        <>The reading one falls into by default, and it fails by a computable
+          amount. Gravity counts + against −, so with{' '}
+          <V>N</V><Sub>±</Sub> = <V>N</V>/2 ± <V>s</V>/2 the rate is{' '}
+          (<V>NM</V> − <V>su</V>)/2. The root <i>is</i> there —{' '}
+          <V>su</V> ~ √(<V>NM</V>) — but as a <i>correction</i> carrying a
+          random sign. For a star in the Galaxy it is{' '}
+          <b style={{ color: INK }}>3·10<Sup>−63</Sup></b> of the Newtonian
+          term, where MOND wants it comparable (2.13 at 20 kpc). Sixty-three
+          orders, which is a deletion rather than a switch.</>],
+      [<span style={{ color: DERIVED }}>two-way — layer two has its own field</span>,
+        <>The picture as described, and the only one that works. The halo is not
+          a correction to layer one’s counting but layer <i>two’s</i> own
+          emitted field, which layer one feels. Its size is set by an{' '}
+          <b style={{ color: INK }}>inter-layer coupling κ</b> rather than by
+          1/√(<V>NM</V>), so it is free to be whatever{' '}
+          <V>a</V><Sub>0</Sub> says.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>And that is the real cost, stated plainly:</b>{' '}
+      <V>a</V><Sub>0</Sub> becomes a new fundamental constant — the strength
+      with which layer two’s field gravitates in layer one — rather than
+      something counted out of <K>SHEET</K> and <K>WAYS</K>. For a model whose
+      whole method is counting, that is a genuine loss, and it belongs in the
+      ledger rather than hidden inside a κ.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And a requirement nobody asked for, which is a
+        point in favour.</b> The net polarity has a <i>random sign</i>. Couple
+      to the net and half of all halos are repulsive; couple to net<Sup>2</Sup>{' '}
+      and it is ∝ <V>M</V> again with the root gone. It must couple to{' '}
+      |net| — and an absolute value is a strange thing to couple to,{' '}
+      <i>and it is exactly what MOND already has</i>. AQUAL’s field equation is
+      ∇·[<V>μ</V>(|∇<V>φ</V>|/<V>a</V><Sub>0</Sub>)∇<V>φ</V>] = 4π<V>Gρ</V> —
+      the nonlinearity is an absolute value of a field, for precisely this
+      reason: it makes the response sub-linear without making it signed. So the
+      second layer is not being asked for something exotic. It is being asked
+      for{' '}
+      <b style={{ color: INK }}>MOND’s own nonlinearity, arrived at from the
+        other side</b> — |net polarity of a random ± layer| in place of
+      |∇<V>φ</V>|. Two constructions with nothing in common landing on the same
+      odd requirement is the one encouraging thing here.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And is the compounding the nonlinearity?</b>{' '}
+      Layer two moves <i>through</i> layer one, so layer one’s fold decides
+      where layer two can go and the effects feed each other. That is the right
+      shape of argument — it is the one that already paid once, since{' '}
+      1 + <V>u</V> = <V>e</V><Sup><V>u</V><Sub>0</Sub></Sup> came from exactly
+      this move, and it remains the only nonlinearity this file has{' '}
+      <i>derived</i> rather than assumed.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>but the one already here is the wrong function</span>,
+        <>At 20 kpc, <V>u</V> = 1.68·10<Sup>−7</Sup> and the compounded part{' '}
+          <V>e</V><Sup><V>u</V></Sup> − 1 − <V>u</V> is 1.41·10<Sup>−14</Sup> —
+          fourteen orders under a linear term already seven orders short. And
+          the <i>shape</i> matters more:{' '}
+          <b style={{ color: INK }}>there is no limit of an exponential that
+            behaves like a square root</b>. 1 + <V>u</V> + <V>u</V><Sup>2</Sup>/2
+          is integer powers forever.</>],
+      [<span style={{ color: DERIVED }}>the version that could work</span>,
+        <>Not “the fold compounds itself” but{' '}
+          <b style={{ color: INK }}>the fold decides how fast layer two
+            forgets</b>. <i>slowing</i> = <V>e</V><Sup>−2<V>u</V></Sup> holds
+          motion back where the fold is deep: deep in a well layer two is held
+          and the polarities stay aligned (net ~ <V>N</V>, Newton); far out it
+          runs free and they randomise (net ~ √<V>N</V>, MOND). A property of
+          the <i>place</i>, not the body — precisely what the
+          constituent-counting argument demanded.</>],
+      [<span style={{ color: BORROWED }}>and it has a sharp tension</span>,
+        <>The decorrelation time <V>τ</V> must do two jobs. The crossover needs{' '}
+          <V>g·τ</V>/<V>c</V> ≈ 1 at <V>a</V><Sub>0</Sub>, so{' '}
+          <V>τ</V> = <V>c</V>/<V>a</V><Sub>0</Sub> ={' '}
+          <b style={{ color: INK }}>79 Gyr</b> — 5.7× the age, essentially
+          frozen. The scatter needs more than 8.5 draws an orbit, so{' '}
+          <V>τ</V> &lt; <b style={{ color: INK }}>26 Myr</b> — fast.{' '}
+          <b style={{ color: INK }}>3.5 orders apart, in opposite
+            directions.</b></>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>And one escape, which follows from the |net|
+        result rather than being added to save it.</b> The scatter argument
+      assumed <i>one</i> walk for the whole body. But the sign argument already
+      forced the coupling to |net| — and if that is <i>local</i>, the halo sums
+      |net| over <V>K</V> patches instead of taking |Σ| once: the total goes as
+      √(<V>KN</V>) and the width falls as 1/√<V>K</V>. Spatial averaging kills
+      the scatter without needing fast forgetting, so <V>τ</V> is freed and the
+      tension dissolves — at the price of a new length. A patch anywhere under
+      ten kiloparsecs suffices (27 patches, 0.059 dex). What it then owes is
+      that the √<V>K</V> be absorbed into κ{' '}
+      <i>without</i> introducing a mass or radius dependence, or Tully–Fisher
+      moves. A real constraint on the patch size, checkable, and where this goes
+      next.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And checked, that escape does not survive.</b>{' '}
+      Three lines: <V>M</V><Sub>eff</Sub> = √(<V>KN</V>) with{' '}
+      <V>K</V> = <V>V</V>/ℓ<Sup>3</Sup> gives{' '}
+      √(<V>VM</V>/ℓ<Sup>3</Sup><V>m</V><Sub>p</Sub>), and Tully–Fisher wants{' '}
+      √<V>M</V> <i>and nothing else</i> — so ℓ<Sup>3</Sup> ∝ <V>V</V>, i.e.{' '}
+      <b style={{ color: INK }}>the same number of patches for every system</b>,
+      dwarf to cluster. That is not a length, it is a fixed fraction of whatever
+      it sits in, which no local rule produces. With a fixed ℓ the halo picks up
+      the galaxy’s <i>size</i> as well as its mass and Tully–Fisher moves by
+      whole dex. So the spatial escape is out, and the temporal tension stands:
+      79 Gyr against 26 Myr.
+    </Note>
+
+    <Head>the whole thing in one line</Head>
+
+    <Note>
+      The machinery has got ahead of the question. Strip out the layers, the
+      polarities and the patches, and what is left is a statement about{' '}
+      <i>which flux is conserved</i>:
+    </Note>
+
+    <Eq derive={REACH} open={show}
+      note="both flat, both equal to the baryonic mass, at every radius">
+      <V>g·r</V><Sup>2</Sup> = <V>GM</V>
+      <span style={{ padding: '0 1.6em', color: FAINT }}>vs</span>
+      <V>g</V><Sup>2</Sup><V>·r</V><Sup>2</Sup> = <V>GM·a</V><Sub>0</Sub>
+    </Eq>
+
+    <Note>
+      <b style={{ color: INK }}>Newton conserves the flux of <V>g</V>. Deep MOND
+        conserves the flux of <V>g</V><Sup>2</Sup>.</b> Both checked at 10, 20
+      and 40 kpc, both flat at 1.39·10<Sup>41</Sup> kg — the Milky Way’s
+      baryons. The interpolation between them is exactly AQUAL,{' '}
+      <V>μ</V>(<V>g</V>/<V>a</V><Sub>0</Sub>)·<V>g·r</V><Sup>2</Sup> = <V>GM</V>.
+      That is the entire problem, and everything above is machinery for making
+      that one switch happen.
+    </Note>
+
+    <Note>
+      Which <b style={{ color: INK }}>collapses three questions into one</b>.
+      “Where does √<V>M</V> come from”, “where does 1/<V>r</V> come from” and
+      “what switches at <V>a</V><Sub>0</Sub>” are the same question, because{' '}
+      <V>g</V><Sup>2</Sup><V>r</V><Sup>2</Sup> = <V>GMa</V><Sub>0</Sub> contains
+      all three at once: the square gives the root, the square gives the
+      1/<V>r</V>, and <V>a</V><Sub>0</Sub> is only the constant that makes two
+      conserved quantities carry the same units.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>a wrong turn, recorded</span>,
+        <>“Count <i>pairs</i> instead of charges — pairs among <V>n</V> go as{' '}
+          <V>n</V><Sup>2</Sup>, so a conserved pair-flux makes the charge-count
+          its root.” It does not survive: pair density goes as{' '}
+          <V>M</V><Sup>2</Sup>/<V>r</V><Sup>4</Sup>, so pairs in a shell go as{' '}
+          <V>M</V><Sup>2</Sup>/<V>r</V><Sup>2</Sup> — <i>falling</i> rather than
+          conserved. Counting pairs concentrates at the centre, the opposite of
+          a halo.</>],
+      [<span style={{ color: DERIVED }}>the right statement is simpler</span>,
+        <><V>g</V><Sup>2</Sup><V>r</V><Sup>2</Sup> = const is just{' '}
+          <V>g</V> ∝ 1/<V>r</V>, and <V>g</V> is the density of whatever
+          mediates — so it is entirely about how that density falls. Ballistic
+          in 3D gives 1/<V>r</V><Sup>2</Sup> (Newton); diffusive in 3D, or
+          ballistic in 2D, gives 1/<V>r</V>. With the amplitude √<V>M</V> from
+          the random signs, the deep law is{' '}
+          <b style={{ color: INK }}>random signs × a 1/<V>r</V> profile</b> —
+          two things the model has words for, since <K>SPREAD</K> is diffusion
+          and the XOR is the signs. A much smaller ask than a second layer with
+          its own gravity.</>],
+      [<span style={{ color: BORROWED }}>and the remaining trap</span>,
+        <>The natural switch from ballistic to diffusive is the{' '}
+          <i>mean free path</i> — one regime inside <V>λ</V>, another outside.
+          That is a <b style={{ color: INK }}>length</b>, and a length is already
+          excluded: low-surface-brightness galaxies deviate from Newton at{' '}
+          <i>small</i> radius, which no <V>r</V>-threshold can do. The switch has
+          to be driven by field <i>strength</i>, not distance.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>Which leaves one question, in one sentence:
+        what makes the mediator stop travelling straight when <V>g</V> falls
+        below <V>a</V><Sub>0</Sub>?</b> Everything above is scaffolding for
+      that, and anything that answers it makes most of the scaffolding
+      unnecessary.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>“Below what”, though</b> — because “below{' '}
+      <V>a</V><Sub>0</Sub>” is circular, <V>a</V><Sub>0</Sub> being the thing to
+      derive. Said in the model’s own units it stops being circular. The model
+      has one carrier, at occupancy{' '}
+      <i>chance</i> = <V>m</V><K>SHEET</K>/<i>shell</i>, and the pull is{' '}
+      <V>g</V> = <K>GRAVITY</K>·<V>m</V>/<V>r</V><Sup>2</Sup>. Divide them and{' '}
+      <V>m</V> and <V>r</V> both vanish:{' '}
+      <V>g</V>/<i>chance</i> = 4π<K>GRAVITY</K>/<K>SHEET</K> = 0.0979, a
+      constant.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So <V>g</V> <i>is</i> the carrier density</b>,
+      times a fixed number. In general relativity the field strength is not a
+      density of anything; here it is exactly one — which is why this model can
+      state the condition <i>locally</i> at all. “The field is weak” and “the
+      carriers are sparse” are not two facts about a place. And that gives the
+      threshold a value in carriers per cell: <V>a</V><Sub>0</Sub> is
+      2.16·10<Sup>−62</Sup> in lattice units, so the crossover occupancy is
+      2.20·10<Sup>−61</Sup> — <b style={{ color: INK }}>one carrier per
+        4.54·10<Sup>60</Sup> cells</b>.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the statement is about a path, not a
+        volume.</b> Said as “one carrier per horizon” it compared a volume count
+      against a linear one, and those differ by 10<Sup>121</Sup> here — the
+      occupancy was right and the phrase was not. The mean spacing is
+      1.66·10<Sup>20</Sup> cells, 2.68 fm. What <i>is</i> order one is a{' '}
+      <i>path</i> count: a carrier moves one cell a tick, so over the age it
+      crosses <V>t</V><Sub>0</Sub> cells and meets{' '}
+      <V>n</V><Sub>c</Sub>·<V>t</V><Sub>0</Sub> = 1.78 others.{' '}
+      <b style={{ color: INK }}>The crossover is where a carrier meets about one
+        other in the whole history of the universe</b> — below it, a carrier
+      travels its life alone. Which is{' '}
+      <V>a</V><Sub>0</Sub> ≈ <V>c</V>/<V>t</V><Sub>0</Sub> in the model’s own
+      words, now saying something physical: <i>a carrier that never meets
+        another has nothing to keep it straight</i>. A condition on the carrier, evaluated where the
+      carrier is, with no reference to the mass that sent it or the distance it
+      has come — a property of the place and not the body, and not a length, so
+      the low-surface-brightness objection does not touch it.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}>Earth’s surface</span>,
+        <>1.46·10<Sup>11</Sup> carriers per horizon</>],
+      [<span style={{ color: FAINT }}>the Sun at 1 AU</span>,
+        <>8.80·10<Sup>7</Sup></>],
+      [<span style={{ color: DERIVED }}>the Galaxy at 8 kpc</span>,
+        <><b style={{ color: INK }}>2.91</b> — just above the switch</>],
+      [<span style={{ color: DERIVED }}>the Galaxy at 20 kpc</span>,
+        <><b style={{ color: INK }}>0.395</b> — just below it</>],
+      [<span style={{ color: FAINT }}>the Galaxy at 100 kpc</span>,
+        <>0.016</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>The switch at one sits between the solar circle
+        and 20 kpc</b> — exactly where rotation curves start to depart — and the
+      solar system is eight orders clear of it. That separation is what every
+      earlier candidate failed to produce, and here it falls out of the counting
+      rather than being asked for.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So the question in its smallest form, and no
+        longer circular: what does a carrier do when there is less than one
+        other carrier within reach of it — and why would that be a wander rather
+        than nothing at all?</b> Which is answerable by <i>simulation</i> rather
+      than by argument, for the first time in this line of work: two carriers, a
+      lattice, and whatever rule makes one of them notice the other.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So the search, run.</b> Every family of local
+      rule that could bend the radial law, and how each dies.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}>free streaming</span>,
+        <><V>n</V> ∝ 1/<V>r</V><Sup>2</Sup> — nothing wrong with it; it{' '}
+          <i>is</i> Newton</>],
+      [<span style={{ color: BORROWED }}>scattering, <V>λ</V> = 1/<V>σn</V></span>,
+        <>Dense → 1/<V>r</V>. <b style={{ color: INK }}>The sign is
+          backwards</b> — the model’s own <i>through</i> rule makes meetings{' '}
+          <i>deflect</i>, so it wanders where it is crowded. And{' '}
+          <V>λ</V> = <V>r</V> is a length.</>],
+      [<span style={{ color: BORROWED }}>scattering, <V>λ</V> ∝ <V>n</V></span>,
+        <>Right sign, still a length. Any such rule switches where{' '}
+          <V>λ</V>(<V>n</V>) = <V>r</V>, but the switch must sit at fixed{' '}
+          <V>n</V><Sub>c</Sub> while <V>r</V><Sub>c</Sub> = √(<V>GM</V>/<V>a</V><Sub>0</Sub>)
+          moves with mass — 0.3, 3.4 and 34 kpc for 10<Sup>8</Sup>,
+          10<Sup>10</Sup>, 10<Sup>12</Sup> M☉. One number against three.</>],
+      [<span style={{ color: BORROWED }}>creation ∝ <V>n</V><Sup>2</Sup>, i.e. meetings</span>,
+        <>Dimensions demand <V>p</V> = 2 for <V>Φ</V> ∝ <V>r</V>, and{' '}
+          <V>n</V><Sup>2</Sup> is a meeting rate — the only interaction the model
+          has. It looked like the answer.{' '}
+          <b style={{ color: INK }}>It is a knife edge, not an attractor:</b>{' '}
+          1/<V>Φ</V> = 1/<V>Φ</V><Sub>0</Sub> + (<V>γ</V>/4π)(1/<V>r</V> −
+          1/<V>r</V><Sub>0</Sub>) either saturates back to Newton or runs away,
+          and the threshold between them is in the <i>source strength</i> — so
+          heavy galaxies would have halos and light ones none.</>],
+      [<span style={{ color: DERIVED }}>carriers slowing, <V>v</V> ∝ 1/<V>r</V></span>,
+        <>Gives <V>n</V> ∝ 1/<V>r</V> ✓ — and contradicts the model outright.
+          Everything moving at <V>c</V> is what gives the metric and the
+          checkerboard.</>],
+      [<span style={{ color: DERIVED }}>effectively two-dimensional</span>,
+        <>Gives <V>n</V> ∝ 1/<V>r</V> ✓, and nothing forbids it.{' '}
+          <b style={{ color: INK }}>The one live candidate</b> — and nothing
+          here supplies a rule that would do it. <K>FLOOR</K> and the
+          fractional-dimension work in <i>regimes.ts</i> is where the vocabulary
+          already is.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>And the mass is still a separate problem.</b>{' '}
+      None of these produce √<V>M</V> — they are all rates, so all bilinear, so
+      the theorem holds over every one of them. The radial law and the mass law
+      are two problems and this search only ever addressed the first.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the live candidate has a candidate
+        mechanism: lock layer two to layer one’s <K>SHEET</K>.</b>{' '}
+      <K>WAYS</K> = 3<Sup>3</Sup>−1 = 26 is every direction out of a cell;{' '}
+      <K>SHEET</K> = 3<Sup>2</Sup>−1 = 8 is the directions in <i>one plane</i>{' '}
+      through it. And <i>chance</i> = <V>m</V><K>SHEET</K>/<i>shell</i> already
+      uses <K>SHEET</K> rather than <K>WAYS</K> — the pull was always counted
+      through a plane. This is not adding a structure; it is taking one the file
+      already has and making it <i>bind</i>.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>but not “always” 2D</span>,
+        <>A source spreading into a plane gives <V>n</V> ∝ 1/<V>r</V> at{' '}
+          <i>every</i> radius, including the solar system where
+          1/<V>r</V><Sup>2</Sup> holds to a part in 10<Sup>10</Sup>. The locking
+          must be conditional, and the condition is the whole content of the
+          proposal.</>],
+      [<span style={{ color: DERIVED }}>and the condition runs the right way round</span>,
+        <>A plane needs <i>two</i> independent directions to be defined. Many
+          carriers met → many planes, all disagreeing → isotropic →{' '}
+          <b style={{ color: INK }}>3D, Newton</b>. About one met → one plane,
+          uncontested → locked → <b style={{ color: INK }}>2D, MOND</b>. Dense
+          is Newtonian and thin is not — which everything earlier got backwards.
+          And the threshold is a <i>count of meetings</i>, not a length and not
+          a mass.</>],
+      [<span style={{ color: DERIVED }}>so it predicts <V>a</V><Sub>0</Sub></span>,
+        <>“About one meeting in a carrier’s life” means{' '}
+          <V>n</V><Sub>c</Sub> = 1/<V>t</V><Sub>0</Sub> = 1.24·10<Sup>−61</Sup>{' '}
+          a cell, and <V>g</V> = 4π<V>G</V>/<K>SHEET</K>·<V>n</V> gives{' '}
+          <b style={{ color: INK }}><V>a</V><Sub>0</Sub> = 6.74·10<Sup>−11</Sup> m/s²</b>{' '}
+          against a measured 1.20·10<Sup>−10</Sup> —{' '}
+          <b style={{ color: INK }}>a factor of 1.78, with nothing fitted</b>.
+          The inputs are <K>GRAVITY</K> and <K>SHEET</K>, both counted, and the
+          age, which the frontier already fixes at 1/<V>H</V><Sub>0</Sub>.
+          Against <K>BIAS</K>/<V>t</V><Sub>0</Sub>, which was 4.53 out, that is
+          a real improvement — and it comes from a <i>stated rule</i> rather
+          than from trying combinations.</>],
+    ]} />
+
+    <Note>
+      Checked in meetings over a carrier’s whole life: 1.5·10<Sup>11</Sup> at
+      the Earth’s surface, 8.8·10<Sup>7</Sup> at 1 AU, 2.91 at 8 kpc, 0.395 at
+      20 kpc, 0.016 at 100 kpc.{' '}
+      <b style={{ color: INK }}>Eight orders of margin in the solar system,
+        crossing between 8 and 20 kpc.</b> The separation is not asked for; it
+      falls out of the counting.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the mass, where the second half of the idea
+        points.</b> Two dimensions alone is not enough and fails the familiar
+      way: a source of strength <V>M</V> over 2π<V>r</V> gives{' '}
+      <V>n</V> ∝ <V>M</V>/<V>r</V>, so <V>v</V><Sup>4</Sup> ∝ <V>M</V><Sup>2</Sup>{' '}
+      — the third appearance of that exact failure. But layer one’s pulses both{' '}
+      <i>constitute</i> the mass and <i>set</i> the sheet: if the sheet a carrier
+      locks to is chosen by the pulse it met, and pulses carry ± which XOR, the
+      sheet directions inherit the cancellation. <V>N</V> pulses agree on a
+      direction only to √<V>N</V>, so the coherently-locked fraction is
+      √<V>N</V>/<V>N</V> and the effective source is √<V>N</V>.{' '}
+      <b style={{ color: INK }}>That would be the √<V>M</V></b>, from the same
+      mechanism as the radial law rather than a second one.{' '}
+      <i>A sketch and not a result</i> — nothing here shows that sheet
+      directions XOR the way polarities do, and everything turns on that. But it
+      is the first version where both halves have the same cause.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>But the sheet rotates — so what stops it being
+        3D again?</b> The objection is right, and answering it pins the
+      mechanism down rather than breaking it. A straight line is 1D and lies in
+      infinitely many planes, so confining a carrier to a plane does nothing on
+      its own. The distinction is about <i>spreading</i>: a beam widening in two
+      transverse directions covers area ∝ <V>r</V><Sup>2</Sup> and gives
+      1/<V>r</V><Sup>2</Sup>; widening in <i>one</i> covers ∝ <V>r</V> and gives
+      1/<V>r</V>. The plane holds the carrier’s <i>own</i> outward line, so
+      every sky direction is still covered — the picture stays isotropic and
+      only the widening flattens. (Which also disposes of the obvious worry: a
+      globally fixed plane would make halos <i>discs</i> and rotation curves
+      depend on sky direction, and they do not.)
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And then the rotation matters exactly as
+        said</b> — if the plane turns about the <i>radial</i> axis mid-journey,
+      the widening fills both directions and 1/<V>r</V><Sup>2</Sup> comes
+      straight back. So the sheet must hold about that axis for the whole trip.
+      And <i>“reset only by a meeting”</i> is precisely that stability — with a
+      dividend nobody asked for. Meetings are independent and rare, so they are{' '}
+      <b style={{ color: INK }}>Poisson</b> with mean{' '}
+      <V>x</V> = <V>g</V>/<V>a</V><Sub>0</Sub> over a carrier’s life: never
+      reset with probability <V>e</V><Sup>−<V>x</V></Sup> (stays 2D), reset at
+      least once with 1 − <V>e</V><Sup>−<V>x</V></Sup> (3D).
+    </Note>
+
+    <Eq derive={REACH} open={show}
+      note="the fraction that has gone 3D is the interpolation function">
+      <V>μ</V>(<V>x</V>) = 1 − <V>e</V><Sup>−<V>x</V></Sup>
+      <span style={{ padding: '0 1.4em', color: FAINT }}>→ <V>x</V> as <V>x</V> → 0,</span>
+      <span style={{ color: FAINT }}>→ 1 as <V>x</V> → ∞</span>
+    </Eq>
+
+    <Note>
+      <b style={{ color: INK }}>Both limits correct, and neither put in</b> —
+      they are what “at least one reset” means when resets are Poisson. Every
+      MOND paper picks an interpolation function by hand out of a family; this
+      one picks itself out of the counting statistics of the mechanism, which is
+      the difference between a fit and a derivation.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>and it is distinguishable</span>,
+        <>Solving <V>μ</V>(<V>g</V>/<V>a</V><Sub>0</Sub>)·<V>g</V> ={' '}
+          <V>g</V><Sub>N</Sub> for the Milky Way: at 10 kpc the Poisson form
+          gives 208.7 km/s against 227.3 for <V>x</V>/(1+<V>x</V>) and 201.7 for{' '}
+          <V>x</V>/√(1+<V>x</V><Sup>2</Sup>) —{' '}
+          <b style={{ color: INK }}>a 25 km/s spread through the transition at
+            5–20 kpc</b>, exactly where curves are best measured. SPARC-quality
+          fits distinguish interpolation functions at that level.</>],
+      [<span style={{ color: DERIVED }}>and the shape is distinctive</span>,
+        <>1 − <V>e</V><Sup>−<V>x</V></Sup> reaches Newton much faster than either
+          standard form — 0.993 at <V>x</V> = 5 against 0.833 and 0.981. So the
+          model says the transition is{' '}
+          <b style={{ color: INK }}>sharper than the usual fits assume</b>, which
+          is a statement about the <i>inner</i> parts of galaxies rather than the
+          outskirts — the opposite end from where these arguments usually
+          live.</>],
+      [<span style={{ color: BORROWED }}>and the mass is untouched</span>,
+        <>The sheet story is about how carriers <i>travel</i>; √<V>M</V> is about
+          how many of them there effectively <i>are</i>. Six of the seven
+          requirements are now met and the seventh is the one the theorem says
+          needs superposition to fail — a different kind of thing entirely.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>How many emitters — per body, or in the
+        universe?</b> The question has a fork in it and one side is already
+      settled. The root runs over <i>the body</i>, and that is forced rather
+      than preferred: over the body gives{' '}
+      <V>M</V><Sub>eff</Sub> ∝ √<V>M</V> and{' '}
+      <V>v</V><Sup>4</Sup> ∝ <V>M</V> ✓, while over the universe gives{' '}
+      <V>M</V><Sub>eff</Sub> = const and every galaxy rotating at the same speed
+      whatever its mass ✗. Tully–Fisher holds across five decades with under 0.1
+      dex of scatter.
+    </Note>
+
+    <Note>
+      The universe total is worth having anyway, and the model fixes its own
+      rather than borrowing one: a ball of radius{' '}
+      <V>ct</V><Sub>0</Sub> = 4.23 Gpc, 9.32·10<Sup>78</Sup> m³, baryons
+      3.92·10<Sup>51</Sup> kg —{' '}
+      <b style={{ color: INK }}>2.34·10<Sup>78</Sup> emitters</b> if an emitter
+      is a proton, one per 9.4·10<Sup>104</Sup> cells. The familiar
+      10<Sup>80</Sup> is quoted for ΛCDM’s <i>comoving</i> observable universe,
+      14.3 Gpc rather than 4.2 — a volume 39× larger, giving
+      9.0·10<Sup>79</Sup>. Consistent, and a good check that the smaller ball is
+      not quietly losing matter.
+    </Note>
+
+    <Note>
+      √<V>N</V><Sub>universe</Sub> = 1.53·10<Sup>39</Sup>, beside the
+      proton–electron electric-to-gravitational ratio of 2.27·10<Sup>39</Sup> —
+      Dirac’s large numbers in Eddington’s version.{' '}
+      <b style={{ color: INK }}>Recorded and not claimed.</b> The enumeration
+      above measured how worthless this is: 341 of 12816 expressions land within
+      10% of an arbitrary target and 20 within 1%. It is the same discipline
+      that made <V>a</V><Sub>0</Sub> ≈ <V>c</V>/<V>t</V><Sub>0</Sub> worth
+      something only once a <i>rule</i> produced it.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>where the universe does enter</span>,
+        <>Not the count. The halo is{' '}
+          <V>ρ</V> = <V>κ</V>√<V>M</V>/<V>r</V><Sup>2</Sup> and κ is fixed by{' '}
+          <V>a</V><Sub>0</Sub> — 0.1067 measured, 0.0800 predicted, the ratio
+          being √1.78. So{' '}
+          <b style={{ color: INK }}>the root runs over the body and the
+            coefficient runs over the horizon</b>: the mass scaling is local,
+          the scale is cosmological, and nothing counts the universe’s
+          emitters.</>],
+      [<span style={{ color: BORROWED }}>but what <i>is</i> an emitter?</span>,
+        <>If the root is over constituents, the answer depends on what counts as
+          one. For 7·10<Sup>10</Sup> M☉:{' '}
+          <V>M</V><Sub>eff</Sub>/<V>M</V> is 1.1·10<Sup>−34</Sup> per proton,
+          4.0·10<Sup>−25</Sup> per Planck mass, 3.8·10<Sup>−6</Sup> per solar
+          mass — <b style={{ color: INK }}>twenty-nine orders</b>. And since κ is
+          fixed by <V>a</V><Sub>0</Sub>, choosing the emitter <i>is</i> choosing{' '}
+          <V>a</V><Sub>0</Sub>. The mechanism cannot be agnostic about it.</>],
+      [<span style={{ color: DERIVED }}>so the next concrete thing</span>,
+        <>Not “how many in the universe” but <b style={{ color: INK }}>what is
+          one</b>. The model already believes there is a smallest emitter — the
+          ceiling is one emission a cell a tick — so that is where the count has
+          to come from, and it is a question about <i>physics.ts</i> rather than
+          about galaxies.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>So posit the ratio</b> — one layer-two pulse for
+      every <V>x</V> of layer one’s — and check before asking why. In the
+      obvious reading it fails, and the way it fails says what the rule has to
+      be. <V>N</V> in, <V>N</V>/<V>x</V> out: for the output to be √<V>N</V> you
+      need <V>x</V> = √<V>N</V>, so <V>x</V> is not a ratio at all — it grows
+      with the body. “One in a thousand” is still <i>linear</i>, and just
+      rescales the mass.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}>1 for 1, or 1 for every 1000</span>,
+        <><V>N</V><Sup>1</Sup> — <V>v</V><Sup>4</Sup> ∝ <V>M</V><Sup>4</Sup></>],
+      [<span style={{ color: FAINT }}>1 per dead-time (saturates)</span>,
+        <><V>N</V><Sup>0</Sup> — no mass dependence at all</>],
+      [<span style={{ color: FAINT }}>1 per coincidence of two</span>,
+        <><V>N</V><Sup>2</Sup> — the wrong way entirely</>],
+      [<span style={{ color: DERIVED }}>XOR cancellation</span>,
+        <><b style={{ color: INK }}><V>N</V><Sup>½</Sup></b> — the only one</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>So the root is specifically cancellation, not a
+        rate ratio</b> — which is worth having, because it means the rule is
+      forced rather than chosen. <i>But there is a version of the idea that
+        works, and it is a ratio after all — just not of counts.</i> Let the
+      trigger be <b style={{ color: INK }}>phase</b> rather than tally: one
+      layer-two pulse per 2π of accumulated layer-one phase. Phase is{' '}
+      <i>signed</i>, so it random-walks where a tally cannot —{' '}
+      <V>N</V> pulses of ±<V>δ</V> accumulate to <V>δ</V>√<V>N</V>, giving{' '}
+      <V>δ</V>√<V>N</V>/2π pulses out. <b style={{ color: INK }}>√<V>N</V>, from
+        a fixed rule.</b> And the file already carries <i>phase</i> on a source,
+      and <i>inStep</i> already turns on whether phases add.
+    </Note>
+
+    <Eq derive={REACH} open={show}
+      note="one equation, two unknowns — and both were already owed">
+      <V>M</V><Sub>2</Sub> = √(<V>M·m</V><Sub>0</Sub>)
+      <span style={{ padding: '0 1.4em', color: FAINT }}>⇒</span>
+      <V>m</V><Sub>0</Sub> = <Frac over={<><V>a</V><Sub>0</Sub><V>L</V><Sup>2</Sup></>} under={<V>G</V>} />
+    </Eq>
+
+    <Note>
+      The effective source is the <i>geometric mean</i> of the body and the
+      elementary emitter, and matching deep MOND locks the emitter to a length.
+      A proton wants <V>L</V> = 3.05·10<Sup>−14</Sup> m; an electron
+      7.12·10<Sup>−16</Sup>; a Planck mass 1.10·10<Sup>−4</Sup>. Going the other
+      way, 2.68 fm wants a 7.24 MeV emitter.{' '}
+      <b style={{ color: INK }}>Two of those are worth a second look and neither
+        is a claim</b> — a Planck-mass emitter wants 0.11 mm, which is the length
+      short-range gravity experiments were built to probe and the one the
+      dark-energy density picks out. Recorded so they are not rediscovered later
+      and mistaken for evidence.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>What it actually buys is real.</b> Before, κ was
+      one fitted number with no interpretation. Now it is{' '}
+      <V>m</V><Sub>0</Sub> = <V>a</V><Sub>0</Sub><V>L</V><Sup>2</Sup>/<V>G</V> —
+      a relation between two things the model already owes an opinion on:{' '}
+      <i>physics.ts</i> owes a smallest emitter, since the one-a-tick ceiling
+      implies one, and the sheet mechanism owes a length, being how far a locked
+      plane holds. <b style={{ color: INK }}>Two separate debts, now one
+        equation.</b> Fix either and <V>a</V><Sub>0</Sub> follows; fix{' '}
+      <V>a</V><Sub>0</Sub> and they are locked to each other. Which is exactly
+      what “check it works before asking why” was supposed to produce. Still
+      missing: why phases should <i>cancel</i> rather than add — the same
+      question <i>inStep</i> asks, already measured for two identical emitters,
+      and never once asked of a whole body.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And if the universe reuses its abstractions,
+        <i>inStep</i> already answers it.</b> The criterion is in the file,
+      derived and measured for two identical emitters: phases hold together only
+      closer than a Compton wavelength, <V>R</V> &lt; 2π/<V>m</V>, and beyond it
+      they drift through every phase and cancel. For a proton that is
+      1.32·10<Sup>−15</Sup> m, so a galaxy is{' '}
+      <b style={{ color: INK }}>7·10<Sup>35</Sup> of them across</b> — utterly
+      out of step, phases cancelling completely, surviving net √<V>N</V>. Not a
+      new postulate; the model’s own criterion. Which is what “the same
+      abstraction is reused” would predict, so the assumption pays for itself
+      instead of costing something.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>but not for layer one</span>,
+        <>The Sun is 1.19·10<Sup>57</Sup> protons, so √<V>N</V>/<V>N</V> =
+          2.9·10<Sup>−29</Sup>. Gravity would be 10<Sup>−29</Sup> of itself. The
+          two layers cannot read the pulse train the same way.</>],
+      [<span style={{ color: DERIVED }}>one object, two observables</span>,
+        <>Layer one reads the <b style={{ color: INK }}>count</b> — how many
+          pulses, unsigned, which is mass. Layer two reads the{' '}
+          <b style={{ color: INK }}>phase</b> — where in the cycle, signed, which
+          cancels. A pulse train has both, and the file already carries both:{' '}
+          <i>mass = pulse rate</i> is the count and <i>phase</i> is on the
+          Source type. The abstraction <i>is</i> shared; only the aspect coupled
+          to differs.</>],
+      [<span style={{ color: DERIVED }}>which may mean there is no second layer</span>,
+        <>If layer two is the <i>phase</i> of layer one’s pulses, it is the same
+          graph read differently rather than a new one over it. That removes the
+          part hardest to justify — a second set of emitters with their own
+          gravity — and explains why the coupling had to be two-way, since a
+          phase cannot be independent of the pulses carrying it.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>And is it the charge of an electron? Probably
+        not — and not for the obvious reason.</b> The composition test is too
+      weak to settle it: charges per kilogram are 1.196·10<Sup>27</Sup> for
+      hydrogen and 1.029·10<Sup>27</Sup> at <V>Y</V> = 0.28, a 2.3% spread
+      across the real range, which is 0.57% in <V>v</V> — twenty times under
+      Tully–Fisher’s own scatter. In ordinary matter charge and mass are
+      proportional to better than a percent.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>What kills it is the opposite end.</b> If layer
+      two were charge, a body of <i>neutral</i> constituents would get no halo
+      at all. But the most dark-dominated systems known — clusters and dwarf
+      spheroidals — show the <i>largest</i> discrepancies, and they are the ones
+      with the fewest charges per unit mass. The mechanism predicts exactly the
+      reverse ordering. The phase reading is better here too:{' '}
+      <b style={{ color: INK }}>a phase belongs to every pulse</b>, so every
+      gram of anything has one, charged or not — and the halo goes to all matter
+      equally, which is what is observed.
+    </Note>
+
+    <Head>and then it was tested</Head>
+
+    <Note>
+      <b style={{ color: INK }}>Test A — do the model’s own phases cancel to
+        √<V>N</V>?</b> Not assumed random: <i>inStep</i> says two emitters differ
+      in phase by <V>ω</V>Δ<V>r</V>/<V>c</V> = <V>m</V>Δ<V>r</V>. So{' '}
+      <V>N</V> emitters at random places in a ball of radius <V>R</V>, each given
+      the phase its position implies, summed. At{' '}
+      <V>mR</V> = 10<Sup>−2</Sup> the sum is 1.000·10<Sup>3</Sup> out of
+      10<Sup>3</Sup> — fully coherent. At <V>mR</V> = 10<Sup>4</Sup> it is
+      3.164·10<Sup>2</Sup> against √<V>N</V> = 3.16·10<Sup>2</Sup> —{' '}
+      <b style={{ color: INK }}>exactly the root</b>, with the crossover at{' '}
+      <V>mR</V> ≈ 2π where <i>inStep</i> puts it. The √<V>M</V> half is real,
+      and it is not an assumption about randomness.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>Test B — does locking to a plane change the
+        radial law? It does not.</b> Carriers from a point, turning by a small
+      angle each step, locked to one transverse direction or free in two:
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}>turn 0.002/step</span>,
+        <>locked −2.000, free −2.000 — difference <b style={{ color: INK }}>0.000</b></>],
+      [<span style={{ color: FAINT }}>turn 0.010/step</span>,
+        <>locked −2.000, free −1.998 — difference 0.002</>],
+      [<span style={{ color: FAINT }}>turn 0.050/step</span>,
+        <>locked −1.964, free −1.929 — difference 0.034</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>Locked and free agree to three decimal
+        places.</b> The number of transverse directions makes no difference to
+      the radial law at all — and the reason is{' '}
+      <i>flux conservation</i>, which sideways wandering cannot beat.{' '}
+      <V>N</V> carriers leave, <V>N</V> cross every sphere, the sphere has area
+      4π<V>r</V><Sup>2</Sup>. The 1/<V>r</V> appears only when the walk turns{' '}
+      <i>diffusive</i>, because then radial progress slows as{' '}
+      <V>cλ</V>/2<V>r</V> — and diffusion needs <i>many</i> resets, not few.
+      (A first run of this had the per-step turn at 0.25 rad, so every case had
+      already diffused and all four came out identical; and a fourth row at 0.2
+      gives −3.2 and −5.4, which is a truncation artefact rather than a
+      measurement of the diffusive slope.)
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So the sheet claim was wrong, and it is worth
+        saying where.</b> “The plane holds the carrier’s own line, so only the
+      widening flattens” does not give 1/<V>r</V>; widening does not touch the
+      radial profile. The permutation search two steps earlier had this right —
+      dense → 1/<V>r</V>, thin → 1/<V>r</V><Sup>2</Sup>,{' '}
+      <i>sign backwards</i> — and the sheet story talked its way out of a correct
+      result. The simulation puts it back.{' '}
+      <b style={{ color: INK }}>That retires the 2D transport mechanism</b>, and
+      with it the <V>a</V><Sub>0</Sub> prediction that rode on it and the derived
+      interpolation function, both of which assumed the locking worked. They are
+      kept above as a route that was tried, not as results.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>What survives is Test A.</b> Phase cancellation
+      is real, measured, and follows from the model’s own <i>inStep</i> rather
+      than from a new assumption — so the √<V>M</V> half stands on its own. The
+      radial law is unexplained again, and the obstruction is exactly what it was
+      before any of this: <V>n</V> ∝ 1/<V>r</V> needs the carriers to slow, and
+      everything in this model moves at <V>c</V>.
+    </Note>
+
+    <Head>and speed is a budget, not a constant</Head>
+
+    <Note>
+      “Everything moves at <V>c</V>” was quoting half the file at the other
+      half. It rejects <i>idling</i> for massive particles — moving on a
+      fraction <V>β</V> of ticks gives (1−<V>β</V>) where relativity wants
+      √((1−<V>β</V>)(1+<V>β</V>)), and picks a frame. But the{' '}
+      <i>zigzag</i> says a thing steps <i>every</i> tick and its net speed is the
+      imbalance, and that <b style={{ color: INK }}>the updates <i>are</i> the
+        reversals</b>. A net drift below <V>c</V> is not forbidden; it is this
+      model’s own account of what speed is.
+    </Note>
+
+    <Note>
+      And that reopens everything, because flux conservation reads{' '}
+      <V>Φ</V> = 4π<V>r</V><Sup>2</Sup><V>nv</V>. With <V>v</V> constant,{' '}
+      <V>n</V> ∝ 1/<V>r</V><Sup>2</Sup> and no wandering changes it — which is
+      what the last test showed. With <V>v</V> varying, what is needed is simply{' '}
+      <V>v</V> ∝ 1/<V>r</V>. And the model has a reason for the drift to depend
+      on density, out of pieces already here: speed is the share of ticks spent
+      moving rather than updating; a carrier accumulates phase while travelling
+      free; <i>through</i> says a meeting resets it; so the accumulated state ∝
+      the distance since the last meeting, 1/<V>σn</V>, and the moving share ∝{' '}
+      <V>σn</V>.
+    </Note>
+
+    <Eq derive={REACH} open={show}
+      note="dense and the budget caps at c; thin and the carrier crawls">
+      <V>v</V> = <V>c</V>·min(1, <V>n</V>/<V>n</V><Sub>c</Sub>)
+    </Eq>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>dense, <V>n</V> &gt; <V>n</V><Sub>c</Sub></span>,
+        <><V>v</V> = <V>c</V>, so <V>n</V> = <V>Φ</V>/4π<V>r</V><Sup>2</Sup><V>c</V>{' '}
+          ∝ 1/<V>r</V><Sup>2</Sup> — <b style={{ color: INK }}>Newton</b></>],
+      [<span style={{ color: DERIVED }}>thin, <V>n</V> &lt; <V>n</V><Sub>c</Sub></span>,
+        <><V>v</V> = <V>cn</V>/<V>n</V><Sub>c</Sub>, so flux conservation goes{' '}
+          <i>quadratic</i>: <V>n</V> = √(<V>Φn</V><Sub>c</Sub>/4π<V>c</V>)/<V>r</V>{' '}
+          ∝ 1/<V>r</V> — <b style={{ color: INK }}>MOND</b></>],
+      [<span style={{ color: DERIVED }}>and the mass comes free</span>,
+        <>In the thin branch <V>n</V> ∝ √<V>Φ</V> and <V>Φ</V> ∝ <V>M</V>, so{' '}
+          <V>g</V> ∝ √<V>M</V>/<V>r</V> and{' '}
+          <b style={{ color: INK }}><V>v</V><Sub>rot</Sub><Sup>4</Sup> ∝ <V>M</V></b>.
+          Both halves from one mechanism — and the √<V>M</V> is not the phase
+          cancellation at all. It falls out because the flux equation becomes
+          quadratic in <V>n</V> once the speed is proportional to <V>n</V>.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>That is the non-linearity the theorem
+        demanded</b>, and it lives in the <i>transport</i> rather than in the
+      source — which is why every earlier attempt to put it in the source failed.
+      And the switch is at a <i>fixed occupancy</i>, hence fixed <V>g</V>, since{' '}
+      <V>g</V> ∝ <V>n</V>. Not a length, not a mass, not a count of
+      constituents. Every requirement the search accumulated, at once.
+    </Note>
+
+    <Note>
+      Measured by integrating the transport rather than trusting the algebra:{' '}
+      <b style={{ color: INK }}>−2.0000 inside and −1.0000 outside</b>, and the
+      outer density against √<V>Φ</V> comes to 10.0000 for a hundredfold mass
+      against √100 = 10. Exact.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>What it costs.</b> A carrier that crawls is a
+      carrier that is <i>late</i>. At 20 kpc the drift is 0.4<V>c</V> and a
+      galaxy’s crossing time goes from 98 to 244 kyr — harmless. Further out it
+      is not: at <V>n</V>/<V>n</V><Sub>c</Sub> = 10<Sup>−3</Sup> a cluster-scale
+      field takes 10<Sup>7</Sup> years to establish.{' '}
+      <b style={{ color: INK }}>Gravity should lag in the deep-field regime</b>,
+      and merging systems are where that would show. It is not relativity broken
+      — the carriers still step one cell a tick, and the density setting the
+      drift is a scalar, so nothing exceeds <V>c</V> and nothing picks a frame.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And chasing that link turns up a sign conflict
+        in the chain above.</b> It used “a meeting <i>resets</i> the accumulated
+      state, so meetings free up ticks and the carrier moves faster”. But{' '}
+      <i>through</i> — the model’s own rule, and a measured one — says a charge
+      arriving at an occupied cell annihilates or <i>reverses</i>. A reversal
+      does not clear internal state; it turns the carrier round, which{' '}
+      <i>slows</i> the net drift. So <i>through</i> gives{' '}
+      <V>v</V> falling with <V>n</V> and the chain gives it rising, and{' '}
+      <V>v</V> ∝ <V>n</V> is exactly what the √<V>M</V> depends on.{' '}
+      <b style={{ color: INK }}>A real problem, not a detail</b> — and the sort
+      that would have gone unnoticed if the link had been left as an IOU.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>But there is a connection with the right sign,
+        and it is already here: <i>inStep</i>.</b> It says emitters closer than
+      a Compton wavelength hold a common phase and further apart drift
+      independently. Read as a <i>budget</i> rather than an interference
+      condition: <b style={{ color: INK }}>in step</b>, one phase is shared
+      between many carriers, the update is paid <i>once</i>, and each is free to
+      spend its ticks moving — dense → fast. <b style={{ color: INK }}>Out of
+        step</b>, each carries its own phase and pays every tick — thin → slow.
+      Right sign, no new rule, and it does not fight <i>through</i>: reversals
+      still happen, but what sets the drift is what a tick is <i>spent on</i>,
+      not which way the step points.
+    </Note>
+
+    <Eq derive={REACH} open={show}
+      note="a Compton wavelength is a fixed density — the shape the search demanded">
+      in step ⇔ spacing &lt; 2π/<V>m</V>
+      <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+      <V>n</V><Sub>c</Sub> = (<V>m</V>/2π)<Sup>3</Sup>
+    </Eq>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>which fixes the emitter</span>,
+        <>The required <V>n</V><Sub>c</Sub> = 2.203·10<Sup>−61</Sup> per cell
+          gives <V>m</V> = 5.150·10<Sup>−29</Sup> kg ={' '}
+          <b style={{ color: INK }}>28.9 MeV/<V>c</V><Sup>2</Sup></b>.</>],
+      [<span style={{ color: BORROWED }}>and there is no such particle</span>,
+        <>The proton gives <V>n</V><Sub>c</Sub> 3.4·10<Sup>4</Sup> too dense, the
+          electron 5.5·10<Sup>−6</Sup> too thin. The muon at 106 MeV and the
+          pion at 135 are the nearest things and both are four to eight times
+          too heavy.</>],
+      [<span style={{ color: DERIVED }}>but three of four are fixed</span>,
+        <>The <i>sign</i>, the <i>crossover shape</i>, and{' '}
+          <i>no new rule needed</i> — all by something already derived and
+          measured in the file. Only the number is wrong, and it is wrong by a
+          stateable amount.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>Which says exactly what to look for:</b> either
+      an emitter near 29 MeV, or a reason the relevant Compton wavelength is not
+      the constituent’s own. And there is an obvious place to look for the
+      second — <i>inStep</i> takes the mass of what is <i>emitting</i>. If the
+      phase that matters belongs to the <i>carrier</i> rather than the source,
+      then 29 MeV is a statement about the carrier — and this model has{' '}
+      <b style={{ color: INK }}>never assigned the carrier a mass at all</b>.
+      The pull is carried by charges whose own rate was never fixed, which makes
+      this a gap rather than a contradiction, and the first thing{' '}
+      <i>physics.ts</i> would have to answer.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And a correction: the a₀ prediction was
+        over-retracted.</b> It was written off along with the 2D transport, but
+      it used only <V>g</V> ∝ <V>n</V> with the constant 4π<V>G</V>/<K>SHEET</K>{' '}
+      — the geometry of emission — and{' '}
+      <V>n</V><Sub>c</Sub> = 1/<V>t</V><Sub>0</Sub>, one meeting per carrier
+      lifetime. <i>Neither mentions the sheet.</i> The transport failed and the
+      prediction does not depend on it.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So how do you derive it without data?</b>{' '}
+      Enumerate the inputs that exist at all — this is the whole list, and a
+      derivation can use nothing else: four counted numbers (<K>SHEET</K>,{' '}
+      <K>WAYS</K>, <K>BITE</K>, <K>GRAVITY</K>), two units (the cell and the
+      tick, fixed by the calibration), and one dynamical quantity,{' '}
+      <V>t</V><Sub>0</Sub> = 8.08·10<Sup>60</Sup> ticks. Then see which
+      combinations can reach the size at all.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}>the ceiling — one emission a tick</span>,
+        <><V>n</V><Sub>c</Sub> = 1, which is 4.5·10<Sup>60</Sup> too dense</>],
+      [<span style={{ color: FAINT }}>the floor — one emission per age</span>,
+        <>7.6·10<Sup>−186</Sup>, which is 10<Sup>124</Sup> too thin</>],
+      [<span style={{ color: DERIVED }}>one <i>meeting</i> per carrier lifetime</span>,
+        <>1.24·10<Sup>−61</Sup> against the 2.20·10<Sup>−61</Sup> that{' '}
+          <V>a</V><Sub>0</Sub> requires —{' '}
+          <b style={{ color: INK }}>out by 1.78</b></>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>Only one route lands</b>, and it is not a fit
+      surviving among many — it is the only candidate the available ingredients
+      can even build at the right size. A carrier crosses one cell a tick and
+      lives <V>t</V><Sub>0</Sub> ticks, sweeping <K>BITE</K> cells of
+      cross-section, so it meets <V>n</V>·<K>BITE</K>·<V>t</V><Sub>0</Sub>{' '}
+      others; the crossover is where that count is <i>one</i> — the boundary
+      between a carrier whose history contains an interaction and one whose does
+      not. So <V>n</V><Sub>c</Sub> = 1/<K>BITE</K><V>t</V><Sub>0</Sub>, and with{' '}
+      <V>g</V> = (4π<V>G</V>/<K>SHEET</K>)<V>n</V>,{' '}
+      <b style={{ color: INK }}><V>a</V><Sub>0</Sub> = 4π<V>G</V>/(<K>SHEET</K>·<V>t</V><Sub>0</Sub>)
+        = 6.74·10<Sup>−11</Sup></b> against 1.20·10<Sup>−10</Sup> measured. No{' '}
+      <V>a</V><Sub>0</Sub> anywhere in the derivation.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And it then predicts the carrier mass</b>, which
+      was the open number. <i>inStep</i> wants{' '}
+      <V>n</V><Sub>c</Sub> = (<V>m</V>/2π)<Sup>3</Sup>; setting the two equal
+      gives <V>m</V> = 2π(1/<V>t</V><Sub>0</Sub>)<Sup>⅓</Sup> ={' '}
+      <b style={{ color: INK }}>23.8 MeV/<V>c</V><Sup>2</Sup></b>, against the
+      28.9 MeV that <V>a</V><Sub>0</Sub> demands — a ratio of 1.212.{' '}
+      <b style={{ color: INK }}>Two independent routes to the same number,
+        agreeing to 21%.</b> One counts meetings over a lifetime, the other asks
+      when carriers fall out of step. They did not have to agree at all, and it
+      is the first time in this line of work that two derivations have met.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>The bills, and they are specific.</b> The{' '}
+      <i>1.78 is uncounted</i> — and it is the <i>same</i> 1.78 at every step, so
+      it is one missing factor rather than several; somewhere a 2, a π or a √π is
+      not being counted. <V>t</V><Sub>0</Sub> <i>is not a constant</i>, so{' '}
+      <V>a</V><Sub>0</Sub> ∝ 1/<V>t</V> and the carrier mass goes as{' '}
+      <V>t</V><Sup>−⅓</Sup> — a mass that changes with the age is a strange
+      object, and it is the same prediction already flagged, with high-redshift
+      curves going the wrong way. And <i>24 MeV is not a particle</i>: the muon
+      is 106 and the pion 135. Either something sits there, or the Compton
+      wavelength that matters is not a particle’s at all.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the 1.78 is mostly countable — it was never
+        one number.</b> The count was “a carrier sweeps <K>BITE</K> cells a tick
+      for <V>t</V><Sub>0</Sub> ticks, so it meets{' '}
+      <V>n</V>·<K>BITE</K>·<V>t</V><Sub>0</Sub> others; set that to one”. Two
+      things in it were left at one and should not have been, and both are
+      already derived elsewhere in this file: <i>share</i> = ½, since only
+      opposite polarities annihilate and <i>opposed</i> pairs at random; and{' '}
+      ⟨|<V>v</V><Sub>rel</Sub>|⟩ = 4/3, since both things move at <V>c</V> and
+      the rate carries their <i>relative</i> speed — the same average that
+      corrected the screening geometry.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}>nothing counted</span>,
+        <><V>a</V><Sub>0</Sub> = 6.74·10<Sup>−11</Sup> — 0.562 of measured</>],
+      [<span style={{ color: DERIVED }}><i>share</i> = ½</span>,
+        <>1.348·10<Sup>−10</Sup> — 1.124</>],
+      [<span style={{ color: FAINT }}>⟨|<V>v</V><Sub>rel</Sub>|⟩ = 4/3 alone</span>,
+        <>5.06·10<Sup>−11</Sup> — 0.421</>],
+      [<span style={{ color: DERIVED }}>both</span>,
+        <>1.011·10<Sup>−10</Sup> — 0.843</>],
+    ]} />
+
+    <Note>
+      They pull <i>opposite</i> ways — fewer meetings puts the threshold at a
+      higher density and raises <V>a</V><Sub>0</Sub>; a larger relative speed
+      means more meetings and lowers it.{' '}
+      <b style={{ color: INK }}>And the relative-speed factor is not actually
+        4/3 here</b>, which is the interesting part rather than a nuisance: 4/3
+      is the <i>isotropic</i> average, but a source’s own carriers all stream
+      radially outward — nearly comoving, and two things moving the same way at{' '}
+      <V>c</V> never meet. So the true factor sits between 1 and 4/3, and with{' '}
+      <i>share</i> counted{' '}
+      <b style={{ color: INK }}><V>a</V><Sub>0</Sub> ∈ [1.011, 1.348]·10<Sup>−10</Sup></b>{' '}
+      — the measured 1.200 sitting inside, 56% of the way across.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And it tightens the two routes against each
+        other</b>, which is the better test since neither involves{' '}
+      <V>a</V><Sub>0</Sub>. Each <V>n</V><Sub>c</Sub> predicts a carrier mass
+      through <V>n</V><Sub>c</Sub> = (<V>m</V>/2π)<Sup>3</Sup>: bare gives 23.8
+      MeV, <i>share</i> gives 30.0, both give 27.3, against the 28.9 that{' '}
+      <V>a</V><Sub>0</Sub> demands.{' '}
+      <b style={{ color: INK }}>From 21% apart to 4%.</b> Two derivations that
+      share no steps now meet inside the uncertainty of either.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>What is left.</b> <i>What a carrier meets</i> is
+      now the only thing between this and a number — its own source’s outflow,
+      comoving and suppressed, or an ambient sea, isotropic and 4/3? That is a
+      question about <i>field.ts</i> and it is answerable by simulation.{' '}
+      <V>t</V><Sub>0</Sub> not being a constant is unfixable and stays a
+      prediction. And ~28 MeV is still not a particle: the bracket is 27–30 and
+      nothing sits there.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>A discipline note.</b> (4/3)<Sup>2</Sup> = 1.7778
+      against the observed 1.7799 — a match to 0.1%.{' '}
+      <i>Not claimed, and it should not be:</i> <V>a</V><Sub>0</Sub> itself is
+      quoted at ~10%, so 0.1% is far inside the noise, and √π = 1.772 fits just
+      as well. The two factors above are worth having because each was{' '}
+      <i>derived somewhere else in this file</i> — not because their product
+      lands well.
+    </Note>
+
+    <Head>and simulating the last open thing breaks it</Head>
+
+    <Note>
+      <b style={{ color: INK }}>The suppression is real and strong.</b> A source
+      of radius <V>R</V>, a field point at <V>r</V>, two carriers arriving there
+      from random parts of it, each weighted by the flux that part contributes:
+      ⟨|<V>v</V><Sub>rel</Sub>|⟩/<V>c</V> is 0.560 at{' '}
+      <V>r</V>/<V>R</V> = 1.5, 0.162 at 5, 0.027 at 30, 0.008 at 100. It falls
+      as <V>R</V>/<V>r</V> exactly as the geometry says — far out the source
+      subtends a small angle and its carriers all go the same way.{' '}
+      <b style={{ color: INK }}>A point source is the limit: its carriers are
+        perfectly comoving and never meet each other at all.</b>
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>But a carrier does not only meet those.</b> The
+      rest of the universe is emitting too, and that sea arrives isotropically
+      at <V>ρ</V>·<K>SHEET</K>·<V>R</V><Sub>h</Sub> = 1.73·10<Sup>−60</Sup> per
+      cell. Against the galaxy’s own carriers: 6.3·10<Sup>6</Sup> times smaller
+      at 1 AU, comparable by 8 kpc, and{' '}
+      <b style={{ color: INK }}>thirty-five times <i>denser</i> than the
+        galaxy’s own by 20 kpc</b>.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>and that breaks it</span>,
+        <>The crossover wants <V>n</V><Sub>c</Sub> = 2.48·10<Sup>−61</Sup> and
+          the sea alone is 1.73·10<Sup>−60</Sup> —{' '}
+          <b style={{ color: INK }}>seven times above it, everywhere</b>. A
+          carrier anywhere meets 7.0 others in its life from the background
+          alone, so the switch is thrown in every direction at every radius. No
+          MOND regime; Newton everywhere.</>],
+      [<span style={{ color: BORROWED }}>the conflation that hid it</span>,
+        <><V>g</V> ∝ <V>n</V> is about the <i>source’s own</i> carriers, while
+          the meeting rate is about <i>all</i> of them.{' '}
+          <b style={{ color: INK }}>Two densities, one symbol.</b> The crossover
+          was meant to depend on the source, so it happens at a radius — but the
+          meeting rate does not depend on the source at all, so it happens
+          nowhere, or everywhere.</>],
+      [<span style={{ color: DERIVED }}>and what saves it, barely</span>,
+        <><i>reach</i> screens the sea with a Yukawa length of 1.6 Gpc, so
+          distant matter does not count. Redone with the cut-off,{' '}
+          <V>ρ</V><K>SHEET</K><V>λ</V> = 6.55·10<Sup>−61</Sup> against{' '}
+          <V>n</V><Sub>c</Sub> = 2.48·10<Sup>−61</Sup> — a ratio of{' '}
+          <b style={{ color: INK }}>2.65</b> instead of 7. Still above, but
+          inside the uncertainty of everything feeding it.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>So the verdict is marginal rather than
+        dead</b>, and it turns on <i>reach</i> — a length this file derived for
+      entirely unrelated reasons and called its one genuine prediction. The
+      mechanism does not have a comfortable MOND regime; it has one that
+      switches on <i>barely</i>, and only because gravity’s own range cuts the
+      sea off. That is a much weaker claim than the sections above it make, and
+      it is what the simulation actually supports. (The alternative branch — only
+      the source’s own carriers counting, so the crossover <i>is</i> radial —
+      fails differently: the rate goes as <V>R</V>/<V>r</V><Sup>3</Sup>, giving a
+      crossover radius ∝ <V>M</V><Sup>⅓</Sup> rather than √<V>M</V>, and
+      Tully–Fisher goes wrong again. Neither branch works, for different
+      reasons.)
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>One link is still owed:</b> that the update cost
+      goes as the accumulated phase. Everything above hangs on it, and it is the
+      only part not already in the file — a question about <i>physics.ts</i>,
+      what a tick is spent on, rather than about galaxies.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>Where it leaves things.</b> √<V>M</V> in the
+      source: done, from the XOR. 1/<V>r</V><Sup>2</Sup> in the reach: done,
+      from the emitters. A flat curve and <V>v</V><Sup>4</Sup> ∝ <V>M</V>:
+      both follow exactly. The scale <V>a</V><Sub>0</Sub>: sets κ, still not
+      counted, still 4.5 off <K>BIAS</K>/<V>t</V><Sub>0</Sub>. And the
+      crossover: <b style={{ color: INK }}>open, and now the only open
+        thing</b> — and stated exactly, it is not “why does the root appear” but{' '}
+      <i>why does the product switch off</i>, without counting constituents.
+      Three turns ago this was five separate unknowns; it is one. And a bonus
+      that has nothing to do with <V>a</V><Sub>0</Sub>: a layer carrying
+      “pulse = which particle” is where a <b style={{ color: INK }}>particle
+        spectrum</b> could come from, and this model has none.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the sign is the interesting part.</b>{' '}
+      High-redshift discs at <V>z</V> ~ 1–2 are reported with{' '}
+      <i>declining</i> rotation curves — more baryon-dominated, more Keplerian,
+      which is what a <i>smaller</i> <V>a</V><Sub>0</Sub> would give. This model
+      wants a larger one. If that reading holds,{' '}
+      <V>a</V><Sub>0</Sub> ∝ 1/<V>t</V> is excluded, and with it the only native
+      hook the model has at galactic scale. Which is the right kind of trouble:
+      the coincidence <V>a</V><Sub>0</Sub> ≈ <V>cH</V><Sub>0</Sub> is normally
+      an ornament precisely because nothing forces it to hold at other epochs.
+      Here the frontier forces it, so{' '}
+      <b style={{ color: INK }}>the model cannot decline the test</b>.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And Newton and general relativity fail this
+        identically</b>, which is worth being plain about. The curve above{' '}
+      <i>is</i> the Newtonian prediction; general relativity’s correction to a
+      circular orbit is <V>u</V> = 1.7·10<Sup>−7</Sup>, shifting 220 km/s by
+      4·10<Sup>−5</Sup>. All three agree to six decimal places and all three
+      miss by a factor of 3 at 20 kpc and 4.5 at 30. This is not a strike
+      against the model — it is the bill every theory of gravity has carried
+      since the 1970s, and this one inherits it exactly{' '}
+      <i>because</i> it reproduces general relativity. What would count against
+      it is failing where general relativity succeeds, and it does not do that
+      here. Dark matter costs the same thing here as there: either a particle
+      the theory permits and does not predict — <i>inStep</i> already wants{' '}
+      <V>m</V> &lt; 2π/<V>R</V>, which at 30 kpc is 1.3·10<Sup>−27</Sup> eV,
+      the ultralight window — or a modified law, which is the floor above.
+    </Note>
+
     <Note>
       <b style={{ color: INK }}>So what is left owed</b>, ranked: the light
       elements, with no mechanism and no room for one; the microwave background,
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
new file mode 100644
index 0000000..2eb5e64
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
@@ -0,0 +1,267 @@
+/**
+ * A GALAXY, RUN THROUGH THE MODEL'S OWN FORCE LAW — and drawn, because the
+ * shape of the disagreement is the whole point and a table hides it.
+ *
+ * NO SHELL THEOREM IS ASSUMED ANYWHERE HERE. The radial pull at each radius is
+ * summed directly over the entire mass distribution, ring by ring and angle by
+ * angle, so the question "does the mass outside cancel, and with what sign" is
+ * answered by the sum rather than by a theorem that only holds for spheres.
+ *
+ * WHAT THE MODEL PREDICTS FOR A GALAXY, and why it is just Newton on the
+ * baryons — every other term it owns is checked and negligible:
+ *
+ *     the pull    GRAVITY·m_a·m_b/R²      G_LATTICE·l_P³/(MU·t_P²) = G exactly
+ *     `reach`     Yukawa, λ = 1.6 Gpc     a deficit of 2·10⁻³ % at 30 kpc
+ *     `carry`     1 + 2v²/c²              1.1·10⁻⁶ at 220 km/s
+ *     `shows`     self-screening          nothing; a galaxy is transparent
+ *
+ * and the gap to close at 20 kpc is +195%. Between five and eight orders too
+ * small, with no dial in the model that reaches.
+ *
+ * AND THE ANSWER TO "DOES THE OUTSIDE CANCEL". It does not, and it is worth
+ * being exact about the sign because the intuition runs the other way:
+ *
+ *     r (kpc)   from inside r   from outside r   net        outside/inside
+ *     2         6.171e−10       −1.643e−10       4.528e−10  −26.6%
+ *     8         1.701e−10       −3.041e−11       1.397e−10  −17.9%
+ *     20        2.863e−11       −2.066e−12       2.656e−11   −7.2%
+ *     30        1.208e−11       −4.537e−13       1.163e−11   −3.8%
+ *
+ * (m/s², positive INWARD). For a SPHERE an exterior shell contributes exactly
+ * nothing. A disc is not a sphere, so its exterior does act — and it pulls
+ * OUTWARD, because the near arc of an exterior ring is closer than the far arc
+ * and wins the inverse square. It does not cancel, and what it does is the
+ * OPPOSITE of helping: it takes 27% off at 2 kpc and 4% off at 30.
+ *
+ * So the missing gravity cannot come from the outside failing to cancel. The
+ * outside is already counted, already fails to cancel, and already subtracts.
+ */
+
+import { CanvasView, Surface } from "./canvas";
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19;
+const A0 = 1.2e-10;                                     // the MOND scale, for reference
+
+/** the Milky Way's baryons, as measured rather than as fitted */
+const DISK = { M: 5.0e10 * MSUN, Rd: 2.6 * KPC, h: 0.30 * KPC };
+const GAS = { M: 1.2e10 * MSUN, Rd: 7.0 * KPC, h: 0.15 * KPC };
+const BULGE = { M: 0.9e10 * MSUN, a: 0.5 * KPC };
+
+type Disc = typeof DISK;
+
+const sigma = (d: Disc, R: number) => d.M / (2 * Math.PI * d.Rd * d.Rd) * Math.exp(-R / d.Rd);
+
+/**
+ * The radial pull at r in the plane from one exponential disc, summed over the
+ * disc — kept split into the part inside r and the part outside it, since that
+ * split is the thing being asked about. Positive is inward.
+ */
+const discPull = (d: Disc, r: number, NR = 420, NP = 480) => {
+  const RMAX = 12 * d.Rd;
+  let inside = 0, outside = 0;
+  for (let i = 0; i < NR; i++) {
+    const R = RMAX * (i + 0.5) / NR, dR = RMAX / NR;
+    const s = sigma(d, R) * R * dR;
+    let acc = 0;
+    for (let j = 0; j < NP; j++) {
+      const p = 2 * Math.PI * (j + 0.5) / NP;
+      const dx = R * Math.cos(p) - r, dy = R * Math.sin(p);
+      const s2 = dx * dx + dy * dy + d.h * d.h;
+      acc += dx / Math.pow(s2, 1.5);
+    }
+    const bit = -G * s * acc * (2 * Math.PI / NP);
+    if (R < r) inside += bit; else outside += bit;
+  }
+  return { inside, outside };
+};
+
+/** the bulge is spherical, so here the shell theorem really does hold */
+const bulgePull = (r: number) =>
+  G * BULGE.M * (r * r) / Math.pow(r + BULGE.a, 2) / (r * r);
+
+export type Point = {
+  r: number;          // metres
+  disc: number; gas: number; bulge: number;
+  inside: number; outside: number; total: number;
+};
+
+/** everything, at one radius */
+export const pullAt = (r: number): Point => {
+  const a = discPull(DISK, r), b = discPull(GAS, r), c = bulgePull(r);
+  return {
+    r,
+    disc: a.inside + a.outside, gas: b.inside + b.outside, bulge: c,
+    inside: a.inside + b.inside + c,
+    outside: a.outside + b.outside,
+    total: a.inside + a.outside + b.inside + b.outside + c,
+  };
+};
+
+const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+
+/** computed once and shared by both panels */
+const CURVE: Point[] = (() => {
+  const out: Point[] = [];
+  for (let i = 1; i <= 60; i++) out.push(pullAt(i * 0.5 * KPC));
+  return out;
+})();
+
+const OBSERVED = 220;                                   // km/s, flat, 5…25 kpc
+
+// ---------------------------------------------------------------------------
+
+const INK = "#c8cbd4", FAINT = "#5a5f6e", GRID = "rgba(255,255,255,0.055)";
+const MODEL = "#4aa8eb", DATA = "#eb964a", FLOOR = "#8bd48b";
+const PALE = "#6f7ba8", GASC = "#59806a", BULGEC = "#8a6f8f";
+
+const frame = (s: Surface, pad = 46) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = "#08090d";
+  ctx.fillRect(0, 0, width, height);
+  return {
+    x0: pad, x1: width - 14, y0: 12, y1: height - 26,
+    w: width - 14 - pad, h: height - 38,
+  };
+};
+
+const axes = (
+  s: Surface, box: ReturnType<typeof frame>,
+  xmax: number, ymin: number, ymax: number,
+  xticks: number[], yticks: number[], yfmt: (v: number) => string,
+) => {
+  const { ctx } = s;
+  const X = (r: number) => box.x0 + box.w * r / xmax;
+  const Y = (v: number) => box.y1 - box.h * (v - ymin) / (ymax - ymin);
+
+  ctx.font = "400 10px ui-monospace, Menlo, monospace";
+  ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+  for (const t of yticks) {
+    ctx.beginPath(); ctx.moveTo(box.x0, Y(t)); ctx.lineTo(box.x1, Y(t)); ctx.stroke();
+    ctx.fillStyle = FAINT; ctx.textAlign = "right";
+    ctx.fillText(yfmt(t), box.x0 - 6, Y(t) + 3);
+  }
+  for (const t of xticks) {
+    ctx.beginPath(); ctx.moveTo(X(t), box.y0); ctx.lineTo(X(t), box.y1); ctx.stroke();
+    ctx.fillStyle = FAINT; ctx.textAlign = "center";
+    ctx.fillText(String(t), X(t), box.y1 + 15);
+  }
+  ctx.textAlign = "left";
+  return { X, Y };
+};
+
+const path = (
+  s: Surface, pts: Point[], X: (r: number) => number, Y: (v: number) => number,
+  of: (p: Point) => number, css: string, wide = 1.6, dash: number[] = [],
+) => {
+  const { ctx } = s;
+  ctx.strokeStyle = css; ctx.lineWidth = wide; ctx.setLineDash(dash);
+  ctx.beginPath();
+  pts.forEach((p, i) => {
+    const x = X(p.r / KPC), y = Y(of(p));
+    if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
+  });
+  ctx.stroke();
+  ctx.setLineDash([]);
+};
+
+const tag = (s: Surface, x: number, y: number, text: string, css: string) => {
+  const { ctx } = s;
+  ctx.fillStyle = css;
+  ctx.font = "500 11px ui-sans-serif, system-ui, sans-serif";
+  ctx.fillText(text, x, y);
+};
+
+/**
+ * THE ROTATION CURVE. What the model says, what each component of the baryons
+ * contributes, what is measured, and — for scale rather than as a claim — what
+ * a floor at a₀ would give.
+ */
+const curve = (s: Surface) => {
+  const box = frame(s);
+  const XMAX = 30, YMAX = 260;
+  const { X, Y } = axes(s, box, XMAX, 0, YMAX,
+    [5, 10, 15, 20, 25, 30], [50, 100, 150, 200, 250], v => String(v));
+
+  // the measured flat disc, 5…25 kpc
+  s.ctx.fillStyle = "rgba(235,150,74,0.10)";
+  s.ctx.fillRect(X(5), Y(OBSERVED + 12), X(25) - X(5), Y(OBSERVED - 12) - Y(OBSERVED + 12));
+  path(s, CURVE.filter(p => p.r / KPC >= 3), X, Y, () => OBSERVED, DATA, 2);
+
+  path(s, CURVE, X, Y, p => Math.sqrt(A0 * p.total * p.r) / 1e3, FLOOR, 1.3, [4, 3]);
+
+  path(s, CURVE, X, Y, p => kms(p.disc, p.r), PALE, 1.1);
+  path(s, CURVE, X, Y, p => kms(p.gas, p.r), GASC, 1.1);
+  path(s, CURVE, X, Y, p => kms(p.bulge, p.r), BULGEC, 1.1);
+  path(s, CURVE, X, Y, p => kms(p.total, p.r), MODEL, 2.4);
+
+  // placed against the computed values so nothing sits on a line it does not
+  // belong to: disc peaks 173 near 6, gas 52 at 21, bulge 102 at 2.6, model
+  // 168 at 11.5, floor 187 at 21, and the measured band spans 208…232.
+  tag(s, X(13.4), Y(243), "measured — flat at 220 km/s", DATA);
+  tag(s, X(21.4), Y(172), "a floor at a₀", FLOOR);
+  tag(s, X(11.4), Y(190), "THE MODEL — Newton on the baryons", MODEL);
+  tag(s, X(5.8), Y(152), "stars", PALE);
+  tag(s, X(21.0), Y(40), "gas", GASC);
+  tag(s, X(2.6), Y(88), "bulge", BULGEC);
+
+  s.ctx.fillStyle = FAINT;
+  s.ctx.font = "400 10px ui-monospace, Menlo, monospace";
+  s.ctx.textAlign = "center";
+  s.ctx.fillText("radius (kpc)", (box.x0 + box.x1) / 2, s.height - 4);
+  s.ctx.textAlign = "left";
+  s.ctx.fillText("km/s", 6, 20);
+};
+
+/**
+ * AND THE SPLIT, which is the thing actually being asked. Inward from the mass
+ * inside the orbit, outward from the mass beyond it, and the net.
+ */
+const split = (s: Surface) => {
+  const box = frame(s);
+  const XMAX = 30;
+  const top = 1.18, bot = -0.35;                          // fractions of `inside`
+  const { X, Y } = axes(s, box, XMAX, bot, top,
+    [5, 10, 15, 20, 25, 30], [1, 0.75, 0.5, 0.25, 0, -0.25],
+    v => v === 0 ? "0" : v.toFixed(2));
+
+  s.ctx.strokeStyle = "rgba(255,255,255,0.22)"; s.ctx.lineWidth = 1;
+  s.ctx.beginPath(); s.ctx.moveTo(box.x0, Y(0)); s.ctx.lineTo(box.x1, Y(0)); s.ctx.stroke();
+
+  path(s, CURVE, X, Y, p => 1, PALE, 1.6, [4, 3]);
+  path(s, CURVE, X, Y, p => p.outside / p.inside, DATA, 2.2);
+  path(s, CURVE, X, Y, p => p.total / p.inside, MODEL, 2.2);
+
+  tag(s, X(16.4), Y(1.09), "pull from inside r  (set to 1)", PALE);
+  tag(s, X(15), Y(0.80), "net", MODEL);
+  tag(s, X(13), Y(-0.16), "pull from OUTSIDE r — outward, so it subtracts", DATA);
+
+  s.ctx.fillStyle = FAINT;
+  s.ctx.font = "400 10px ui-monospace, Menlo, monospace";
+  s.ctx.textAlign = "center";
+  s.ctx.fillText("radius (kpc)", (box.x0 + box.x1) / 2, s.height - 4);
+  s.ctx.textAlign = "left";
+};
+
+const Panel = (
+  { paint, height, note }: { paint: (s: Surface) => void; height: number; note: string },
+) => <div style={{ marginBottom: "1.1rem" }}>
+  <div style={{
+    fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+    color: FAINT, marginBottom: 6,
+  }}>{note}</div>
+  <div style={{ height, background: "#08090d" }}>
+    <CanvasView animate={false} deps={[note]}
+      paint={() => ({ frame: (s: Surface) => paint(s) })} />
+  </div>
+</div>;
+
+/** the curve the model predicts, against the one that is measured */
+export const Rotation = ({ height = 340 }: { height?: number }) =>
+  <Panel paint={curve} height={height}
+    note="the Milky Way, summed directly over its baryons — no shell theorem" />;
+
+/** and where the pull comes from, inside the orbit and beyond it */
+export const Split = ({ height = 260 }: { height?: number }) =>
+  <Panel paint={split} height={height}
+    note="does the mass outside cancel? — as a fraction of the pull from inside" />;

From 4e14742ee34c71fae689846c1faab77e210213d5 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Wed, 12 Aug 2026 16:28:33 +0200
Subject: [PATCH 29/47] More thinking on dark matter

---
 .../2026.RayCalculiAndPhysics/echoes.tsx      |    6 +-
 .../2026.RayCalculiAndPhysics/gravity.ts      | 1229 +++++++++++++++-
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 1251 ++++++++++++++++-
 .../2026.RayCalculiAndPhysics/rotation.tsx    |  746 +++++++++-
 4 files changed, 3166 insertions(+), 66 deletions(-)

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/echoes.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/echoes.tsx
index 0ed4469..bdb33cf 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/echoes.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/echoes.tsx
@@ -65,7 +65,11 @@ const SPAN = 420;                     // how much of the signal is shown
 const strain = (t: number, gap: number) => {
   let h = 0;
   for (let n = 0; n < 40; n++) {
-    const at = t - n * gap;
+    // `n * gap` at n = 0 with gap = Infinity is 0·∞, which is NaN — and a NaN
+    // strain is a NaN y, which is a path the canvas silently declines to draw.
+    // Both no-echo lanes rendered as nothing at all, which read as a broken
+    // panel rather than as the measurement. The first arrival is always at t.
+    const at = n === 0 ? t : t - n * gap;
     if (at < 0) break;
     // each bounce loses most of the wave through the ring
     h += Math.pow(0.45, n) * Math.exp(-at / TAU) * Math.sin(OMEGA * at);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index b231b8a..e417bf5 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -2067,7 +2067,15 @@ export const foldAt = (mass: number, R: number) =>
 export const reach = (density: number) =>
   LIGHT / Math.sqrt(BITE * 0.5 * SHEET * density);
 
-/** And what that is as a fraction of the horizon, which is where it is a count. */
+/**
+ * And what that is as a fraction of the horizon, which is where it is a count.
+ *
+ * WITH A CONDITION ON IT THAT WAS NOT WRITTEN DOWN, and it is load-bearing.
+ * The density cancels here because `ρ = 3H²/8πG` was substituted, which is
+ * FRIEDMANN. The frontier cosmology below coasts and has no Friedmann equation,
+ * so nothing cancels and this becomes `0.361/√Ω` — see `reachesIn`, where at
+ * this model's own Ω it is 1.628 and the prediction stops predicting.
+ */
 export const REACHES = Math.sqrt(
   8 * Math.PI * G_LATTICE / (3 * BITE * 0.5 * SHEET));
 
@@ -2387,12 +2395,222 @@ export const REACHES = Math.sqrt(
  *     frontier   9.06·10¹²² cells of surface
  *
  * AND A BILL ON THE FRONTIER ITSELF. If it were ceiling-density MATTER rather
- * than fresh neutral space, one cell thick it would weigh 2·10¹¹⁵ kg against the
- * universe's 10⁵³ — 10⁶² times too much. So the frontier must make SPACE and not
- * matter: the pairs have to annihilate back and leave the point. Which is what
- * `BITE` already says, so this is a consistency check that passes rather than a
- * new assumption, but it is a tight one.
+ * than fresh neutral space, one cell thick it would weigh 1.2·10¹¹⁴ kg against
+ * the universe's 1.5·10⁵³ — 61 orders too much. So the frontier must make SPACE
+ * and not matter: the pairs have to annihilate back and leave the point. Which
+ * is what `BITE` already says, so this is a consistency check that passes rather
+ * than a new assumption, but it is a tight one. (An earlier version of this line
+ * said 2·10¹¹⁵ and 10⁶². That was `m_Planck` per cell; the lattice's own mass
+ * unit is `MU = G_LATTICE·m_Planck`, which is the right one and is 16 times
+ * lighter. The conclusion does not care, but the number should be the model's.)
+ */
+
+// SI, and nowhere else in this file — everything above is in lattice units and
+// stays that way. These exist only so the cosmology below can be COUNTED rather
+// than asserted, which is what the rest of the file demands of itself.
+const L_PLANCK = 1.616255e-35, T_PLANCK = 5.391247e-44, M_PLANCK = 2.176434e-8;
+const MPC = 3.0856775814913673e22, GYR = 3.1557e16, C_SI = 2.99792458e8;
+const MU_SI = G_LATTICE * M_PLANCK;
+
+/**
+ * THE FRONTIER COSMOLOGY, AS ARITHMETIC — because it had none, and that was
+ * the thing wrong with it.
+ *
+ * Everything above this line was prose with numbers typed into it. They have
+ * now been recomputed from `H₀` alone and they were all right, which is worth
+ * saying plainly. What was NOT right is below.
+ */
+export const frontier = (H0 = 70.9) => {
+  const H = H0 * 1e3 / MPC;                 // s⁻¹
+  const age = 1 / H;                        // the whole cosmology is this line
+  const radius = C_SI * age;
+  const cells = radius / L_PLANCK;
+
+  return {
+    H0, age, radius, cells,
+    ageGyr: age / GYR,
+    radiusGpc: radius / (1e3 * MPC),
+    ticks: age / T_PLANCK,                  // equal to `cells`, which is R = ct
+    volume: 4 / 3 * Math.PI * Math.pow(cells, 3),
+    surface: 4 * Math.PI * cells * cells,
+
+    /** what the frontier would weigh as matter, which is the bill it passes */
+    frontierMass: 4 * Math.PI * cells * cells * MU_SI,
+
+    /** it appears here, at half the horizon — the offset dipole is `d/R` */
+    seenAt: radius / 2,
+  };
+};
+
+/**
+ * AND THE FIRST THING WRONG: THE ADVANCE BUDGET, WHICH THE SECTION GETS BY A
+ * FACTOR OF EIGHT AND NEEDS BY A FACTOR OF TWO.
+ *
+ * The argument above runs "one emission per cell per tick is the most the
+ * lattice permits, so a frontier cell can advance the frontier by at most one
+ * cell a tick, and it SATURATES". Read literally that is a DEFICIT, not a
+ * saturation: half the emission goes inward and annihilates, so the budget is
+ * half a cell per frontier cell per tick and the frontier advances at c/2.
+ *
+ * Which would be fatal twice over. The age would be 2/H₀ = 27.6 Gyr, twice the
+ * measured one and the very thing the construction was praised for getting
+ * right; and free-streaming matter approaching c WOULD OVERTAKE THE FRONTIER,
+ * which is a lattice with matter outside it.
+ *
+ * IT IS SAVED BY WHAT `mass` ACTUALLY SAYS. The ceiling in `physics.ts` is one
+ * PULSE per cell per tick, and a pulse is `SHEET` charges — not one. So:
+ *
+ *     charges out of a frontier cell per tick    SHEET = 8
+ *     the outward half, which never meets        4
+ *     needed to advance the shell by one cell    1
+ *     margin                                     4×
+ *
+ * So `dR/dt = c` really does saturate, and the binding constraint is the speed
+ * limit rather than the creation rate — which is what "the ceiling is the rate
+ * rather than a bound on it" was reaching for. But it saturates with four times
+ * the room, not by a hair, and the version written above has none. The surplus
+ * is a real open question (four cells' worth of creation a tick with only one
+ * cell to put it in), and it is not one the section knows it has.
  */
+export const ADVANCE = SHEET / 2;           // cells per frontier cell per tick
+
+/**
+ * AND THE SECOND THING WRONG, WHICH IS WORSE: `reach` DOES NOT SURVIVE THIS.
+ *
+ * `REACHES` = 0.361 is the file's one full prediction — gravity dies at a third
+ * of the horizon "in ANY universe this model describes, whatever its density,
+ * because a denser one screens harder in exactly the proportion that it expands
+ * faster". Read the derivation again and the second half of that sentence is
+ * FRIEDMANN: it substitutes `ρ = 3H²/8πG` and watches the density cancel.
+ *
+ * THE FRONTIER COSMOLOGY HAS NO FRIEDMANN EQUATION. It coasts. `H = 1/t` comes
+ * out of free-streaming kinematics and is true whatever ρ is, so ρ and H are no
+ * longer tied and there is nothing to cancel. What is left is
+ *
+ *     λ/R_h = 0.361 / √Ω
+ *
+ * and this model has to use ITS OWN Ω, which — having no dark matter — is the
+ * baryon one:
+ *
+ *     Ω = 1      as the derivation assumed     λ/R_h = 0.361
+ *     Ω = 0.315  ΛCDM's matter                 λ/R_h = 0.644
+ *     Ω = 0.0493 baryons, i.e. THIS MODEL      λ/R_h = 1.628
+ *
+ * Gravity reaches one and a half times past the horizon, so it never bites and
+ * there is nothing left to exclude. The prediction does not become wrong; it
+ * becomes UNFALSIFIABLE, which for this file is the worse of the two.
+ *
+ * AND IT IS NOT EVEN A CONSTANT ANY MORE. Coasting gives ρ ∝ t⁻³ and R_h ∝ t,
+ * so λ/R_h ∝ √t — it grows:
+ *
+ *     z = 0    1.628        z = 3     0.814
+ *     z = 1    1.151        z = 10    0.491
+ *
+ * so it did bite, in the past, and passed out through the horizon on the way
+ * here. "A pure count" was a statement about Friedmann universes only.
+ *
+ * THIS IS THE COST OF THE FRONTIER AND IT IS NOT SMALL. Moving the creation to
+ * the edge dissolved five closures, and this file called that a clear win. It
+ * also quietly spent the one prediction the file had that an instrument could
+ * refuse, and did not notice.
+ */
+export const reachesIn = (omega: number) => REACHES / Math.sqrt(omega);
+
+/**
+ * AND THE THIRD: THE SUPERNOVAE, WHICH THE SECTION NEVER PUT IT AGAINST.
+ *
+ * A coasting universe is `q₀ = 0` exactly, with no freedom anywhere — no Ω, no
+ * Λ, nothing to fit. Measured, `q₀ = −0.55 ± 0.05`. That is the whole test in
+ * one line, and it is eleven sigma, but it is worth doing properly because the
+ * defence is real: a supernova's absolute magnitude is a nuisance parameter, so
+ * a CONSTANT offset in the distance modulus is free, and H₀ is degenerate with
+ * it. Only the SHAPE counts. So marginalise the offset out and look at what is
+ * left, against ΛCDM at Ω_m = 0.315:
+ *
+ *     z      residual (mag)      z      residual (mag)
+ *     0.02   +0.072              0.45   −0.078
+ *     0.08   +0.041              0.80   −0.122
+ *     0.18   −0.002              1.00   −0.130
+ *     0.25   −0.027              2.00   −0.098
+ *
+ * 0.061 mag rms, 0.202 mag peak to peak, and MONOTONIC — a smooth trend from
+ * bright to faint, which is precisely the shape of the residual the 1998
+ * measurements found and called acceleration. Pantheon+ bins carry 0.02–0.03
+ * mag. The frontier cosmology fails the supernova Hubble diagram at about the
+ * significance with which acceleration was discovered, and no choice of H₀
+ * helps because H₀ is exactly the parameter that was marginalised away.
+ */
+export const coasting = {
+  /** luminosity distance in a coasting universe, R = ct */
+  distance: (z: number, H0 = 70.9) =>
+    (C_SI / (H0 * 1e3 / MPC)) * (1 + z) * Math.log(1 + z),
+
+  /** and ΛCDM's, for the comparison — the only place this file uses it */
+  lcdm: (z: number, H0 = 70.9, om = 0.315) => {
+    const N = 4000; let acc = 0;
+    for (let i = 0; i < N; i++) {
+      const zz = z * (i + 0.5) / N;
+      acc += 1 / Math.sqrt(om * Math.pow(1 + zz, 3) + (1 - om));
+    }
+    return (C_SI / (H0 * 1e3 / MPC)) * (1 + z) * acc * (z / N);
+  },
+
+  modulus: (d: number) => 5 * Math.log10(d / (10 * 3.0857e16)),
+
+  /** exactly nought, which is the prediction and the problem */
+  q0: 0,
+};
+
+/**
+ * THE CAUGHT PAIR, AS ARITHMETIC — see the dark-matter section below, where it
+ * is argued. This is the part of it that is a number.
+ *
+ * `crossover` is the radius at which the vacuum-mediated 1/R pull would equal
+ * Newton's 1/R², given a vacuum making pairs at `C` per cell per tick; `loss`
+ * is what that same vacuum does to the beam over that distance. The whole
+ * result is that the second is never small when the first is useful.
+ */
+export const caught = {
+  /**
+   * ∫d³P·e^{−(r_A+r_B)/λ}/(r_A²·r_B²), reduced to one dimension in prolate
+   * spheroidal coordinates. This is what makes the law 1/R rather than 1/R²,
+   * and putting the attenuation INSIDE it is what the first pass got wrong.
+   *
+   * `a = R/λ`; at a = 0 it returns π³/R exactly.
+   */
+  linked: (R: number, a = 0) => {
+    // the log singularity sits at ξ = 1, so integrate in ξ = 1 + e^s
+    const N = 60_000, S0 = -60, S1 = Math.log(1e4 + 40 / Math.max(a, 1e-12));
+    const ds = (S1 - S0) / N;
+    let acc = 0;
+    for (let i = 0; i < N; i++) {
+      const u = Math.exp(S0 + (i + 0.5) * ds), xi = 1 + u;
+      acc += Math.exp(-a * xi) / xi * Math.log((xi + 1) / u) * u * ds;
+    }
+    return 4 * Math.PI / R * acc;
+  },
+
+  /** the vacuum's steady density, as the bulk-vacuum route already had it */
+  density: (C: number) => Math.sqrt(C / (BITE * 0.5)),
+
+  /**
+   * The enhancement over Newton, with the fog applied to BOTH sides so that
+   * the e^{−R/λ} cancels — which it very nearly does, since the pair's shortest
+   * route is Newton's route. What survives is logarithmic in R and set by Φ:
+   *
+   *     gain/Newton → 4π·Φ·(ln(2R/λ) + γ)
+   *
+   * The whole result is that this saturates. It does not grow into the
+   * discrepancy however much space is put between the two bodies.
+   */
+  enhancement: (Phi: number, R: number) => {
+    const lam = 1 / (BITE * 0.5 * Phi);
+    return 4 * Math.PI * Phi * (Math.log(2 * R / lam) + 0.5772156649);
+  },
+
+  /** and the range of gravity that same Φ leaves, in cells */
+  range: (Phi: number) => 1 / (BITE * 0.5 * Phi),
+};
 
 /**
  * SO WHERE IS THE CENTRE — and the answer is not a place.
@@ -2610,6 +2828,129 @@ export const REACHES = Math.sqrt(
  * produce the way they scale with mass, which is the usual fate of halo models
  * and is why MOND-like schemes are about acceleration rather than density.
  *
+ * AND A FOURTH, WHICH IS NOT A PROFILE AT ALL — THE CAUGHT PAIR.
+ *
+ * Do not give the vacuum a density profile. Let it make pairs anywhere, and
+ * let ONE CHARGE BE CAUGHT BY A AND THE OTHER BY B. The pair was made with its
+ * point and does not give it back, because its two halves were taken by
+ * different bodies and never met each other. So a net point is destroyed, a
+ * destroyed point is attraction, and there is MORE of it where there is more
+ * empty space to make pairs in. That is a different shape of idea from (a)–(c)
+ * and the bookkeeping is right: `BITE` makes creation and annihilation exact
+ * inverses only for a pair that self-annihilates, and this one does not.
+ *
+ * AND ITS RADIAL LAW IS THE ONE THING EVERY OTHER ROUTE FAILED TO GET. A pair
+ * born at P reaches A with weight `σ_A/4π|P−A|²` and B with `σ_B/4π|P−B|²`, so
+ * the linked rate is that product summed over everywhere a pair could be born:
+ *
+ *     I(R) = ∫d³P / (|P−A|²·|P−B|²) = π³/R   exactly
+ *
+ * (the Fourier transform of 1/r² is 2π²/k, so the convolution is 4π⁴/k², whose
+ * inverse is π³/R. Checked by importance-sampled Monte Carlo at R = 1, 2, 5,
+ * 10: 0.949, 0.975, 1.059, 0.976 of it.)
+ *
+ * ONE OVER R, WHERE NEWTON IS ONE OVER R². The ratio grows linearly with
+ * radius, which is precisely what dark matter looks like and precisely what
+ * MOND's deep limit is. No profile was assumed, no halo was fitted, and the
+ * exponent came out of a geometric integral rather than a choice. This is the
+ * best radial law anything in this file has produced.
+ *
+ * AND THE DISC GEOMETRY WORKS TOO, which is the other half and was worth
+ * checking rather than assuming. The picture is two bodies in DIFFERENT SPIRAL
+ * ARMS — same radius, different angle, a great deal of empty space between
+ * them to make pairs in. Two questions, both answered by the sum:
+ *
+ *   THE SIGN. A star sitting IN a ring is pulled INWARD by the rest of that
+ *   ring: an element at angle θ contributes `cos θ − 1 ≤ 0` radially, for every
+ *   θ. So arm-to-arm pull is centripetal, which is the direction dark matter is
+ *   missing in. (Unlike space made in a shell OUTSIDE the orbit, which was the
+ *   idea killed at the top of this section — that one pushes outward.)
+ *
+ *   THE SHAPE. The mechanism ADDS a 1/d channel to Newton rather than replacing
+ *   him — the direct meeting of A's charges with B's is still there and still
+ *   1/d². Sum both over the real baryons and fit the one coupling κ at the Sun
+ *   and nowhere else:
+ *
+ *       r (kpc)   Newton   Newton + caught   measured   ratio
+ *       6         192.4    228.1             232.6      0.981
+ *       8         185.7    229.1             229.2      1.000
+ *       12        163.6    219.2             222.4      0.985
+ *       16        143.4    207.9             215.6      0.964
+ *       20        128.0    199.5             208.8      0.955
+ *       25        114.1    192.0             200.3      0.959
+ *       30        103.7    186.8             191.8      0.974
+ *
+ *   INSIDE 4.5% ACROSS THE WHOLE RANGE THE DATA COVERS, ON ONE CONSTANT, where
+ *   Newton alone is short by 52% at the Sun and 242% at 30 kpc. Below 5 kpc it
+ *   falls away, and below 5 kpc there is no data either — the Eilers fit is not
+ *   defined there, so neither is the comparison.
+ *
+ *   (Written as a REPLACEMENT for Newton instead it fails inside 6 kpc for the
+ *   obvious reason: 1/d is too weak where Newton needs to be strong. MOND needs
+ *   an interpolation function for exactly this. The caught pair does not, since
+ *   it was a second channel and not a modification, and the sum recovers Newton
+ *   at small radius on its own.)
+ *
+ * IT DIES TWICE ANYWAY.
+ *
+ * FIRST ON TULLY–FISHER, in the same place (c) did and for the same reason.
+ * `σ_A ∝ m_A` and `σ_B ∝ m_B`, so `F ∝ m_A·m_B/R`, so `v² ∝ M` and `v⁴ ∝ M²`
+ * — slope 2 against a measured 3.85 ± 0.09, which is 21σ. Putting the vacuum in
+ * the middle does not make the law non-bilinear, and the file's own theorem
+ * (equivalence + the third law ⇒ F ∝ m_a·m_b) does not care what the mediator
+ * is. Every route this model has ends here.
+ *
+ * AND SECOND ON THE DENSITY — but NOT in the way an earlier draft of this said,
+ * and the correction is worth more than the conclusion.
+ *
+ * THAT DRAFT SAID: the gain is linear in Φ·R and the loss is exponential in it,
+ * so the loss wins. IT WAS COMPARING AN ATTENUATED GAIN AGAINST AN
+ * UNATTENUATED NEWTON. Newton's own carriers cross the same fog. Put the
+ * attenuation on both sides and most of it cancels, because the vacuum charge
+ * has to reach A and its partner has to reach B, and `r_A + r_B ≥ R` with
+ * EQUALITY ON THE SEGMENT AB — the shortest route for the pair is the same
+ * route Newton's carrier takes.
+ *
+ * DONE PROPERLY. In prolate spheroidal coordinates (ξ = (r_A+r_B)/R, η =
+ * (r_A−r_B)/R) the angular part collapses exactly:
+ *
+ *     J(R,λ) = (4π/R)·∫₁^∞ e^{−aξ}·(1/ξ)·ln((ξ+1)/(ξ−1)) dξ,    a = R/λ
+ *
+ * which is π³/R at a = 0, as it must be. For large a the log singularity at
+ * ξ = 1 gives `J → (4π/R)·e^{−a}(ln 2a + γ)/a` — measured against the exact
+ * integral, 0.949 at a = 10 and 0.993 at a = 100. Divide by Newton's own
+ * e^{−a}/R² and the exponentials go:
+ *
+ *     gain/Newton  →  4π·C·λ·(ln(2R/λ) + γ)  =  4π·Φ·(ln(2R/λ) + γ)
+ *
+ * since C·λ = C/√(Ck) = √(C/k) = Φ. SO IT SURVIVES THE FOG. What it does not do
+ * is grow: past λ the enhancement is only LOGARITHMIC in R, and its size is set
+ * by Φ itself.
+ *
+ * AND THAT IS WHERE IT DIES, on the same one-Φ-two-jobs trap as everything else
+ * but by a different route. Ask for the extra pull to equal Newton's at 10 kpc:
+ *
+ *     Φ        6.64·10⁻⁴ charges per cell
+ *     λ        3012 cells = 4.9·10⁻³² m
+ *
+ * and λ is the range of gravity. What is left of Newton at that λ:
+ *
+ *     1 Planck length   R/λ = 3·10⁻⁴     survives
+ *     1 nanometre       R/λ = 2·10²²     nothing
+ *     1 AU              R/λ = 3·10⁴²     nothing
+ *     10 kpc            R/λ = 6·10⁵¹     nothing
+ *
+ * SO THE RATIO IS FINE AND THERE IS NOTHING LEFT TO TAKE A RATIO OF. The
+ * mechanism does not lose to the fog; it survives the fog exactly as one would
+ * hope. The fog it requires has already abolished the force it was enhancing.
+ *
+ * WHICH IS THE REAL ANSWER TO WHY `reach` SUBTRACTS, and it is not the one
+ * about signs. A mean free path only ever subtracts, true — but the caught pair
+ * IS gain, it does work, and the gain is bounded at 4πΦ·log. Φ cannot be raised
+ * to make the gain useful without lowering λ to where there is no gravity to
+ * enhance. Gain and loss are not fighting over an exponent. They are the same
+ * number, spent twice.
+ *
  * THE ONE HOOK THAT IS NATIVE, AND IT IS AN ACCELERATION:
  *
  *     a₀ measured        1.200·10⁻¹⁰ m/s²
@@ -3905,6 +4246,882 @@ export const REACHES = Math.sqrt(
  * stands on its own. The radial law is unexplained again, and the obstruction
  * is exactly what it was before any of this: `n ∝ 1/r` needs the carriers to
  * slow.
+ *
+ * AND THAT LAST SENTENCE IS THE WHOLE OF WHAT THE REST OF THIS SECTION DOES.
+ * "The carriers need to slow" was written here as an obstruction; it turns out
+ * to be the answer, once the drift is allowed to depend on the density the
+ * carrier is passing through. See the speed-budget section below, and then
+ * Test H, which is where it ends up. What is retired here is the SHEET-LOCKING
+ * account of slowing, not slowing itself.
+ */
+
+/**
+ * TEST C — CAN √M COME FROM THE VACUUM INSTEAD OF FROM PHASE? Simulated, and
+ * the answer is no, for a reason worth having.
+ *
+ * Test A's √N is a cancellation of PHASES, and it needs the source to be an
+ * AMPLITUDE — the coherent sum |Σ| — rather than a count. Gravity here is a
+ * rate of annihilations, and rates do not cancel. So the obvious thing to try
+ * is a cancellation that works on counts: A BODY'S OWN CHARGES ANNIHILATING
+ * EACH OTHER on the way out. Emit N pairs a tick from a ball, let every + and −
+ * that lands in the same cell annihilate, and count what crosses a distant
+ * sphere. Nothing about randomness assumed; the charges are moved and met.
+ *
+ * IT DOES CANCEL, AND THE CONTROLLING NUMBER IS AN OPTICAL DEPTH. The surface
+ * density of a body's own charges is ~2N/4πR² per tick over a path ~R, so
+ *
+ *     τ = N / (2π·R)      N emitters, R the body's radius IN CELLS
+ *
+ * and the measured survival collapses onto it exactly — three (N, R) pairs at
+ * each τ, spanning sixteenfold in N:
+ *
+ *     τ = 1.06    52.0%   49.4%   51.0%
+ *     τ = 6.37    19.9%   19.2%   19.7%
+ *     τ = 31.8     6.8%    6.1%
+ *
+ * AND IT PASSES THROUGH √N WITHOUT STOPPING THERE, which is the finding:
+ *
+ *     N       τ        flux    d(log F)/d(log N)
+ *     5       0.13      8.3    0.920
+ *     30      0.80     33.5    0.734
+ *     75      1.99     56.2    0.563      ← √N is HERE and only here
+ *     190     5.04     83.1    0.421
+ *     1200    31.8    146.3    0.273
+ *     3000    79.6    183.0    0.244
+ *
+ * The exponent is not a plateau at ½. It slides continuously from 1 toward 0,
+ * touching ½ at τ ≈ 2.5 on its way past. Tully–Fisher needs the SAME exponent
+ * across five decades of mass, and τ ∝ M/R varies across those five decades, so
+ * even a body parked at τ = 2.5 would drift off the relation. A crossover
+ * cannot impersonate a power law over five decades.
+ *
+ * AND IT IS MOOT ANYWAY, BECAUSE NOTHING REAL IS DENSE ENOUGH:
+ *
+ *     body               N            τ
+ *     a proton           1.2·10⁻¹⁸    3.8·10⁻³⁹
+ *     the Earth          4.4·10³³     1.8·10⁻⁹
+ *     the Milky Way      9.1·10⁴⁹     5.1·10⁻⁷
+ *     the Sun            1.5·10³⁹     5.4·10⁻⁶
+ *     a NEUTRON STAR     2.1·10³⁹     4.4·10⁻¹
+ *
+ * EVERY REAL BODY IS DILUTE. Its own flux does not meet itself, the survival is
+ * 100%, the source is a count, and the flux goes as N exactly. A galaxy sits
+ * thirteen orders below where the cancellation starts — which is the same fact
+ * `shows` reports from the other side, that a galaxy is transparent.
+ *
+ * THE ONE PLACE IT COULD EVER BITE is the neutron star, at τ = 0.44 — the only
+ * object in the list within an order of the threshold. So this mechanism is not
+ * nothing; it is a prediction about the densest matter there is, and it has
+ * nothing whatever to say about rotation curves.
+ *
+ * WHICH LEAVES TEST A ALONE AS THE ROUTE TO √M, and sharpens what it owes. Its
+ * cancellation is real and measured. What it needs is for the gravitational
+ * source to be the COHERENT SUM of a body's emissions rather than their number
+ * — and this file's gravity is a rate of meetings, which counts. That single
+ * question is now the whole of the dark-matter problem here: the radial law is
+ * supplied (the caught pair), the cancellation is supplied (Test A), and what
+ * is missing is a reason for a rate to care about a phase.
+ */
+
+/**
+ * TEST D — AND THERE IS A REASON, AND IT IS THE WRONG WAY ROUND.
+ *
+ * The proposal: a rate cares about a phase because IN THIS MODEL THEY ARE THE
+ * SAME VARIABLE. Mass is a period (`X = 1/m` ticks between pulses, `physics.ts`),
+ * so the emission rate IS the thing carrying the phase; and gravity makes a body
+ * lighter (`m_eff = m/(1+u)`), so the well modulates it, and the two feed each
+ * other. That is structurally the right shape of answer — the missing bridge
+ * has to be something that makes a COUNT depend on a PHASE, and mass being a
+ * period is exactly such a thing. So it was tested in two pieces.
+ *
+ * THE FIRST PIECE FAILS ON SIZE. For the well to move a body across `inStep`'s
+ * switch, `m` must fall by `m·R/2π`:
+ *
+ *     place                 u = GM/rc²    the factor needed
+ *     the Sun's surface     2.1·10⁻⁶      8.4·10²⁴
+ *     the Galaxy at 8 kpc   3.7·10⁻⁷      3.0·10³⁶
+ *     a neutron star        1.7·10⁻¹      1.5·10²⁰
+ *
+ * FORTY-THREE ORDERS SHORT at the place it matters. Gravity does make things
+ * lighter and it cannot make them lighter enough to change what they cancel to.
+ * Nothing that feeds off that link survives it.
+ *
+ * THE SECOND PIECE WORKS, WHICH IS THE INTERESTING HALF. It does not need the
+ * first. If emission is PULSED rather than steady, two charges meet only when
+ * their bunches arrive together — so the meeting rate, which is what gravity
+ * counts, really does depend on relative phase. Measured at FIXED AVERAGE
+ * EMISSION, varying only the spread of the phases:
+ *
+ *     period P   phases        survived
+ *     1          steady        28.2%
+ *     4          all in step   28.4%
+ *     4          random        28.8%
+ *     16         ALL IN STEP   17.4%      ← the rate cared
+ *     16         random        28.5%      ← it did not
+ *
+ * BUNCHING CANCELS, AND ONLY IN STEP. A pulsed source whose emitters fire
+ * together concentrates its charges into thin shells that annihilate each other;
+ * the same source with random phases smooths out completely and is
+ * indistinguishable from a steady one, to a tenth of a percent.
+ *
+ * AND THAT IS THE OBSTRUCTION, MEASURED RATHER THAN ASSERTED. The two halves
+ * want opposite things:
+ *
+ *     Test A's √N needs the emitters OUT of step     m·R ≫ 2π
+ *     Test D's rate-cancellation needs them IN step  m·R ≪ 2π
+ *
+ * They are the same condition read in opposite directions, so NO BODY CAN HAVE
+ * BOTH. A galaxy is at `m·R ≈ 3·10³⁶`: its phases cancel beautifully and its
+ * rate does not notice, which is precisely the situation Test C found from the
+ * other side. Anything coherent enough for the rate to care is smaller than a
+ * Compton wavelength and has nothing to cancel.
+ *
+ * AND EVEN WHERE IT DOES CARE, IT OVERSHOOTS. Quadrupling the mass at P = 16
+ * in step takes the flux from 41.0 to 57.6 — a slope of 0.243, against 0.35 for
+ * the same source out of step. The rate-cancellation does not settle at ½ any
+ * more than Test C's did; it goes past it toward saturation.
+ *
+ * SO THE BRIDGE IS NOT MISSING BY OVERSIGHT where COHERENCE is concerned. It is
+ * missing because the model makes those two requirements exclusive.
+ *
+ * BUT THAT TESTED THE WRONG VARIABLE, AND TEST E BELOW OVERTURNS THE
+ * CONCLUSION. Everything above asks whether the feedback can move a body across
+ * `inStep`'s coherence switch. It cannot. It does not have to: the feedback
+ * produces √M on its own, with nothing coherent anywhere in it.
+ */
+
+/**
+ * TEST E — AND IT WORKS. THE FEEDBACK IS THE √M, WITH NO PHASE IN IT AT ALL.
+ *
+ * The claim, restated so it can be tested rather than argued: the loop FEEDS
+ * ITSELF BUT BY LESS EACH ROUND. More fold makes a body lighter, lighter makes
+ * fewer pulses, fewer pulses make less fold. That is a SELF-LIMITING feedback,
+ * and a self-limiting feedback has a fixed point:
+ *
+ *     M_eff = N / (1 + κ·M_eff^p)        ⇒       M_eff ∝ N^(1/(1+p))
+ *
+ * — so everything turns on `p`, how the fold at an emitter scales with what its
+ * body emits. And `p` is not a choice. It is what the annihilation counting
+ * gives, so it was measured: emitters at the ceiling, slowed each round by the
+ * fold their own charges have built, iterated to a fixed point.
+ *
+ *     N       source    mean u    slope of source
+ *     60      86        0.804     —
+ *     240     217       2.094     0.668
+ *     960     453       4.489     0.530
+ *     3840    878       9.636     0.478
+ *
+ *     measured p = d(log u)/d(log source) = 1.075
+ *     predicted exponent 1/(1+p)          = 0.482
+ *
+ * AND THE FIXED POINT SOLVED DIRECTLY, over six decades of N, confirms the form
+ * exactly: p = ½ → 0.6671, p = 1 → 0.5000, p = 2 → 0.3333, against 2/3, 1/2,
+ * 1/3 predicted.
+ *
+ * SO THIS IS NOT A CROSSOVER. Tests C and D produced exponents that slid past ½
+ * on their way to saturation, which is why neither could carry Tully–Fisher.
+ * THIS ONE CONVERGES ON ½ AND STAYS, because ½ is a fixed point of the loop and
+ * not a point on a curve. p = 1 — the fold at an emitter goes linearly with what
+ * the body emits — is exactly what gives it, and p = 1 is what was measured.
+ *
+ * THE ONE THING IN THE WAY IS THE SCALE, and it is seven orders and not
+ * forty-three. The loop only bites once `u ≳ 1`; below that `M/(1+u) = M` and
+ * the source is a plain count:
+ *
+ *     body             u = GM/Rc²   exponent there
+ *     a proton         1.5·10⁻³⁹    1.000000
+ *     the Milky Way    2.0·10⁻⁷     1.000000
+ *     the Sun          2.1·10⁻⁶     0.999998
+ *     a neutron star   1.7·10⁻¹     0.871870
+ *     at its own r_s   5.0·10⁻¹     0.750000
+ *
+ * — read with `u` as the NEWTONIAN potential.
+ *
+ * AND `u` IS NOT THE NEWTONIAN POTENTIAL HERE, WHICH IS THE WHOLE POINT. This
+ * file already says so, twice, and files it as a defect. See `MADE`: "static?
+ * no. It is a RATE, so it accumulates: `m·SHEET·t/r` passes `G·m/r` at
+ * `t = G/SHEET ≈ 0.008 ticks` and keeps going." The fold is a running total of
+ * annihilations at a node, and nothing gives it back. Over the age:
+ *
+ *     accumulated / Newtonian = t·SHEET/G_LATTICE = 1.04·10⁶³
+ *
+ *     body             u accumulated   exponent
+ *     a proton         1.5·10²⁴        0.5000
+ *     the Earth        7.2·10⁵³        0.5000
+ *     the Sun          2.2·10⁵⁷        0.5000
+ *     the Milky Way    2.1·10⁵⁶        0.5000
+ *
+ * EVERY BODY SITS AT EXACTLY ½, AND AT THE SAME ½. Which is precisely what
+ * Tully–Fisher demands and what no crossover could ever supply — one exponent,
+ * unchanging across five decades of mass.
+ *
+ * SO THE DEFECT AND THE MECHANISM ARE THE SAME FACT. The accumulating fold was
+ * written down as the reason the `MADE` account could not be wired in; it is
+ * also the only thing that puts real bodies in the regime where the feedback
+ * gives √M. One of the two readings is wrong and they cannot both stand.
+ *
+ * WHAT IS OWED BEFORE THIS IS A RESULT. Three things, and none is small:
+ *
+ *   WHICH CHANNEL. A √M source applied to the DIRECT 1/R² channel makes gravity
+ *   weaker, not stronger, and would show up in the solar system. It helps only
+ *   if it scales the caught pair's 1/R channel while Newton's keeps its count.
+ *   Nothing here says why the two channels would couple to different things.
+ *
+ *   WHAT STOPS IT. An unbounded accumulating fold makes `m_eff → 0`: every body
+ *   would fade. The fixed point above is a fixed point in N at fixed κ·t, and
+ *   the t-dependence has not been solved at all.
+ *
+ *   AND THE SOLAR SYSTEM. If `u` really is 10⁵⁷ at the Sun then `slowing`,
+ *   `thickness` and every measured GR test are being computed from the wrong u,
+ *   and those pass. That is the sharpest objection to the accumulating reading,
+ *   and it is not answered here.
+ *
+ * NONE OF WHICH RETRACTS THE MEASUREMENT. The self-limiting loop gives an
+ * exponent of exactly ½, as a fixed point, from the model's own two rules —
+ * mass is a period, and fold slows the period. That is the first mechanism in
+ * this file that produces the mass law rather than approaching it.
+ */
+
+/**
+ * AND WHICH SLOWING IS IT? — because there are two readings of the same chain
+ * and they give DIFFERENT EXPONENTS, so the data can choose between them.
+ *
+ * Test E slowed the emitter by the FOLD it sits in. The other reading is the
+ * model's own speed rule and is arguably more native to it:
+ *
+ *     it accelerates → it goes faster → it moves on more ticks and updates on
+ *     fewer → it ticks less → it IS lighter → it pulls less → it accelerates
+ *     less
+ *
+ * That is the same self-limiting shape and it uses `massFor` rather than
+ * `slowing` — speed as a budget between moving and updating, which is what this
+ * file already says mass IS on the movement side.
+ *
+ * THE EXPONENT COMES FROM HOW THE DRIVER SCALES WITH THE SOURCE, and this is
+ * where the two part company. The fixed point `M_eff = N/(1+κ·M_eff^p)` gives
+ * `M_eff ∝ N^{1/(1+p)}`, measured over six decades and converged to five
+ * figures:
+ *
+ *     driver          p     exponent   asymptotic value
+ *     fold, u ∝ M     1     1/(1+p)    0.50000
+ *     speed, v ∝ √M   ½     1/(1+p)    0.66667
+ *
+ * — because `v² = GM/r`, so SPEED CARRIES ITS OWN SQUARE ROOT ALREADY, and a
+ * feedback driven by it can only spend that root once.
+ *
+ * AND TULLY–FISHER SEPARATES THEM. With the caught pair's 1/R law `v² ∝ M_eff`,
+ * so `M_eff ∝ M^e` gives `M ∝ v^{2/e}` against a measured 3.85 ± 0.09:
+ *
+ *     driver                    e       BTFR slope   off by
+ *     none (bilinear)           1       2.00         20.6σ
+ *     SPEED  (v ∝ √M)           2/3     3.00          9.4σ
+ *     FOLD   (u ∝ M)            1/2     4.00          1.7σ
+ *
+ * THE FOLD READING LANDS INSIDE 2σ AND THE SPEED READING DOES NOT. So the chain
+ * is right and the driver has to be the one that scales LINEARLY with the
+ * source. That is a real discrimination between two versions of the same idea,
+ * made by data rather than by preference — and it is the first time anything in
+ * this file has been able to choose between two mechanisms on the mass law.
+ *
+ * AND THE SPEED READING IS ALSO TOO SMALL BY ITSELF, independently of its
+ * exponent. `v/c` is the whole size of the effect:
+ *
+ *     the Earth's orbit          9.9·10⁻⁵
+ *     the Sun round the Galaxy   7.6·10⁻⁴
+ *     a galaxy cluster           3.3·10⁻³
+ *
+ * Run on the Milky Way it slows the curve by 0.06% at 2 kpc and 0.02% at 30,
+ * where the discrepancy is a factor of two. THE SIGN IS RIGHT AND NOTHING ELSE
+ * IS — which is the same verdict `carry` got, for the same reason: anything
+ * whose size is v²/c² or v/c is three to six orders under a galaxy's problem.
+ *
+ * WHAT SURVIVES OF IT. The speed rule is not the driver of the mass law, but it
+ * says the two readings are not interchangeable, and it explains WHY the fold
+ * reading works: the feedback needs a driver that has not already spent the
+ * square root, and the accumulated fold is the only such quantity the model has.
+ */
+
+/**
+ * TEST F — AND THEN IT WAS RUN ON A WHOLE GALAXY, WHICH TAKES IT BACK.
+ *
+ * Tests C, D and E were all boxes of a few thousand cells, or transients begun
+ * from nothing at t = 0. A galaxy is neither. So it was rebuilt properly:
+ *
+ *   - the real Milky Way baryons, ring by ring and angle by angle, NO SHELL
+ *     THEOREM anywhere
+ *   - THE FIELD AS A FIXED POINT rather than a transient. Every mass element's
+ *     source strength depends on the field it sits in, and that field is made by
+ *     all the already-weakened sources, iterated to convergence. Which is what
+ *     "gravity has already propagated everywhere" has to mean
+ *   - the circular speed at every radius solved SIMULTANEOUSLY with the field,
+ *     so a speed-driven feedback is fed the speed it actually produces
+ *   - one coupling fitted, at the Sun, and nothing else
+ *
+ * FIRST, THE THING THAT SETTLES THE SPEED QUESTION OUTRIGHT, and it is more
+ * general than any exponent. Pushed to κ = 10⁶, far past anything physical,
+ * with the galaxy's own self-consistent speeds:
+ *
+ *     κ        v(8 kpc)    shape rms vs Gaia
+ *     0        185.6       32.5%
+ *     10²      180.9       34.1%
+ *     10⁴      102.2       62.3%
+ *     10⁶       66.2       76.3%
+ *
+ * A FEEDBACK THAT WEAKENS THE SOURCE CAN ONLY LOWER A ROTATION CURVE. It is
+ * monotone in κ and it never turns around. So the feedback is not the dark
+ * matter and cannot be, at any coupling, for any driver — it can only govern
+ * how an excess supplied by something else SCALES with mass. That is worth
+ * having flatly, because it is the answer to "is the speed the reason" and it
+ * does not depend on Tully–Fisher at all.
+ *
+ * SO THE HONEST OBJECT IS THE PAIR: the caught pair's 1/R channel supplying the
+ * excess, the feedback setting its mass scaling. Two requirements at once —
+ * the SHAPE of one rotation curve, and the SLOPE across five decades of galaxy
+ * mass, with sizes following the observed R ∝ M^0.35.
+ *
+ * AND NO PERMUTATION MEETS BOTH. Five drivers × three channel choices × local
+ * or body-averaged × eight couplings:
+ *
+ *     setup                                    shape    BTFR slope
+ *     the caught pair alone, no feedback       3.2%     2.51
+ *     + feedback, κ = 10⁶                      9.7%     2.92
+ *     + feedback, saturated (κ ≥ 10⁹)          19.8%    3.25
+ *     wanted                                   < 5%     3.85 ± 0.09
+ *
+ * THE TWO REQUIREMENTS PULL OPPOSITE WAYS. Weak feedback keeps the shape and
+ * leaves the slope at the caught pair's own 2.51; strong enough feedback to
+ * move the slope crushes the inner disc, and the curve starts RISING outward —
+ * v(30) = 264.9 against v(8) = 229, where Gaia has it falling. The best joint
+ * fit anywhere in the search is 6.7σ from the measured slope.
+ *
+ * WHICH CORRECTS TEST E, AND THE CORRECTION IS THE POINT. Test E measured the
+ * exponent on what was effectively a point source and got exactly ½, and that
+ * measurement stands as arithmetic. What it could not see is that REACHING the
+ * regime where the exponent is ½ requires κ·u ≫ 1 THROUGHOUT THE GALAXY, and a
+ * `u` that varies by an order of magnitude across the disc cannot be deep in
+ * that regime everywhere without deforming the profile. THE FIXED POINT IS REAL
+ * AND IT IS NOT REACHABLE WITH A ROTATION CURVE STILL ATTACHED.
+ *
+ * (One bug found on the way, recorded because it changed a conclusion: the
+ * bulge was being added to the field UNWEAKENED. At large κ the disc was
+ * crushed to nothing and the untouched bulge dominated, dragging the slope back
+ * to Newton's 2.07 and making the feedback look useless in the wrong direction.
+ * Weakened consistently — the bulge is made of emitters too — the slope rises
+ * to 3.25 instead. The conclusion is unchanged and the number was wrong.)
+ *
+ * WHAT IS LEFT STANDING, precisely:
+ *
+ *   THE CHAIN IS SOUND. More fold, lighter, fewer pulses, less fold. It is
+ *   self-limiting and it does have a fixed point.
+ *   THE EXPONENT IS RIGHT IN ISOLATION. p = 1 gives ½, measured twice.
+ *   THE SHAPE IS SUPPLIED, by the caught pair, at 3.2%.
+ *   AND THEY CANNOT BE HAD TOGETHER. Which is not a gap in the argument. It is
+ *   a measured incompatibility between the two halves, on a galaxy, with the
+ *   field relaxed and nothing fitted but one number.
+ *
+ * THE MODEL STILL HAS NO DARK MATTER. The difference after this test is that it
+ * is no longer missing a mechanism — it has two, each of which does its own half
+ * correctly, and a demonstration that they do not compose.
+ *
+ * — AND TEST G BELOW WITHDRAWS THAT LAST SENTENCE. They do compose. Test F used
+ * the wrong functional form and the failure was the form's, not the model's.
+ */
+
+/**
+ * TEST G — THEY DO COMPOSE, USING THE MODEL'S OWN CONVERSION AND NOT A MADE-UP
+ * ONE. THIS IS THE BEST RESULT IN THE FILE.
+ *
+ * WHAT WAS WRONG WITH TEST F. Every feedback above was written `m/(1+κ·D)`,
+ * which SATURATES: once κD ≫ 1 it stops responding, and the exponent stalls
+ * wherever it happened to be. That form was mine. It is not in the model
+ * anywhere.
+ *
+ * THE MODEL'S OWN CONVERSION IS A POWER LAW AND NEVER SATURATES:
+ *
+ *     massFor(v) = LIGHT/v          so m ∝ 1/v, exactly — `physics.ts`
+ *
+ * So the honest test is `m_eff ∝ v^{−q}` solved self-consistently, with q = 1
+ * being the model's own rule and NOT a fitted exponent. And the analytic
+ * expectation is clean: for the caught pair's flat channel `v² = λ·M_eff ∝
+ * λ·N·v^{−q}`, so `v^{2+q} ∝ N` and THE TULLY–FISHER SLOPE IS 2 + q.
+ *
+ * RUN ON THE RELAXED GALAXY, with one constant fitted at the Sun:
+ *
+ *     q       shape rms   BTFR slope   2+q
+ *     0.0     3.2%        2.51         2.00      ← the caught pair alone
+ *     0.5     3.1%        3.07         2.50
+ *     1.0     2.6%        3.60         3.00      ← THE MODEL'S OWN massFor
+ *     1.5     1.8%        4.10         3.50
+ *     2.0     1.1%        4.58         4.00
+ *
+ * AT q = 1 BOTH HALVES IMPROVE AT ONCE. The shape gets BETTER than the caught
+ * pair had alone — 2.6% against 3.2% — and the slope moves from 2.51 to 3.60.
+ * They are not in tension; each helps the other, which is what a composition
+ * ought to look like and what Test F said was impossible.
+ *
+ * THE CURVE, RADIUS BY RADIUS, against Gaia:
+ *
+ *     r (kpc)   Newton   this model   Gaia    ratio
+ *     6         192.5    230.5        232.6   0.991
+ *     8         185.4    229.0        229.2   0.999
+ *     12        163.6    219.2        222.4   0.985
+ *     20        128.0    201.3        208.8   0.964
+ *     30        103.7    189.8        191.8   0.990
+ *
+ * — inside 3.6% from 6 to 30 kpc, on ONE fitted number, where Newton is short
+ * by 52% and 242% at the two ends.
+ *
+ * AND THE SLOPE'S REMAINING GAP IS MY SYSTEMATIC, NOT THE MODEL'S. 3.60 against
+ * 3.85 ± 0.09 is 2.8σ — but the galaxy family is my construction, and its
+ * assumed size–mass relation moves the answer more than the discrepancy:
+ *
+ *     R ∝ M^0.20    slope 3.31
+ *     R ∝ M^0.35    slope 3.60      ← the baseline above
+ *     R ∝ M^0.50    slope 4.03
+ *
+ * The measured 3.85 sits inside that range, at s ≈ 0.42. A gas fraction rising
+ * toward the dwarfs moves it by −0.08. SO THE MODEL IS CONSISTENT WITH THE
+ * BARYONIC TULLY–FISHER RELATION, and the honest statement of the residual is
+ * that the family is not measured well enough here to do better.
+ *
+ * WHAT IS ACTUALLY OWED, AND THE FIRST ONE IS SHARP:
+ *
+ *   THE SIGN OF THE IDENTITY, WHICH DECIDES EVERYTHING. `massFor` is a COST per
+ *   step and is ≥ 1; the emission side is a RATE and is ≤ 1, and `physics.ts`
+ *   bridges them with "once a tick is the ceiling, which TURNS THE IDENTITY
+ *   ROUND". If the emission rate is `m`, the source goes as 1/v and q = +1. If
+ *   it is `1/m`, the source goes as v and q = −1. Measured:
+ *
+ *       q = +1   shape 2.6%   slope 3.60
+ *       q =  0   shape 3.2%   slope 2.51
+ *       q = −1   shape 3.7%   slope 1.30
+ *
+ *   The whole result rides on that one reading, and this file has not derived
+ *   it — it has asserted it in one direction and used it in the other. THAT is
+ *   the single question to settle next, and it is a question about `physics.ts`
+ *   rather than about galaxies.
+ *
+ *   λ IS STILL FITTED. One number, but nothing derives it, and until something
+ *   does this is a one-parameter fit that happens to have the right shape.
+ *
+ *   AND THE CAUGHT PAIR'S DENSITY BILL IS UNTOUCHED. The Φ that makes λ this
+ *   big puts the range of gravity at 5·10⁻³² m. Nothing here answers that, and
+ *   it remains the reason the mechanism cannot yet be believed.
+ *
+ * BUT THE COMPOSITION IS REAL AND IT WAS MEASURED. Two mechanisms, each derived
+ * for its own reason, one fitted constant between them, and both the shape of a
+ * rotation curve and the mass scaling of a population come out together. That
+ * has not happened before in this file.
+ *
+ * — AND THEN THE SIGN WAS SETTLED, AGAINST IT. See below.
+ */
+
+/**
+ * TEST H — SETTLING THE SIGN, WHICH RETIRES THE SOURCE ROUTE AND LEAVES THE
+ * TRANSPORT ONE STANDING.
+ *
+ * Test G's whole result rode on reading `massFor(v) = c/v` as the emission
+ * rate, giving source ∝ 1/v. Take the model's own account of what a step costs
+ * — A STEP TAKES A POINT FROM IN FRONT AND PUTS ONE BEHIND, so a step COSTS A
+ * TICK — and the budget is forced:
+ *
+ *     (share of ticks spent moving) + (share spent updating) = 1
+ *     ⇒  pulse rate ∝ (1 − v/c)
+ *
+ * WHICH IS NOT c/v, AND THE DIFFERENCE IS EVERYTHING. Measured on the relaxed
+ * galaxy, with nothing else changed:
+ *
+ *     reading                       weakening at the Sun   shape   BTFR
+ *     source ∝ 1/v      (Test G)    order one              2.6%    3.60
+ *     source ∝ (1−v/c)  (the budget) 0.076%                3.2%    2.509
+ *     no feedback at all             —                     3.2%    2.51
+ *
+ * THE BUDGET READING IS THE CAUGHT PAIR ALONE, TO THREE DIGITS. `v/c` is
+ * 7.6·10⁻⁴ at the Sun's orbit, so the feedback modulates the source by less
+ * than a tenth of a percent and cannot move a mass law.
+ *
+ * AND `massFor` CANNOT BE PRESSED INTO SERVICE INSTEAD, for a reason that is
+ * structural rather than numerical. It is a COST PER STEP and is `max(c/v, 1)`,
+ * hence ≥ 1 always; the emission side is a RATE and is ≤ 1 by the one-a-tick
+ * ceiling. The two have DISJOINT RANGES and meet only at exactly 1. There is no
+ * reading on which a star's constituents, orbiting at 7.6·10⁻⁴ c, have an
+ * emission rate of `c/v` = 1362 — that is 1362 pulses a tick against a ceiling
+ * of one. So Test G's q = +1 was never available; it was me reading a cost as a
+ * rate because the file calls both of them "mass".
+ *
+ * TEST G IS THEREFORE WITHDRAWN AS A RESULT. What survives of it is the method
+ * and one real lesson: a SATURATING feedback (`m/(1+κD)`) and a POWER-LAW one
+ * behave completely differently, and Test F's failure was the saturating form's
+ * fault. That correction stands. The 3.60 does not.
+ *
+ * WHICH LEAVES THE TRANSPORT ROUTE, AND IT DOES NOT NEED ANY OF THIS. Its √M
+ * does not come from the source at all — flux conservation goes QUADRATIC in n
+ * once the drift is `v = c·min(1, n/n_c)`, and the root falls out of the
+ * transport. Its sign is fixed by `inStep` read as a budget (in step, one phase
+ * paid once, dense → fast) rather than by identifying two incompatible masses.
+ *
+ * AND IT HAD NEVER BEEN RUN ON A GALAXY. Run now, on the relaxed disc:
+ *
+ *     g_c (m/s²)   shape    BTFR slope
+ *     0.5e−10      12.2%    3.28
+ *     1.0e−10       2.5%    3.40
+ *     1.2e−10       1.0%    3.43
+ *     1.5e−10       4.8%    3.47
+ *     2.0e−10      10.4%    3.52
+ *
+ * ONE PERCENT ON THE SHAPE — the best any mechanism in this file has managed —
+ * at a `g_c` of 1.2·10⁻¹⁰ m/s², which is `a₀`. And the slope is 3.43 against
+ * 3.85 ± 0.09, inside the ±0.4 the size–mass relation moves it by.
+ *
+ * SO THE STANDING OF THE THREE ROUTES, HONESTLY:
+ *
+ *     route                shape   BTFR   what it owes
+ *     caught pair alone     3.2%   2.51   the slope, and a density that kills
+ *                                         gravity at 5·10⁻³² m
+ *     source feedback       2.6%   3.60   RETIRED — needs a rate to equal a
+ *                                         cost, and their ranges are disjoint
+ *     TRANSPORT             1.0%   3.43   a 29 MeV emitter, and nothing else
+ *
+ * THE TRANSPORT ROUTE IS THE ONE TO BACK. It is the only one whose sign is
+ * derived rather than asserted, it needs no new rule (`inStep` was already
+ * measured), it gives both halves from ONE mechanism, and its single bill is a
+ * number rather than a structure: `n_c = (m/2π)³` wants an emitter at 28.9 MeV,
+ * where the electron gives 5.5·10⁻⁶ of what is needed and the proton 3.4·10⁴.
+ * Either something sits near 29 MeV, or the Compton wavelength that matters
+ * belongs to the CARRIER and not to the source.
+ *
+ * That is one question, it is about `physics.ts`, and everything else in the
+ * dark-matter thread now hangs off it.
+ *
+ * — AND IT WAS THE WRONG QUESTION. See below: the scale is not a particle's.
+ */
+
+/**
+ * TEST I — THE SCALE COMES FROM THE EXPANSION, AND THEN NOTHING IS FITTED.
+ *
+ * The 29 MeV bill came from setting `n_c` by a CONSTITUENT'S Compton
+ * wavelength. That was looking for the scale in the wrong place, and the whole
+ * model says so: SPACE BEING MADE IS THE MECHANISM. Making space has a rate,
+ * that rate is H, and an acceleration built out of it is `c·H`. The frontier
+ * cosmology already forces
+ *
+ *     H₀ = 1/t₀     exactly, with no freedom      (see `frontier`)
+ *
+ * so `c·H₀ = c/t₀` is A COUNT OF TICKS rather than a constant anyone chose. The
+ * crossover is where a galaxy's own field falls to the scale the expansion
+ * already sets — and the 2π is `inStep`'s own, since in step means within 2π of
+ * phase.
+ *
+ *     a₀ = c·H₀ / 2π
+ *
+ *     H₀      c·H₀        prediction   measured a₀   ratio
+ *     67.4    6.54e−10    1.041e−10    1.200e−10     0.867
+ *     70.9    6.89e−10    1.096e−10    1.200e−10     0.914
+ *     73.0    7.09e−10    1.129e−10    1.200e−10     0.941
+ *
+ * NINE PERCENT, WITH NOTHING FITTED ANYWHERE. H₀ is measured, t₀ = 1/H₀ is
+ * forced by the frontier, 2π is already in the file, and `a₀` was never a free
+ * parameter of this route at all.
+ *
+ * AND RUN ON THE GALAXY WITH THAT PREDICTED VALUE — no fitting of any kind:
+ *
+ *     a₀ from             value       shape    BTFR
+ *     H₀ = 67.4           1.04e−10    1.8%     3.41
+ *     H₀ = 70.9           1.10e−10    1.1%     3.42
+ *     H₀ = 73.0           1.13e−10    0.8%     3.42
+ *     the measured a₀     1.20e−10    1.0%     3.43
+ *
+ * ONE POINT ONE PERCENT ON THE MILKY WAY'S ROTATION CURVE, FROM THE HUBBLE
+ * CONSTANT. Radius by radius: 0.977 at 6 kpc, 0.997 at 8, 0.999 at 10, 0.995 at
+ * 12, 0.987 at 15 and 20, 1.002 at 25, 1.028 at 30 — against Newton's 0.83
+ * falling to 0.54 across the same span.
+ *
+ * WHICH RETIRES THE 29 MeV BILL ENTIRELY. It was the price of assuming the
+ * coherence scale belonged to a constituent. It belongs to the expansion, which
+ * this model has its own account of, and the two numbers agree to nine percent
+ * without either being adjusted to meet the other.
+ *
+ * AND THIS IS WHERE THE FRONTIER COSMOLOGY EARNS ITS KEEP. `a₀ ≈ c/(2πt₀)` is a
+ * known coincidence and an embarrassment everywhere else — why should a galaxy
+ * know the age of the universe? Here H₀ = 1/t₀ is not a coincidence but the
+ * construction, so the galaxy is not being told the age; it is being told the
+ * rate at which space is made, which is the same number because the frontier
+ * makes it so. The cosmology and the rotation curves are the same fact.
+ *
+ * AND IT PREDICTS SOMETHING MOND CANNOT, WHICH IS THE POINT OF HAVING A REASON.
+ * `a₀ = c/(2πt)` is not a constant — it FALLS as the universe ages:
+ *
+ *     z      t (Gyr)   a₀(z)/a₀(0)   a₀(z)
+ *     0      13.79     1.00          1.10e−10
+ *     1      6.90      2.00          2.19e−10
+ *     2      4.60      3.00          3.29e−10
+ *     4      2.76      5.00          5.48e−10
+ *
+ * MOND has no reason for `a₀` to depend on anything and treats it as a constant
+ * of nature. This route makes it a clock reading. High-redshift rotation curves
+ * are therefore a direct test, and a sharp one.
+ *
+ * AND THE FIRST LOOK AT THAT TEST IS NOT COMFORTABLE, which should be said
+ * rather than left for someone else to find. Genzel et al. (2017) find massive
+ * discs at z ≈ 2 with DECLINING outer rotation curves — baryon-dominated, less
+ * of a dark-matter effect, not more. A larger `a₀` pushes MORE of a galaxy into
+ * the deep regime and predicts a LARGER effect. The two pull opposite ways.
+ * They are not immediately contradictory, because high-z discs are also denser
+ * and `g_N` rises too, and what matters is the ratio — but the sign of the
+ * tension is the wrong one and this has not been worked out here.
+ *
+ * WHAT IS STILL OWED, now that the number is not:
+ *
+ *   THE ONE LINK, unchanged since it was first written down: that a carrier's
+ *   update cost goes as its accumulated phase. Everything in the transport
+ *   route rests on it, and it is a `physics.ts` question about what a tick is
+ *   spent on.
+ *   THE 2π, which is taken from `inStep` by analogy rather than derived for
+ *   this use. It is the difference between 9% and 43%, so it is load-bearing.
+ *   AND THE HIGH-z CURVES, above.
+ *
+ * BUT THE SHAPE OF THE RESULT IS NEW FOR THIS FILE. A rotation curve fitted to
+ * one percent by a number the model computes from its own cosmology, with a
+ * dated prediction attached that distinguishes it from the phenomenology it
+ * reproduces. Nothing else in the dark-matter thread has been in that position.
+ */
+
+/**
+ * TEST J — THE POLARITY IS A COIN, WHICH REMOVES THE COHERENCE CONDITION
+ * ALTOGETHER.
+ *
+ * Test A's √N came from PHASE cancellation, which needs `m·R ≫ 2π`, hence an
+ * emitter mass, hence the 29 MeV bill. But THE MODEL NEVER GIVES A WAVE A
+ * DEFINITE POLARITY. A neutral point becomes a ± pair (rule 3) and nothing
+ * decides which half goes which way — the attribution is a fair coin, and the
+ * expansion that makes the point has no polarity to hand it.
+ *
+ * A fair coin gives √N by itself, at every scale, with no coherence anywhere.
+ * Measured over an ensemble of forty realisations, since the imbalance is a
+ * random variable and one draw says nothing:
+ *
+ *     N       total arrivals   rms(net)   rms/√total
+ *     16      21.1             0.30       0.064
+ *     64      49.0             0.68       0.097
+ *     256     86.5             0.72       0.077
+ *     1024    130.5            1.61       0.141
+ *
+ * `rms(net)/√total` is flat across a sixty-fourfold range in N, and it does not
+ * depend on the body's size either — 0.065, 0.061, 0.075 at radii 5, 10 and 16
+ * for fixed N, where Test A's phase route varied by orders across the same span.
+ * SO THE ± IMBALANCE IS EXACTLY THE FAIR-COIN FLUCTUATION ON THE ARRIVALS, AND
+ * IT CARES ABOUT NOTHING ELSE.
+ *
+ * WHICH CONFIRMS TEST I FROM THE OTHER DIRECTION, and that is why it matters.
+ * Test I removed the 29 MeV bill by finding the scale in the expansion. This
+ * removes the REASON anyone looked for a Compton wavelength in the first place:
+ * there was never a coherence condition to satisfy. The two agree that no
+ * emitter mass enters the dark-matter account anywhere, and they get there
+ * independently.
+ *
+ * BUT IT IS A FLUCTUATION, AND A FLUCTUATION HAS NO SIGN. It cannot be the
+ * source of a systematic attraction, and if gravity coupled to it at every
+ * scale the solar system would be gone — the Sun's 10⁵⁷ emitters would act as
+ * 10²⁸ˑ⁵. So this is not an alternative to the transport route; it is the
+ * removal of an objection to it. The systematic pull stays with the count, as
+ * it always was, and the √M stays in the transport, where flux conservation
+ * goes quadratic.
+ */
+
+/**
+ * TEST K — AND THE HIGH-REDSHIFT DISCS REFUSE `a₀ ∝ 1/t`. Measured against the
+ * data rather than left as a worry.
+ *
+ * Genzel et al. (2017), six massive discs at z = 0.85–2.24, with declining
+ * outer rotation curves and `f_DM(<R_e) < 0.2` — which is a boost over the
+ * purely baryonic speed of under about 1.12. Their masses and sizes, put
+ * through the transport route inside one effective radius:
+ *
+ *     galaxy        z      a₀ fixed   a₀ = c/2πt   allowed
+ *     COS4_01351    0.85   1.112      1.179        < 1.12
+ *     D3a_6397      1.50   1.083      1.170        < 1.12
+ *     GS4_43501     1.61   1.077      1.164        < 1.12
+ *     zC_406690     2.20   1.101      1.239        < 1.12
+ *     zC_400569     2.24   1.019      1.057        < 1.12
+ *
+ * FOUR OF THE FIVE ARE OVER THE LINE WITH `a₀ ∝ 1/t`, AND NONE IS WITH `a₀`
+ * FIXED. Ordinary MOND is marginal here and survives; the model's own
+ * time-dependence does not. Inverting it, the largest `a₀` these galaxies
+ * permit is 1.09× today's, i.e. z < 0.09, and the coasting cosmology wants
+ * 3.20× at z = 2.2. THE PREDICTION IS OUT BY ABOUT A FACTOR OF THREE, in the
+ * direction that was already suspected.
+ *
+ * (The one galaxy that passes, zC_400569, passes because it is compact —
+ * R_e = 3.3 kpc at 2·10¹¹ M☉ — so its own `g_N` is 6.2 a₀ and it is Newtonian
+ * under either reading. That is the shape of the only available escape: the
+ * discs that refuse the prediction are the extended ones.)
+ *
+ * SO THE ONE THING THAT DATED THE MODEL IS THE ONE THING THE DATA REFUSES. That
+ * is the right way round for a prediction to fail — it was specific, it was
+ * derived rather than fitted, and it was refutable by measurements that already
+ * existed. What it costs is precisely the part of Test I that made `a₀` a clock
+ * reading. WHAT SURVIVES IS THE VALUE: `a₀ = cH₀/2π` at the present epoch is
+ * still 9% from the measured number with nothing fitted, and still fits the
+ * Milky Way to 1.1%.
+ *
+ * AND WHAT WOULD HAVE TO BE TRUE FOR IT TO LIVE. `a₀` would have to track
+ * something LOCAL rather than the global clock — and that quantity would have
+ * to be roughly constant over 0 < z < 2.2 while `1/t` trebles.
+ *
+ * WHICH IS EXACTLY WHAT THE NEXT TEST FINDS, so the paragraph that used to sit
+ * here — saying the model had no such quantity — was wrong. It has one.
+ */
+
+/**
+ * TEST L — THE BULK MAKES NO SPACE, BUT IT MAKES GRAVITY, AND THE AMOUNT
+ * DEPENDS ON HOW MUCH EMPTY SPACE THERE IS.
+ *
+ * The frontier construction forbids the bulk from CREATING space. It says
+ * nothing about the bulk coupling gravitationally, and the caught pair is
+ * exactly that: a pull mediated by the vacuum between two bodies, whose
+ * strength goes with how much vacuum there is to mediate it. More empty space
+ * between two things, more pull. That is a LOCAL quantity, and it is the thing
+ * the last test said the model did not have.
+ *
+ * FIRST, THE VERSION THAT FAILS, because it is instructive. Read the emptiness
+ * as the local baryon DENSITY, `a₀_eff = a₀·(ρ_ref/ρ_local)^s`:
+ *
+ *     s      Milky Way shape   worst Genzel boost
+ *     0      1.1%              1.239
+ *     0.3    15.5%             1.186
+ *     0.5    29.3%             1.156
+ *     1.0    77.4%             1.107
+ *
+ * The sign is right — raising s does relieve Genzel — but it wrecks the Milky
+ * Way long before it fixes anything, and NO VALUE OF s DOES BOTH. The reason is
+ * that ρ varies by fifty across one galaxy, so a rule keyed to it cannot tell
+ * "between galaxies" from "within a galaxy".
+ *
+ * AND THAT POINTS STRAIGHT AT THE FIX: THE SPACE BETWEEN TWO BODIES IS A
+ * LENGTH, NOT A VOLUME. It is measured along the line joining them, so what
+ * counts is the mean SPACING, `ρ^{−1/3}`, and not the density. Then
+ *
+ *     a₀ = (c·H / 2π) · (spacing / spacing₀)
+ *
+ * and in a coasting universe both factors are fixed by the epoch alone:
+ *
+ *     H        ∝ (1+z)      the frontier's own H = 1/t, with 1+z = t₀/t
+ *     spacing  ∝ (1+z)⁻¹    since ρ ∝ (1+z)³, so ρ^{−1/3} ∝ (1+z)⁻¹
+ *
+ * THE TWO CANCEL EXACTLY. Measured across the range, `a₀(z)/a₀(0)` = 1.0000 at
+ * z = 0.5, 1, 1.5, 2, 2.5 and 4 — not approximately, identically, because the
+ * clock speeds up by precisely the factor the spacing shrinks by.
+ *
+ * SO `a₀` IS CONSTANT IN REDSHIFT AND STILL EQUAL TO `c·H₀/2π`:
+ *
+ *     the value            1.096·10⁻¹⁰ m/s²
+ *     measured             1.200·10⁻¹⁰            ratio 0.914
+ *     Milky Way shape      1.1%                   unchanged
+ *     Genzel boosts        1.112 1.083 1.077 1.101 1.019   ALL under 1.12
+ *
+ * EVERY ONE OF THE FIVE DISCS PASSES. The refutation in Test K was of `a₀ ∝
+ * 1/t`, which was the version where the emptiness was left out — and putting it
+ * in is not a patch, it is the mechanism the section was about in the first
+ * place. "More empty space, more pull" was the idea; `1/t` alone was the idea
+ * with half of it dropped.
+ *
+ * WHAT IS GAINED AND WHAT IS LOST, exactly. GAINED: the 9% value survives, the
+ * Milky Way fit survives, and the high-z discs stop refusing it. LOST: the
+ * dated prediction. `a₀` constant is what MOND already assumes, so the model no
+ * longer says anything about redshift that MOND does not — the thing that made
+ * it refutable is the thing that had to go for it to survive. That is an honest
+ * trade and not a good one, and it should be read as the model becoming HARDER
+ * to test rather than as it becoming more right.
+ *
+ * WHAT IS STILL OWED IS UNCHANGED AND IT IS ONE THING: that a carrier's update
+ * cost goes as its accumulated phase. Everything in the transport route rests on
+ * it. It is a `physics.ts` question about what a tick is spent on, and it has
+ * been owed since the mechanism was written down.
+ *
+ * — AND THE NEXT TEST PAYS PART OF IT, and gets the interpolation function for
+ * nothing besides.
+ */
+
+/**
+ * TEST M — THE CARRIERS ALREADY THERE BLOCK THE SPLITTING, WHICH DERIVES THE
+ * INTERPOLATION FUNCTION INSTEAD OF ASSUMING IT.
+ *
+ * Every test above wrote the turnover as `g = g_N/2 + √(g_N²/4 + g_N·a₀)` and
+ * called it "the simple interpolation, same algebra as MOND's". IT WAS
+ * ASSUMED. Here is where it comes from, and it is already in the rules:
+ *
+ *   A neutral point becomes a ± pair (rule 3). A point that ALREADY HAS A
+ *   CARRIER ON IT is busy — `through` says an arriving charge annihilates or
+ *   reverses, and either way that point does not split this tick. So the
+ *   splitting is suppressed exactly where the carrier density is high, which by
+ *   `g ∝ n` is exactly where the field is strong.
+ *
+ * WITH OCCUPANCY θ = g/a₀ THE FREE FRACTION IS 1/(1+θ), so the extra pull per
+ * unit free space being constant, the enhancement over Newton is `(1 + a₀/g)`,
+ * and that closes:
+ *
+ *     g = g_N·(1 + a₀/g)   ⇒   g² − g·g_N − g_N·a₀ = 0
+ *     ⇒   g = g_N/2 + √(g_N²/4 + g_N·a₀)
+ *
+ * WHICH IS THE FUNCTION, DERIVED. Checked over six decades: `g/g_N` runs 31.7,
+ * 10.5, 3.70, 1.62, 1.10, 1.010, 1.0010 against a deep limit √(a₀/g_N) of 31.6,
+ * 10.0, 3.16 — the two agree where they should and part company where they
+ * should. The μ-function stops being borrowed phenomenology.
+ *
+ * AND IT MAKES a₀ A LOCAL THRESHOLD RATHER THAN A CLOCK READING, which is what
+ * Test K needed and Test L had to buy with a cosmological cancellation. The
+ * blocking is a function of the field at the point, and nothing else. So it
+ * does not move with redshift because there is nothing in it that could.
+ *
+ * WHICH SETTLES GENZEL WITHOUT THE CANCELLATION:
+ *
+ *     a₀ reading                value       MW shape   worst boost   all pass?
+ *     cH₀/2π, isotropic         1.10e−10    1.1%       1.112         YES
+ *     cone shut at cos θ > 0.9  1.05e−10    1.8%       1.108         YES
+ *     cone shut at cos θ > 0.5  8.38e−11    5.2%       1.090         YES
+ *     the measured a₀           1.20e−10    1.0%       1.120         no
+ *
+ * ALL FIVE DISCS PASS AND THE MILKY WAY STAYS AT 1.1%. And the last row is
+ * worth staring at: the MEASURED a₀ is the one that fails Genzel, by a hair, at
+ * 1.120 against 1.12 — while the model's own smaller prediction passes. The 9%
+ * the model is "wrong" by is in the direction the high-z data prefer.
+ *
+ * AND THEN THE DIRECTION, WHICH IS THE PART NOBODY HAD ASKED. A carrier
+ * streaming along ĝ occupies the cell in that direction; the point has `WAYS`
+ * exits and only the occupied ones are shut, so the pair goes out with the
+ * field direction REMOVED. That is an anisotropic source, and it costs a
+ * projection:
+ *
+ *     forward cone shut   directions open   ⟨|ĉ·r̂|⟩   vs isotropic
+ *     none                26                0.4721    1.000
+ *     cos θ > 0.9         25                0.4510    0.955
+ *     cos θ > 0.5         17                0.3610    0.765
+ *
+ * SHUTTING THE FORWARD CONE REDUCES THE RADIAL PROJECTION. The surviving pairs
+ * carry LESS flux outward, not more — so the anisotropy weakens the vacuum
+ * channel, and it does so most where the field is strong, which is the same
+ * direction the blocking already pushes. The two compound rather than fight,
+ * which is why the shape of the interpolation survives them both: they are
+ * functions of the same occupancy, so they can only move the SCALE.
+ *
+ * AND THAT IS THE ONE PLACE IT GOES THE WRONG WAY. The projection multiplies a₀
+ * by 0.955 or 0.765, and the measurement wants it 9% LARGER, not smaller. So
+ * the anisotropy widens the gap it was hoped to close — 1.8% and 5.2% on the
+ * Milky Way against 1.1% isotropic. IT IS NOT FATAL, because the gap is still
+ * under a factor of 1.5 in a quantity nothing was fitted to, but it is the
+ * opposite of the hoped-for result and the cone cannot be shut far.
+ *
+ * SO WHAT THIS TEST BUYS, PRECISELY. The interpolation function, derived from
+ * `through` rather than borrowed. a₀ as a local threshold, which settles the
+ * high-z discs without the cosmological cancellation Test L needed — so Test L
+ * is no longer load-bearing, though it remains a consistency check that passes.
+ * And a bound on the anisotropy: the forward cone cannot be shut past about
+ * cos θ = 0.5 before the Milky Way fit goes.
+ *
+ * WHAT IT DOES NOT BUY is the one link. "The carrier density suppresses the
+ * splitting" is `through` and is already in the file; "the update cost goes as
+ * the accumulated phase", which is what makes the DRIFT fall with density, is
+ * still owed and still a `physics.ts` question.
  */
 
 /**
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 73c0ecf..581122e 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -2,7 +2,7 @@ import { Fragment, ReactNode, useEffect, useRef, useState } from "react";
 
 import { GRAIN } from "./gravity";
 import { Echoes } from "./echoes";
-import { Rotation, Split } from "./rotation";
+import { Apart, Discs, HighRedshift, HighZDiscs, Rotation, Split } from "./rotation";
 import { Overlay, Routes, Seam, Shadows } from "./shadow";
 
 /**
@@ -2026,7 +2026,9 @@ export const Law = () => {
       meetings unmake it, and the net is what escapes — a real expansion, and
       it compounds, so <V>H</V> is constant and the growth exponential. Ask it
       for the <i>observed</i> <V>H</V> and it fails seven separate ways, each
-      worth recording because each is a fact rather than a failure to try:
+      worth recording because each is a fact rather than a failure to try —
+      and because <i>five of the seven dissolve</i> once the creation is moved
+      to the frontier, which is the section after this one:
     </Note>
 
     <Rows of={[
@@ -2126,9 +2128,42 @@ export const Law = () => {
       third of the way to the horizon in <i>any</i> universe this model
       describes” — got the density to cancel by using{' '}
       <V>ρ</V> = 3<V>H</V><Sup>2</Sup>/8π<V>G</V>. That is <i>Friedmann</i>, and
-      this model has no Friedmann equation. The absolute length survives —{' '}
-      <V>λ</V> = 1.60 Gpc at the observed density — and the universality of the
-      fraction does not. It is a fact about <i>our</i> density, not about any.
+      this model has no Friedmann equation. So the universality of the fraction
+      goes, and what is left is <V>λ</V>/<V>R</V><Sub>h</Sub> = 0.361/√<V>Ω</V>.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the absolute length does not survive
+        either</b>, which is the half that got missed. Reading it “at the
+      observed density” means <V>Ω</V> = 1 and gives 1.6 Gpc — but this model
+      has no dark matter and no dark energy, so the density that does the
+      screening is <i>the baryon one</i>:
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}><V>Ω</V> = 1, as assumed</span>,
+        <><V>λ</V>/<V>R</V><Sub>h</Sub> = 0.361, i.e. 1.5 Gpc — gravity dies
+          well inside the horizon, and large-scale structure can say so.</>],
+      [<span style={{ color: FAINT }}><V>Ω</V> = 0.315, ΛCDM’s matter</span>,
+        <><V>λ</V>/<V>R</V><Sub>h</Sub> = 0.644, i.e. 2.7 Gpc — still inside,
+          still in principle refusable.</>],
+      [<span style={{ color: BORROWED }}><V>Ω</V> = 0.049, <i>this model’s</i></span>,
+        <><V>λ</V>/<V>R</V><Sub>h</Sub> = <b style={{ color: INK }}>1.63</b>,
+          i.e. 6.9 Gpc. <b style={{ color: INK }}>Gravity reaches half again
+            past the horizon, so it never bites and there is nothing left to
+            exclude.</b> The prediction does not become wrong. It becomes
+          unfalsifiable, which here is the worse of the two.</>],
+    ]} />
+
+    <Note>
+      And it is not a constant any more. Coasting gives <V>ρ</V> ∝{' '}
+      <V>t</V><Sup>−3</Sup> against <V>R</V><Sub>h</Sub> ∝ <V>t</V>, so{' '}
+      <V>λ</V>/<V>R</V><Sub>h</Sub> ∝ √<V>t</V> — it <i>grows</i>: 0.49 at{' '}
+      <V>z</V> = 10, 0.81 at <V>z</V> = 3, 1.63 now. It bit once and passed out
+      through the horizon on the way here. <b style={{ color: INK }}>Moving the
+        creation to the frontier dissolved five closures and spent the one
+        prediction this file had that an instrument could refuse</b> — and the
+      first draft of that section counted the winnings without the bill.
     </Note>
 
     <Note>
@@ -2175,6 +2210,30 @@ export const Law = () => {
       better. The frontier has to be the only source.
     </Note>
 
+    <Note>
+      <b style={{ color: INK }}>Except that “one a tick” does not close, read
+        literally.</b> Half of what a frontier cell emits goes <i>inward</i> and
+      annihilates, so one emission a tick is a budget of <i>half</i> a cell and
+      the frontier advances at <V>c</V>/2. Which fails twice: the age becomes
+      2/<V>H</V><Sub>0</Sub> = 27.6 Gyr, twice the thing this construction was
+      about to be praised for getting right, and free-streaming matter
+      approaching <V>c</V> <i>overtakes the frontier</i> — a lattice with matter
+      outside it.
+    </Note>
+
+    <Note>
+      It survives on what <K>mass</K> actually says. The ceiling is one{' '}
+      <i>pulse</i> a tick and a pulse is <K>SHEET</K> charges, not one — so a
+      frontier cell puts <b style={{ color: INK }}>four</b> outward-going charges
+      into empty sky per tick, against the one needed to advance the shell. So{' '}
+      d<V>R</V>/d<V>t</V> = <V>c</V> does saturate, and the binding constraint is
+      the speed limit rather than the creation rate, which is what “the ceiling
+      is the rate” was reaching for. But it saturates{' '}
+      <b style={{ color: INK }}>with four times the room, not by a hair</b> — and
+      that surplus is its own unanswered question, since three cells’ worth of
+      creation a tick has nowhere to go.
+    </Note>
+
     <Rows of={[
       [<span style={{ color: DERIVED }}>five of the seven dissolve</span>,
         <>And for one reason rather than seven, since all five were consequences
@@ -2208,8 +2267,44 @@ export const Law = () => {
       4.45 Gpc, 2.6·10<Sup>183</Sup> cells, with a frontier
       9.1·10<Sup>122</Sup> cells across. And a tight consistency check: were
       that frontier ceiling-density <i>matter</i> rather than fresh neutral
-      space it would weigh 10<Sup>62</Sup> times the universe. It has to make
-      space and not matter — which is what <K>BITE</K> already said.
+      space it would weigh 1.2·10<Sup>114</Sup> kg, which is 10<Sup>61</Sup>{' '}
+      times the universe. It has to make space and not matter — which is what{' '}
+      <K>BITE</K> already said. Every number in this section now comes out of{' '}
+      <K>frontier</K> in <code>gravity.ts</code> rather than being typed in;
+      they were all right, and they were all unchecked.
+    </Note>
+
+    <Head>and then the supernovae, which decide it</Head>
+
+    <Note>
+      A coasting universe is <b style={{ color: INK }}><V>q</V><Sub>0</Sub> = 0
+        exactly</b>, with nothing to fit — no <V>Ω</V>, no <V>Λ</V>, no freedom
+      anywhere. The measured value is −0.55 ± 0.05. That is the test in one
+      line, and it is eleven sigma, but it deserves doing properly, because the
+      defence is a real one: a supernova’s absolute magnitude is a nuisance
+      parameter, so a <i>constant</i> offset in distance modulus is free — and{' '}
+      <V>H</V><Sub>0</Sub> is exactly degenerate with it. Only the{' '}
+      <i>shape</i> counts.
+    </Note>
+
+    <Note>
+      So marginalise the offset away and look at what is left, against ΛCDM at{' '}
+      <V>Ω</V><Sub>m</Sub> = 0.315. The residual runs +0.072 mag at{' '}
+      <V>z</V> = 0.02, through zero near 0.18, to −0.130 at <V>z</V> = 1 and
+      back to −0.098 at 2: <b style={{ color: INK }}>0.061 mag rms, 0.202 mag
+        peak to peak, and monotonic</b>. Pantheon+ bins carry 0.02–0.03 mag. And
+      the shape of that residual — nearby too bright, distant too faint — is
+      precisely the one the 1998 measurements found and named acceleration.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So the frontier cosmology fails the supernova
+        Hubble diagram at roughly the significance with which acceleration was
+        discovered</b>, and no choice of <V>H</V><Sub>0</Sub> helps, because{' '}
+      <V>H</V><Sub>0</Sub> is the parameter that was marginalised away. The age
+      coming out right was the strongest thing this section had; the same
+      construction, asked a second question, gets the answer wrong by the width
+      of the discovery that started modern cosmology. It was never asked.
     </Note>
 
     <Head>and where the middle would be</Head>
@@ -2379,13 +2474,48 @@ export const Law = () => {
 
     <Note>
       Every other term the model owns is checked and negligible: <i>reach</i>{' '}
-      costs 2·10<Sup>−3</Sup>% at 30 kpc, <i>carry</i> 1.1·10<Sup>−6</Sup> at
-      220 km/s, <i>shows</i> nothing at all — a galaxy is transparent. So the
-      model’s prediction here is Newton on the baryons, and it{' '}
-      <b style={{ color: INK }}>peaks at 192 km/s and falls to 104 by 30 kpc</b>{' '}
-      where the disc is measured flat at 220. The gap to close at 20 kpc is
-      +195%; the largest correction the model has is five orders under that.
-      There is no dial in it that reaches.
+      takes 1.9·10<Sup>−10</Sup> off the pull at 30 kpc, <i>carry</i> puts
+      2.4·10<Sup>−7</Sup> back on, <i>shows</i> nothing at all — a galaxy is
+      transparent. So the model’s prediction here is Newton on the baryons: it{' '}
+      <b style={{ color: INK }}>peaks at 193 km/s and falls to 104 by 30 kpc</b>,
+      against a curve Gaia measures at 229 km/s at the Sun and 200 at 25.
+      That is a shortfall in the pull of <b style={{ color: INK }}>52% at the
+        Sun and 242% at 30 kpc</b>.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And it is not this model’s shortfall in
+        particular</b>, which is the honest way to put it. General relativity is
+      on that same line. Its correction to Newton for a galaxy is the 1PN term,
+      of order <V>v</V><Sup>2</Sup>/<V>c</V><Sup>2</Sup> — about 4·10<Sup>−7</Sup>{' '}
+      at the Sun’s radius — and this model, having <V>β</V> = <V>γ</V> = 1,
+      reproduces exactly that size through <i>carry</i>. The one genuinely new
+      thing in this force law is <i>reach</i>, and at galactic radii it is
+      thirteen orders below the problem. Put all three on a log axis against
+      what is missing and there is nothing left to argue about:
+    </Note>
+
+    <Apart />
+
+    <Note>
+      Two lines at 10<Sup>−7</Sup>, one at 10<Sup>−10</Sup>, and the discrepancy
+      at 10<Sup>0</Sup>. <b style={{ color: INK }}>The entire difference between
+        Newton, Einstein and this model is six orders below the thing all three
+        of them miss.</b> Whatever dark matter is, it was never going to be
+      reached by a correction of that size — which is the reason the dashed
+      green curve is on the panel above. MOND with one number, not fitted here,
+      lands on the Gaia curve from 8 kpc out to 24 within a few km/s. Nothing in
+      the <i>force law</i> gets near it.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>Which is a statement about the force law and not
+        about the model</b>, and the difference matters for everything below. The
+      sections that follow find the missing piece somewhere else entirely — in
+      how the carriers <i>travel</i> rather than in how hard they pull — and that
+      route does produce the green curve, from one mechanism, with one number it
+      claims to fix rather than fit. Read this panel as closing off the obvious
+      direction, not as closing the question.
     </Note>
 
     <Note>
@@ -2464,6 +2594,152 @@ export const Law = () => {
       rotation curves and cannot make them scale.
     </Note>
 
+    <Head>a fourth, which is not a profile at all</Head>
+
+    <Note>
+      Do not give the vacuum a profile. Let it make pairs anywhere, and let{' '}
+      <b style={{ color: INK }}>one charge be caught by <V>A</V> and the other
+        by <V>B</V></b>. The pair was made with its point and never gives it
+      back, because its two halves were taken by different bodies and never met
+      each other. A net point is destroyed, a destroyed point is attraction, and
+      there is more of it where there is more empty space to make pairs in. The
+      bookkeeping is right: <K>BITE</K> makes creation and annihilation exact
+      inverses only for a pair that <i>self</i>-annihilates, and this one does
+      not.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And its radial law is the one thing every other
+        route failed to get.</b> A pair born at <V>P</V> reaches <V>A</V> with
+      weight <V>σ</V><Sub>A</Sub>/4π|<V>P</V>−<V>A</V>|<Sup>2</Sup> and{' '}
+      <V>B</V> with <V>σ</V><Sub>B</Sub>/4π|<V>P</V>−<V>B</V>|<Sup>2</Sup>, so
+      the linked rate is that product summed over everywhere a pair could be
+      born — and that integral is exactly π<Sup>3</Sup>/<V>R</V>. (The Fourier
+      transform of 1/<V>r</V><Sup>2</Sup> is 2π<Sup>2</Sup>/<V>k</V>, so the
+      convolution is 4π<Sup>4</Sup>/<V>k</V><Sup>2</Sup>, whose inverse is{' '}
+      π<Sup>3</Sup>/<V>R</V>. Monte Carlo agrees to 5%.)
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>One over <V>R</V>, where Newton is one over{' '}
+        <V>R</V><Sup>2</Sup></b> — so the ratio grows linearly with radius,
+      which is precisely what dark matter looks like and precisely MOND’s deep
+      limit. No profile assumed, no halo fitted, the exponent out of a geometric
+      integral rather than a choice. It is the best radial law anything in this
+      file has produced.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And the disc geometry works too.</b> The picture
+      is two bodies in <i>different spiral arms</i> — same radius, different
+      angle, a great deal of empty space between them to make pairs in. Both
+      halves of that check out. The <b style={{ color: INK }}>sign</b>: a star
+      sitting <i>in</i> a ring is pulled inward by the rest of it, since an
+      element at angle <V>θ</V> contributes cos <V>θ</V> − 1 ≤ 0 radially for
+      every <V>θ</V>. So arm-to-arm pull is centripetal — the direction the
+      missing gravity is missing in, and the opposite of what space made in an
+      exterior shell does.
+    </Note>
+
+    <Note>
+      And the <b style={{ color: INK }}>shape</b>. The mechanism <i>adds</i> a
+      1/<V>d</V> channel to Newton rather than replacing him — the direct
+      meeting of <V>A</V>’s charges with <V>B</V>’s is still there and still
+      1/<V>d</V><Sup>2</Sup>. Sum both over the real baryons, fit the one
+      coupling at the Sun and nowhere else, and against the Gaia curve it runs
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>0.981 · 1.000 · 0.996 · 0.985</span>,
+        <>at 6, 8, 10 and 12 kpc.</>],
+      [<span style={{ color: DERIVED }}>0.964 · 0.955 · 0.959 · 0.974</span>,
+        <>at 16, 20, 25 and 30 kpc — so{' '}
+          <b style={{ color: INK }}>inside 4.5% across the whole range the data
+            covers, on one constant</b>, where Newton alone is short by 52% at
+          the Sun and 242% at 30 kpc. Below 5 kpc it falls away, and below 5 kpc
+          there is no data either.</>],
+    ]} />
+
+    <Note>
+      Which is worth looking at rather than reading, since a rotation curve is a
+      graph and a graph hides what it means. Below: four spokes of stars laid
+      down along one radius and left to shear, under each of the three laws.
+      The dashed curve is the measured one, repeated in every panel.{' '}
+      <b style={{ color: INK }}>General relativity falls visibly behind it
+        within one turn of the Sun; the caught pair sits on top of it.</b>
+    </Note>
+
+    <Discs />
+
+    <Note>
+      <b style={{ color: INK }}>It dies twice anyway</b>, and neither death is
+      visible in that picture — which is the reason to be careful with pictures.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>first on Tully–Fisher</span>,
+        <>Same wall as the halo above, same reason. <V>σ</V> ∝ <V>m</V> at both
+          ends, so <V>F</V> ∝ <V>m</V><Sub>A</Sub><V>m</V><Sub>B</Sub>/<V>R</V>,
+          so <V>v</V><Sup>2</Sup> ∝ <V>M</V> and{' '}
+          <V>v</V><Sup>4</Sup> ∝ <V>M</V><Sup>2</Sup> — slope 2 against a
+          measured <b style={{ color: INK }}>3.85 ± 0.09</b>, which is 21σ.
+          Putting the vacuum in the middle does not make the law non-bilinear,
+          and the theorem does not care what the mediator is. The arms change
+          the geometry, not the mass dependence.</>],
+      [<span style={{ color: BORROWED }}>and second on the density</span>,
+        <>Which needs care, because the obvious version of this argument is{' '}
+          <i>wrong</i> — see below. It is not that the fog eats the mechanism.
+          The mechanism survives the fog. It is that the fog it needs leaves no
+          gravity to enhance.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>The correction, which is worth more than the
+        conclusion.</b> An earlier pass here said: the gain is linear in{' '}
+      <V>ΦR</V> and the loss exponential in it, so the loss wins. That was
+      comparing an attenuated gain against an <i>unattenuated Newton</i>.
+      Newton’s carriers cross the same fog. Put the attenuation on both sides
+      and most of it cancels — because the vacuum charge must reach <V>A</V>{' '}
+      and its partner must reach <V>B</V>, and{' '}
+      <V>r</V><Sub>A</Sub> + <V>r</V><Sub>B</Sub> ≥ <V>R</V>{' '}
+      <i>with equality on the segment</i>. The pair’s shortest route is Newton’s
+      route.
+    </Note>
+
+    <Note>
+      Done properly, in prolate spheroidal coordinates the angular part
+      collapses exactly and the enhancement comes out as{' '}
+      <b style={{ color: INK }}>4π<V>Φ</V>(ln(2<V>R</V>/<V>λ</V>) + <V>γ</V>)</b>,
+      since <V>Cλ</V> = √(<V>C</V>/<V>k</V>) = <V>Φ</V>.{' '}
+      <b style={{ color: INK }}>So it does survive the fog</b> — you were right
+      about that. What it does not do is <i>grow</i>: past <V>λ</V> the
+      enhancement is only logarithmic in <V>R</V>, and its size is fixed by{' '}
+      <V>Φ</V> and nothing else. All the extra space in the galaxy buys a
+      logarithm.
+    </Note>
+
+    <Note>
+      And then the same trap as everywhere else, by a new route. Ask the extra
+      pull to equal Newton’s at 10 kpc and it takes{' '}
+      <V>Φ</V> = 6.6·10<Sup>−4</Sup> per cell, which puts{' '}
+      <V>λ</V> — <i>the range of gravity</i> — at 3030 cells, or
+      4.9·10<Sup>−32</Sup> m. What is left of Newton at that <V>λ</V>: at a
+      nanometre <V>R</V>/<V>λ</V> = 2·10<Sup>22</Sup>, at 1 AU
+      3·10<Sup>42</Sup>, at 10 kpc 6·10<Sup>51</Sup>.{' '}
+      <b style={{ color: INK }}>The ratio is fine and there is nothing left to
+        take a ratio of.</b>
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>Which is the real answer to why <K>reach</K>{' '}
+        subtracts</b>, and it is not the one about signs. A mean free path only
+      ever subtracts, true — but the caught pair <i>is</i> gain, it does work,
+      and it is bounded at 4π<V>Φ</V>·log. <V>Φ</V> cannot be raised to make the
+      gain useful without lowering <V>λ</V> to where there is no gravity to
+      enhance. Gain and loss are not fighting over an exponent.{' '}
+      <b style={{ color: INK }}>They are the same number, spent twice.</b>
+    </Note>
+
     <Note>
       <b style={{ color: INK }}>The one hook that is native is an
         acceleration.</b> <V>a</V><Sub>0</Sub> = 1.20·10<Sup>−10</Sup> m/s²,{' '}
@@ -3589,7 +3865,914 @@ export const Law = () => {
       than from a new assumption — so the √<V>M</V> half stands on its own. The
       radial law is unexplained again, and the obstruction is exactly what it was
       before any of this: <V>n</V> ∝ 1/<V>r</V> needs the carriers to slow, and
-      everything in this model moves at <V>c</V>.
+      everything in this model moves at <V>c</V>. (The caught pair, later,
+      supplies that radial law from a different direction — so what follows is
+      about the <i>other</i> half.)
+    </Note>
+
+    <Head>test C — could √M come from the vacuum instead?</Head>
+
+    <Note>
+      Test A’s cancellation is a cancellation of <i>phases</i>, and it needs the
+      source to be an <b style={{ color: INK }}>amplitude</b> — a coherent sum —
+      rather than a count. Gravity here is a <i>rate</i> of annihilations, and
+      rates do not cancel. So the obvious thing to try is a cancellation that
+      works on counts: <b style={{ color: INK }}>a body’s own charges
+        annihilating each other on the way out</b>. Emit <V>N</V> pairs a tick
+      from a ball, let every + and − landing in the same cell annihilate, count
+      what crosses a distant sphere. Nothing assumed about randomness — the
+      charges are moved and met.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>It does cancel, and an optical depth controls
+        it.</b> The surface density of a body’s own charges is ~2<V>N</V>/4π<V>R</V><Sup>2</Sup>{' '}
+      per tick over a path ~<V>R</V>, so <V>τ</V> = <V>N</V>/(2π<V>R</V>) with{' '}
+      <V>R</V> in cells — and the measured survival collapses onto it exactly.
+      Three <V>N</V>,<V>R</V> pairs spanning sixteenfold in <V>N</V> give
+      52.0 / 49.4 / 51.0% at <V>τ</V> = 1.06, and 19.9 / 19.2 / 19.7% at 6.37.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And it passes through √<V>N</V> without stopping
+        there</b>, which is the finding. The exponent d(log <V>F</V>)/d(log{' '}
+      <V>N</V>) runs 0.920 at <V>τ</V> = 0.13, 0.734 at 0.80,{' '}
+      <b style={{ color: INK }}>0.563 at 1.99</b>, then 0.421, 0.273, 0.244. It
+      is not a plateau at ½ — it slides continuously from 1 toward 0 and touches
+      ½ at <V>τ</V> ≈ 2.5 on the way past. Tully–Fisher needs the <i>same</i>{' '}
+      exponent across five decades of mass, and <V>τ</V> ∝ <V>M</V>/<V>R</V>{' '}
+      varies across those decades. A crossover cannot impersonate a power law.
+    </Note>
+
+    <Note>
+      And it is moot anyway, because nothing real is dense enough. A proton sits
+      at <V>τ</V> = 4·10<Sup>−39</Sup>, the Earth 2·10<Sup>−9</Sup>, the Milky
+      Way 5·10<Sup>−7</Sup>, the Sun 5·10<Sup>−6</Sup>.{' '}
+      <b style={{ color: INK }}>Every real body is dilute</b> — its own flux
+      never meets itself, survival is 100%, and the flux goes as <V>N</V>{' '}
+      exactly. A galaxy is thirteen orders below where the cancellation starts,
+      which is the same fact <K>shows</K> reports from the other side.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>The one place it could ever bite is a neutron
+        star</b>, at <V>τ</V> = 0.44 — the only object within an order of the
+      threshold. So the mechanism is not nothing. It is a statement about the
+      densest matter there is, and it has nothing whatever to say about rotation
+      curves.
+    </Note>
+
+    <Note>
+      Which leaves Test A alone, and sharpens what it owes.{' '}
+      <b style={{ color: INK }}>The radial law is supplied</b> — the caught pair.{' '}
+      <b style={{ color: INK }}>The cancellation is supplied</b> — Test A,
+      measured. What is missing is one thing and it can now be stated in a line:{' '}
+      <b style={{ color: INK }}>a reason for a rate to care about a phase.</b>
+    </Note>
+
+    <Head>test D — and there is a reason, the wrong way round</Head>
+
+    <Note>
+      There is a candidate, and it is structurally the right shape:{' '}
+      <b style={{ color: INK }}>in this model a rate and a phase are the same
+        variable</b>. Mass is a <i>period</i> — <V>X</V> = 1/<V>m</V> ticks
+      between pulses — so the emission rate is the thing carrying the phase. And
+      gravity makes a body lighter,{' '}
+      <V>m</V><Sub>eff</Sub> = <V>m</V>/(1+<V>u</V>), so the well modulates it
+      and the two feed each other. Two pieces, both testable.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>The first fails on size.</b> For the well to
+      move a body across <i>inStep</i>’s switch, <V>m</V> must fall by{' '}
+      <V>m</V>·<V>R</V>/2π. At the Sun’s surface <V>u</V> = 2.1·10<Sup>−6</Sup>{' '}
+      against a factor 8.4·10<Sup>24</Sup> needed; in the Galaxy at 8 kpc,
+      3.7·10<Sup>−7</Sup> against 3.0·10<Sup>36</Sup>.{' '}
+      <b style={{ color: INK }}>Forty-three orders short</b> where it matters.
+      Gravity does make things lighter and cannot make them lighter enough to
+      change what they cancel to.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>The second works</b>, and does not need the
+      first. If emission is <i>pulsed</i> rather than steady, two charges meet
+      only when their bunches arrive together — so the meeting rate really does
+      depend on relative phase. Measured at fixed average emission, varying only
+      the spread of the phases: steady gives 28.2% survival; period 16{' '}
+      <i>all in step</i> gives <b style={{ color: INK }}>17.4%</b>; period 16
+      with random phases gives <b style={{ color: INK }}>28.5%</b>. Bunching
+      cancels, and only in step — random phases smooth out completely and are
+      indistinguishable from a steady source to a tenth of a percent.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>Test A’s √<V>N</V> needs them OUT of step</span>,
+        <><V>m</V>·<V>R</V> ≫ 2π — phases spread over many wavelengths, so the
+          coherent sum falls to √<V>N</V>.</>],
+      [<span style={{ color: DERIVED }}>Test D’s cancellation needs them IN step</span>,
+        <><V>m</V>·<V>R</V> ≪ 2π — bunches arriving together, so the arrivals
+          annihilate each other instead of being tallied.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>They are the same condition read in opposite
+        directions, so no body can have both.</b> A galaxy sits at{' '}
+      <V>m</V>·<V>R</V> ≈ 3·10<Sup>36</Sup>: its phases cancel beautifully and
+      its rate does not notice — which is exactly what Test C found from the
+      other side. Anything coherent enough for the rate to care is smaller than
+      a Compton wavelength and has nothing left to cancel. And even where it does
+      care it overshoots: quadrupling the mass in step gives a slope of 0.243,
+      against 0.35 out of step. Past ½ again, toward saturation.
+    </Note>
+
+    <Note>
+      So where <i>coherence</i> is concerned the bridge is missing because the
+      model makes the two requirements exclusive.{' '}
+      <b style={{ color: INK }}>But that tested the wrong variable, and the next
+        section overturns the conclusion.</b> Everything above asks whether the
+      feedback can move a body across <i>inStep</i>’s switch. It cannot — and it
+      does not have to.
+    </Note>
+
+    <Head>test E — and it works, with no phase in it at all</Head>
+
+    <Note>
+      Stated so it can be tested rather than argued:{' '}
+      <b style={{ color: INK }}>the loop feeds itself but by less each round.</b>{' '}
+      More fold makes a body lighter, lighter makes fewer pulses, fewer pulses
+      make less fold. A <i>self-limiting</i> feedback, and a self-limiting
+      feedback has a fixed point —{' '}
+      <V>M</V><Sub>eff</Sub> = <V>N</V>/(1 + <V>κM</V><Sub>eff</Sub><Sup>p</Sup>),
+      giving <V>M</V><Sub>eff</Sub> ∝ <V>N</V><Sup>1/(1+p)</Sup>. So everything
+      turns on <V>p</V>, and <V>p</V> is not a choice: it is what the
+      annihilation counting gives. So it was measured.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>measured <V>p</V> = 1.075</span>,
+        <>Emitters at the ceiling, slowed each round by the fold their own
+          charges built, iterated to a fixed point. The source slope runs 0.668,
+          0.530, <b style={{ color: INK }}>0.478</b> as <V>N</V> quadruples, and{' '}
+          <V>p</V> = d(log <V>u</V>)/d(log source) comes out 1.075 — predicting
+          an exponent of 0.482.</>],
+      [<span style={{ color: DERIVED }}>and the fixed point is exact</span>,
+        <>Solved directly over six decades: <V>p</V> = ½ gives 0.6671,{' '}
+          <V>p</V> = 1 gives <b style={{ color: INK }}>0.5000</b>, <V>p</V> = 2
+          gives 0.3333 — against 2/3, 1/2, 1/3 predicted.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>So this is not a crossover.</b> Tests C and D
+      gave exponents that slid <i>past</i> ½ on the way to saturation, which is
+      why neither could carry Tully–Fisher. This one{' '}
+      <b style={{ color: INK }}>converges on ½ and stays</b>, because ½ is a
+      fixed point of the loop rather than a point on a curve. And{' '}
+      <V>p</V> = 1 — the fold at an emitter going linearly with what its body
+      emits — is exactly what gives ½, and <V>p</V> = 1 is what was measured.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>The one thing in the way is the scale, and it is
+        seven orders, not forty-three.</b> The loop bites once <V>u</V> ≳ 1.
+      Read with <V>u</V> as the Newtonian potential, a proton sits at
+      1.5·10<Sup>−39</Sup> and the Milky Way at 2.0·10<Sup>−7</Sup> — exponent
+      1.000000 — while a neutron star reaches 0.87 and a body at its own{' '}
+      <V>r</V><Sub>s</Sub> reaches 0.75.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And <V>u</V> is not the Newtonian potential
+        here</b>, which is the whole point. This file already says so and files
+      it as a <i>defect</i>: <K>MADE</K> is a rate, so the fold{' '}
+      <i>accumulates</i> — <V>m</V>·<K>SHEET</K>·<V>t</V>/<V>r</V> passes{' '}
+      <V>Gm</V>/<V>r</V> after 0.008 ticks and keeps going. Over the age that is
+      a factor of 1.04·10<Sup>63</Sup>, which puts the proton at
+      1.5·10<Sup>24</Sup>, the Sun at 2.2·10<Sup>57</Sup>, the Milky Way at
+      2.1·10<Sup>56</Sup> — <b style={{ color: INK }}>every body at exactly ½,
+        and at the same ½</b>. One exponent, unchanging across five decades,
+      which is what Tully–Fisher demands and no crossover can supply.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So the defect and the mechanism are the same
+        fact.</b> The accumulating fold was written down as the reason the{' '}
+      <K>MADE</K> account could not be wired in; it is also the only thing that
+      puts real bodies where the feedback gives √<V>M</V>. One of those two
+      readings is wrong, and they cannot both stand.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>which channel</span>,
+        <>A √<V>M</V> source on the <i>direct</i> 1/<V>R</V><Sup>2</Sup> channel
+          makes gravity weaker, not stronger, and would show in the solar system.
+          It helps only if it scales the caught pair’s 1/<V>R</V> channel while
+          Newton’s keeps its count — and nothing here says why two channels would
+          couple to different things.</>],
+      [<span style={{ color: BORROWED }}>what stops it</span>,
+        <>An unbounded accumulating fold sends{' '}
+          <V>m</V><Sub>eff</Sub> → 0: every body fades. The fixed point above is
+          one in <V>N</V> at fixed <V>κt</V>, and the <V>t</V>-dependence has not
+          been solved at all.</>],
+      [<span style={{ color: BORROWED }}>and the solar system</span>,
+        <>If <V>u</V> really is 10<Sup>57</Sup> at the Sun then <K>slowing</K>,{' '}
+          <K>thickness</K> and every GR test in this file are computed from the
+          wrong <V>u</V> — and those pass. That is the sharpest objection to the
+          accumulating reading and it is not answered here.</>],
+    ]} />
+
+    <Note>
+      None of which retracts the measurement.{' '}
+      <b style={{ color: INK }}>The self-limiting loop gives an exponent of
+        exactly ½, as a fixed point, out of the model’s own two rules</b> — mass
+      is a period, and fold slows the period. It is the first mechanism in this
+      file that <i>produces</i> the mass law rather than approaching it.
+    </Note>
+
+    <Head>and which slowing is it?</Head>
+
+    <Note>
+      There are two readings of that chain, and they give <i>different</i>{' '}
+      exponents — so for once the data can choose. Test E slowed the emitter by
+      the <b style={{ color: INK }}>fold</b> it sits in. The other reading is the
+      model’s own speed rule, and is arguably the more native one:{' '}
+      <i>it accelerates → it goes faster → it moves on more ticks and updates on
+        fewer → it ticks less → it is lighter → it pulls less → it accelerates
+        less.</i> Same self-limiting shape, but driven by <K>massFor</K> rather
+      than <K>slowing</K>.
+    </Note>
+
+    <Note>
+      The exponent comes from how the driver scales with the source, and that is
+      where they part company. <V>M</V><Sub>eff</Sub> ∝{' '}
+      <V>N</V><Sup>1/(1+p)</Sup>, measured over six decades and converged to
+      five figures: the fold gives <V>p</V> = 1 and{' '}
+      <b style={{ color: INK }}>0.50000</b>; speed gives <V>p</V> = ½ and{' '}
+      <b style={{ color: INK }}>0.66667</b> — because{' '}
+      <V>v</V><Sup>2</Sup> = <V>GM</V>/<V>r</V>, so{' '}
+      <b style={{ color: INK }}>speed already carries its own square root</b>,
+      and a feedback driven by it can only spend that root once.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>no feedback — <V>e</V> = 1</span>,
+        <>Tully–Fisher slope 2.00. <b style={{ color: INK }}>20.6σ</b> out.</>],
+      [<span style={{ color: BORROWED }}>speed as driver — <V>e</V> = 2/3</span>,
+        <>Slope 3.00. <b style={{ color: INK }}>9.4σ</b> out.</>],
+      [<span style={{ color: DERIVED }}>fold as driver — <V>e</V> = 1/2</span>,
+        <>Slope 4.00 against a measured 3.85 ± 0.09 —{' '}
+          <b style={{ color: INK }}>1.7σ</b>, i.e. inside the error.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>The fold reading lands inside 2σ and the speed
+        reading does not.</b> So the chain is right and the driver has to be the
+      one that scales <i>linearly</i> with the source. That is a real
+      discrimination between two versions of one idea, made by data rather than
+      by preference — and the first time anything in this file has been able to
+      choose between two mechanisms on the mass law.
+    </Note>
+
+    <Note>
+      And the speed reading is too small anyway, independently of its exponent.{' '}
+      <V>v</V>/<V>c</V> is the whole size of it: 9.9·10<Sup>−5</Sup> at the
+      Earth’s orbit, 7.6·10<Sup>−4</Sup> for the Sun round the Galaxy,
+      3.3·10<Sup>−3</Sup> in a cluster. Run on the Milky Way it slows the curve
+      by 0.06% at 2 kpc and 0.02% at 30, where the discrepancy is a factor of
+      two. <b style={{ color: INK }}>The sign is right and nothing else is</b> —
+      the same verdict <K>carry</K> got, for the same reason.
+    </Note>
+
+    <Note>
+      What survives of it: the speed rule is not the driver of the mass law, but
+      it shows the two readings are not interchangeable, and it explains{' '}
+      <i>why</i> the fold reading works —{' '}
+      <b style={{ color: INK }}>the feedback needs a driver that has not already
+        spent the square root</b>, and the accumulated fold is the only such
+      quantity the model has.
+    </Note>
+
+    <Head>test F — and then it was run on a whole galaxy</Head>
+
+    <Note>
+      Tests C, D and E were boxes of a few thousand cells, or transients begun
+      from nothing at <V>t</V> = 0. A galaxy is neither. So it was rebuilt: the
+      real Milky Way baryons ring by ring with no shell theorem,{' '}
+      <b style={{ color: INK }}>the field solved as a fixed point rather than a
+        transient</b> — every source weakened by the field it sits in, that field
+      made by all the already-weakened sources, iterated to convergence, which is
+      what “gravity has already propagated everywhere” has to mean — and the
+      circular speed at every radius solved <i>together with</i> the field, so a
+      speed-driven feedback is fed the speed it actually produces.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>First, the thing that settles the speed question
+        outright</b>, and it is more general than any exponent. Pushed to{' '}
+      <V>κ</V> = 10<Sup>6</Sup>, far past anything physical, with the galaxy’s
+      own self-consistent speeds, the curve at the Sun goes 185.6 → 180.9 →
+      102.2 → 66.2.{' '}
+      <b style={{ color: INK }}>A feedback that weakens the source can only lower
+        a rotation curve.</b> Monotone in <V>κ</V>, and it never turns around. So
+      the feedback is not the dark matter and cannot be — it can only govern how
+      an excess supplied by something <i>else</i> scales with mass.
+    </Note>
+
+    <Note>
+      So the honest object is the pair: the caught pair’s 1/<V>R</V> channel
+      supplying the excess, the feedback setting its mass scaling. Two
+      requirements at once — the <b style={{ color: INK }}>shape</b> of one
+      rotation curve, and the <b style={{ color: INK }}>slope</b> across five
+      decades of galaxy mass with sizes following the observed{' '}
+      <V>R</V> ∝ <V>M</V><Sup>0.35</Sup>. Five drivers, three channel choices,
+      local or body-averaged, eight couplings.{' '}
+      <b style={{ color: INK }}>No permutation meets both.</b>
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>caught pair alone</span>,
+        <>shape <b style={{ color: INK }}>3.2%</b>, BTFR slope 2.51.</>],
+      [<span style={{ color: FAINT }}>+ feedback, <V>κ</V> = 10<Sup>6</Sup></span>,
+        <>shape 9.7%, slope 2.92.</>],
+      [<span style={{ color: BORROWED }}>+ feedback, saturated</span>,
+        <>shape 19.8%, slope <b style={{ color: INK }}>3.25</b> — and the curve
+          now <i>rises</i>: <V>v</V>(30) = 264.9 against <V>v</V>(8) = 229, where
+          Gaia has it falling.</>],
+      [<span style={{ color: INK }}>wanted</span>,
+        <>shape under 5%, slope 3.85 ± 0.09. The best joint fit anywhere in the
+          search is <b style={{ color: INK }}>6.7σ</b> away.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>Which corrects Test E, and the correction is the
+        point.</b> Test E measured the exponent on what was effectively a point
+      source and got exactly ½; that stands as arithmetic. What it could not see
+      is that <i>reaching</i> the regime where the exponent is ½ needs{' '}
+      <V>κu</V> ≫ 1 throughout the galaxy — and a <V>u</V> that varies by an
+      order of magnitude across the disc cannot be deep in that regime everywhere
+      without deforming the profile.{' '}
+      <b style={{ color: INK }}>The fixed point is real and it is not reachable
+        with a rotation curve still attached.</b>
+    </Note>
+
+    <Note>
+      (One bug found on the way, recorded because it changed a number: the bulge
+      was being added <i>unweakened</i>. At large <V>κ</V> the disc was crushed
+      and the untouched bulge dominated, dragging the slope back to Newton’s 2.07
+      and making the feedback look useless in the wrong direction. Weakened
+      consistently — a bulge is made of emitters too — the slope rises to 3.25
+      instead. The conclusion did not change; the number was wrong.)
+    </Note>
+
+    <Note>
+      So: <b style={{ color: INK }}>the chain is sound</b>, self-limiting, with a
+      real fixed point. <b style={{ color: INK }}>The exponent is right in
+        isolation</b>, ½, measured twice.{' '}
+      <b style={{ color: INK }}>The shape is supplied</b>, by the caught pair, at
+      3.2%. <b style={{ color: INK }}>And they cannot be had together.</b> That
+      is not a gap in the argument — it is a measured incompatibility between the
+      two halves, on a galaxy, with the field relaxed and one number fitted. The
+      model still has no dark matter; what is different is that it is no longer
+      missing a mechanism. It has two, each doing its own half correctly, and a
+      demonstration that they do not compose.
+    </Note>
+
+    <Head>test G — they do compose</Head>
+
+    <Note>
+      <b style={{ color: INK }}>That last sentence is withdrawn, and the fault
+        was in the test.</b> Every feedback above was written{' '}
+      <V>m</V>/(1+<V>κD</V>), which <i>saturates</i>: past <V>κD</V> ≫ 1 it stops
+      responding and the exponent stalls wherever it happened to be. That form
+      was mine. It is nowhere in the model. The model’s own conversion is a{' '}
+      <i>power law</i>, and a power law never saturates:{' '}
+      <b style={{ color: INK }}><K>massFor</K>(<V>v</V>) = <V>c</V>/<V>v</V></b>,
+      so <V>m</V> ∝ 1/<V>v</V> exactly.
+    </Note>
+
+    <Note>
+      So the honest test is <V>m</V><Sub>eff</Sub> ∝ <V>v</V><Sup>−q</Sup>{' '}
+      solved self-consistently, with <b style={{ color: INK }}><V>q</V> = 1 being
+        the model’s own rule and not a fitted exponent</b>. The expectation is
+      clean: for the caught pair’s flat channel{' '}
+      <V>v</V><Sup>2</Sup> = <V>λM</V><Sub>eff</Sub> ∝ <V>λN</V><V>v</V><Sup>−q</Sup>,
+      so <V>v</V><Sup>2+q</Sup> ∝ <V>N</V> and the Tully–Fisher slope is{' '}
+      <b style={{ color: INK }}>2 + <V>q</V></b>.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: FAINT }}><V>q</V> = 0 — caught pair alone</span>,
+        <>shape 3.2%, slope 2.51.</>],
+      [<span style={{ color: DERIVED }}><V>q</V> = 1 — the model’s <K>massFor</K></span>,
+        <>shape <b style={{ color: INK }}>2.6%</b>, slope{' '}
+          <b style={{ color: INK }}>3.60</b>. Both halves improve at once — the
+          shape is <i>better</i> than the caught pair had alone.</>],
+      [<span style={{ color: FAINT }}><V>q</V> = 2</span>,
+        <>shape 1.1%, slope 4.58 — overshoots.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>They are not in tension; each helps the other</b>,
+      which is what a composition ought to look like and what Test F said was
+      impossible. Against Gaia radius by radius, on one fitted number: 0.991 at
+      6 kpc, 0.999 at 8, 0.985 at 12, 0.964 at 20, 0.990 at 30 —{' '}
+      <b style={{ color: INK }}>inside 3.6% from 6 to 30 kpc</b>, where Newton is
+      short by 52% and 242% at the two ends.
+    </Note>
+
+    <Note>
+      And the slope’s remaining gap is <i>my</i> systematic, not the model’s.
+      3.60 against 3.85 ± 0.09 is 2.8σ — but the galaxy family is my
+      construction, and its assumed size–mass relation moves the answer further
+      than the discrepancy does: <V>R</V> ∝ <V>M</V><Sup>0.20</Sup> gives 3.31,{' '}
+      <V>M</V><Sup>0.35</Sup> gives 3.60, <V>M</V><Sup>0.50</Sup> gives 4.03.{' '}
+      <b style={{ color: INK }}>The measured 3.85 sits inside that range</b>, at{' '}
+      <V>s</V> ≈ 0.42.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>the sign of the identity</span>,
+        <>Which decides everything. <K>massFor</K> is a <i>cost</i> per step and
+          is ≥ 1; the emission side is a <i>rate</i> and is ≤ 1, and{' '}
+          <code>physics.ts</code> bridges them with “once a tick is the ceiling,
+          which <i>turns the identity round</i>”. If the rate is <V>m</V> the
+          source goes as 1/<V>v</V> and <V>q</V> = +1, giving 3.60. If it is
+          1/<V>m</V> the source goes as <V>v</V> and <V>q</V> = −1, giving{' '}
+          <b style={{ color: INK }}>1.30</b>. The whole result rides on a reading
+          this file asserted in one direction and used in the other.</>],
+      [<span style={{ color: BORROWED }}><V>λ</V> is still fitted</span>,
+        <>One number, but nothing derives it — so until something does, this is a
+          one-parameter fit that happens to have the right shape.</>],
+      [<span style={{ color: BORROWED }}>and the density bill stands</span>,
+        <>The <V>Φ</V> that makes <V>λ</V> this big puts the range of gravity at
+          5·10<Sup>−32</Sup> m. Nothing here answers that, and it is still the
+          reason the mechanism cannot yet be believed.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>But the composition is real and it was
+        measured.</b> Two mechanisms, each derived for its own reason, one fitted
+      constant between them, and both the shape of a rotation curve and the mass
+      scaling of a population come out together. That has not happened before in
+      this file. <b style={{ color: INK }}>And then the sign was settled, against
+        it.</b>
+    </Note>
+
+    <Head>test H — settling the sign</Head>
+
+    <Note>
+      Test G rode entirely on reading <K>massFor</K>(<V>v</V>) = <V>c</V>/<V>v</V>{' '}
+      as the emission rate. Take the model’s own account of what a step costs —{' '}
+      <b style={{ color: INK }}>a step takes a point from in front and puts one
+        behind, so a step costs a tick</b> — and the budget is forced:
+      the share of ticks spent moving plus the share spent updating is one, so
+      the pulse rate goes as (1 − <V>v</V>/<V>c</V>). Which is not{' '}
+      <V>c</V>/<V>v</V>, and the difference is everything.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>source ∝ 1/<V>v</V> (test G)</span>,
+        <>weakening of order one — shape 2.6%, slope 3.60.</>],
+      [<span style={{ color: DERIVED }}>source ∝ (1−<V>v</V>/<V>c</V>) — the budget</span>,
+        <>weakening of <b style={{ color: INK }}>0.076%</b> — shape 3.2%, slope{' '}
+          <b style={{ color: INK }}>2.509</b>. Which is the caught pair alone, to
+          three digits.</>],
+    ]} />
+
+    <Note>
+      And <K>massFor</K> cannot be pressed into service instead, for a reason
+      that is structural rather than numerical.{' '}
+      <b style={{ color: INK }}>It is a cost per step and is ≥ 1; the emission
+        side is a rate and is ≤ 1 by the one-a-tick ceiling.</b> Disjoint ranges,
+      meeting only at exactly 1. There is no reading on which a star’s
+      constituents, orbiting at 7.6·10<Sup>−4</Sup> <V>c</V>, have an emission
+      rate of 1362 pulses a tick against a ceiling of one. Test G’s exponent was
+      never available — it was reading a <i>cost</i> as a <i>rate</i> because
+      this file calls both of them “mass”.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So Test G is withdrawn as a result.</b> What
+      survives is its method and one real lesson: a <i>saturating</i> feedback
+      and a <i>power-law</i> one behave completely differently, and Test F’s
+      failure was the saturating form’s fault. That correction stands. The 3.60
+      does not.
+    </Note>
+
+    <Head>and what that leaves standing</Head>
+
+    <Note>
+      The transport route — and it needs none of this.{' '}
+      <b style={{ color: INK }}>Its √<V>M</V> does not come from the source at
+        all</b>: flux conservation goes <i>quadratic</i> in <V>n</V> once the
+      drift is <V>v</V> = <V>c</V>·min(1, <V>n</V>/<V>n</V><Sub>c</Sub>), and the
+      root falls out of the transport. Its sign is fixed by <K>inStep</K> read as
+      a budget — in step, one phase paid once, so dense is fast — rather than by
+      identifying two incompatible masses. And it had never been run on a galaxy.
+      Run now, on the relaxed disc:
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}><V>g</V><Sub>c</Sub> = 1.2·10<Sup>−10</Sup> m/s²</span>,
+        <>shape <b style={{ color: INK }}>1.0%</b>, slope 3.43. The best shape any
+          mechanism in this file has managed — and that <V>g</V><Sub>c</Sub> is{' '}
+          <V>a</V><Sub>0</Sub>.</>],
+      [<span style={{ color: FAINT }}>either side of it</span>,
+        <>1.0·10<Sup>−10</Sup> gives 2.5%, 1.5·10<Sup>−10</Sup> gives 4.8% — so
+          the fit is real but not sharp.</>],
+    ]} />
+
+    <Note>
+      So the three routes, honestly: the caught pair alone gives 3.2% and 2.51,
+      and owes a density that kills gravity at 5·10<Sup>−32</Sup> m. The source
+      feedback is <b style={{ color: BORROWED }}>retired</b>. And the transport
+      route gives <b style={{ color: INK }}>1.0% and 3.43</b>, owing{' '}
+      <i>one number</i>: <V>n</V><Sub>c</Sub> = (<V>m</V>/2π)<Sup>3</Sup> wants
+      an emitter at <b style={{ color: INK }}>28.9 MeV</b>, where the electron
+      gives 5.5·10<Sup>−6</Sup> of what is needed and the proton
+      3.4·10<Sup>4</Sup>.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>The transport route is the one to back.</b> It is
+      the only one whose sign is derived rather than asserted, it needs no new
+      rule — <K>inStep</K> was already derived and measured — it gives both halves
+      from one mechanism, and its single bill is a number rather than a
+      structure. Either something sits near 29 MeV, or the Compton wavelength
+      that matters belongs to the <i>carrier</i> and not to the source. That is
+      one question, it is about <code>physics.ts</code>, and the whole dark-matter
+      thread now hangs off it.{' '}
+      <b style={{ color: INK }}>And it was the wrong question.</b>
+    </Note>
+
+    <Head>test I — the scale comes from the expansion</Head>
+
+    <Note>
+      The 29 MeV bill came from setting <V>n</V><Sub>c</Sub> by a{' '}
+      <i>constituent’s</i> Compton wavelength — looking for the scale in the
+      wrong place, and the whole model says so.{' '}
+      <b style={{ color: INK }}>Space being made is the mechanism.</b> Making
+      space has a rate, that rate is <V>H</V>, and an acceleration built out of
+      it is <V>cH</V>. The frontier already forces{' '}
+      <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> exactly, so <V>cH</V><Sub>0</Sub>{' '}
+      is a <i>count of ticks</i> rather than a constant anyone chose. And the 2π
+      is <K>inStep</K>’s own, since in step means within 2π of phase.
+    </Note>
+
+    <Eq open={show} note="the acceleration scale, from the expansion alone">
+      <V>a</V><Sub>0</Sub> = <Frac over={<><V>c</V> <V>H</V><Sub>0</Sub></>} under={<>2π</>} />
+    </Eq>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>the prediction</span>,
+        <>1.041·10<Sup>−10</Sup> at <V>H</V><Sub>0</Sub> = 67.4,{' '}
+          <b style={{ color: INK }}>1.096·10<Sup>−10</Sup></b> at 70.9,
+          1.129·10<Sup>−10</Sup> at 73.0 — against a measured
+          1.200·10<Sup>−10</Sup>. <b style={{ color: INK }}>Nine percent, with
+            nothing fitted anywhere.</b></>],
+      [<span style={{ color: DERIVED }}>and on the galaxy</span>,
+        <>Run with the predicted value and no fitting of any kind:{' '}
+          <b style={{ color: INK }}>1.1% on the Milky Way’s rotation curve</b>,
+          Tully–Fisher slope 3.42. Radius by radius, 0.977 · 0.997 · 0.999 ·
+          0.995 · 0.987 · 0.987 · 1.002 · 1.028 from 6 to 30 kpc, where Newton
+          runs 0.83 down to 0.54.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>Which retires the 29 MeV bill entirely.</b> It
+      was the price of assuming the coherence scale belonged to a constituent. It
+      belongs to the expansion — which this model has its own account of — and
+      the two numbers agree to nine percent without either being adjusted to meet
+      the other.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And this is where the frontier cosmology earns
+        its keep.</b> <V>a</V><Sub>0</Sub> ≈ <V>c</V>/(2π<V>t</V><Sub>0</Sub>) is
+      a known coincidence and an embarrassment everywhere else — why should a
+      galaxy know the age of the universe? Here{' '}
+      <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> is not a coincidence but the
+      construction, so the galaxy is not being told the age. It is being told the
+      rate at which space is made, which is the same number because the frontier
+      makes it so. <b style={{ color: INK }}>The cosmology and the rotation
+        curves are the same fact.</b>
+    </Note>
+
+    <Note>
+      And it predicts something MOND cannot, which is the point of having a
+      reason. <V>a</V><Sub>0</Sub> = <V>c</V>/(2π<V>t</V>) is{' '}
+      <i>not a constant</i> — it falls as the universe ages:
+      2.19·10<Sup>−10</Sup> at <V>z</V> = 1, 3.29·10<Sup>−10</Sup> at{' '}
+      <V>z</V> = 2, 5.48·10<Sup>−10</Sup> at <V>z</V> = 4. MOND has no reason for{' '}
+      <V>a</V><Sub>0</Sub> to depend on anything and treats it as a constant of
+      nature. <b style={{ color: INK }}>This route makes it a clock reading</b>,
+      so high-redshift rotation curves are a direct test.
+    </Note>
+
+    <Note>
+      <b style={{ color: BORROWED }}>And the first look at that test is not
+        comfortable.</b> Genzel et al. (2017) find massive discs at{' '}
+      <V>z</V> ≈ 2 with <i>declining</i> outer rotation curves — baryon-dominated,
+      less of a dark-matter effect, not more. A larger{' '}
+      <V>a</V><Sub>0</Sub> pushes more of a galaxy into the deep regime and
+      predicts a <i>larger</i> one. The two pull opposite ways. Not immediately
+      contradictory, since high-<V>z</V> discs are denser and{' '}
+      <V>g</V><Sub>N</Sub> rises too and what matters is the ratio — but the sign
+      of the tension is the wrong one, and it has not been worked out here.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>the one link</span>,
+        <>Unchanged since it was first written down: that a carrier’s update cost
+          goes as its accumulated phase. Everything in the transport route rests
+          on it, and it is a <code>physics.ts</code> question about what a tick
+          is spent on.</>],
+      [<span style={{ color: BORROWED }}>the 2π</span>,
+        <>Taken from <K>inStep</K> by analogy rather than derived for this use. It
+          is the difference between 9% and 43%, so it is load-bearing.</>],
+    ]} />
+
+    <Note>
+      But the shape of the result is new for this file:{' '}
+      <b style={{ color: INK }}>a rotation curve fitted to one percent by a
+        number the model computes from its own cosmology</b>, with a dated
+      prediction attached that distinguishes it from the phenomenology it
+      reproduces. Nothing else in the dark-matter thread has been in that
+      position.
+    </Note>
+
+    <Head>test J — the polarity is a coin</Head>
+
+    <Note>
+      Test A’s √<V>N</V> came from <i>phase</i> cancellation, which needs{' '}
+      <V>m</V>·<V>R</V> ≫ 2π, hence an emitter mass, hence the 29 MeV bill. But{' '}
+      <b style={{ color: INK }}>the model never gives a wave a definite
+        polarity</b>. A neutral point becomes a ± pair and nothing decides which
+      half goes which way — the attribution is a fair coin, and the expansion
+      that made the point has no polarity to hand it. A fair coin gives{' '}
+      √<V>N</V> by itself, at every scale, with no coherence anywhere.
+    </Note>
+
+    <Note>
+      Measured over an ensemble of forty realisations, since the imbalance is a
+      random variable and one draw says nothing:{' '}
+      <b style={{ color: INK }}>rms(net)/√total is flat</b> — 0.064, 0.097,
+      0.077, 0.141 across a sixty-fourfold range in <V>N</V> — and it does not
+      depend on the body’s size either, 0.065 · 0.061 · 0.075 at radii 5, 10 and
+      16, where the phase route varied by orders across the same span. The ±
+      imbalance is exactly the fair-coin fluctuation on the arrivals and cares
+      about nothing else.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>Which confirms Test I from the other
+        direction.</b> Test I removed the 29 MeV bill by finding the scale in the
+      expansion; this removes the <i>reason</i> anyone looked for a Compton
+      wavelength at all — there was never a coherence condition to satisfy. Two
+      independent routes to the same conclusion: no emitter mass enters the
+      dark-matter account anywhere.
+    </Note>
+
+    <Note>
+      <b style={{ color: BORROWED }}>But a fluctuation has no sign.</b> It cannot
+      be the source of a systematic attraction, and if gravity coupled to it at
+      every scale the solar system would be gone — the Sun’s 10<Sup>57</Sup>{' '}
+      emitters would act as 10<Sup>28.5</Sup>. So this is not an alternative to
+      the transport route; it is the removal of an objection to it. The
+      systematic pull stays with the count, and the √<V>M</V> stays in the
+      transport, where flux conservation goes quadratic.
+    </Note>
+
+    <Head>test K — and the high-redshift discs refuse it</Head>
+
+    <Note>
+      The worry above is now measured rather than left standing. Genzel’s six
+      discs, their masses and sizes put through the transport route inside one
+      effective radius, against the <V>f</V><Sub>DM</Sub> &lt; 0.2 they measure —
+      which is a boost under about 1.12:
+    </Note>
+
+    <HighRedshift />
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>four of five are over the line</span>,
+        <>With <V>a</V><Sub>0</Sub> ∝ 1/<V>t</V>: 1.179, 1.170, 1.164, 1.239
+          against an allowed 1.12. With <V>a</V><Sub>0</Sub> fixed, none is —
+          ordinary MOND is marginal here and survives, and{' '}
+          <b style={{ color: INK }}>the model’s own time-dependence does
+            not</b>.</>],
+      [<span style={{ color: BORROWED }}>out by a factor of three</span>,
+        <>Inverted: the largest <V>a</V><Sub>0</Sub> these galaxies permit is
+          1.09× today’s, i.e. <V>z</V> &lt; 0.09. The coasting cosmology wants{' '}
+          <b style={{ color: INK }}>3.20×</b> at <V>z</V> = 2.2.</>],
+      [<span style={{ color: FAINT }}>and the one that passes</span>,
+        <>zC_400569, because it is compact — 3.3 kpc at 2·10<Sup>11</Sup> M☉, so
+          its own <V>g</V><Sub>N</Sub> is 6.2 <V>a</V><Sub>0</Sub> and it is
+          Newtonian either way. The discs that refuse the prediction are the
+          extended ones.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>So the one thing that dated the model is the one
+        thing the data refuses.</b> Which is the right way round for a prediction
+      to fail: it was specific, derived rather than fitted, and refutable by
+      measurements that already existed. What it costs is exactly the part of
+      Test I that made <V>a</V><Sub>0</Sub> a clock reading.{' '}
+      <b style={{ color: INK }}>What survives is the value</b> —{' '}
+      <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π at the present epoch is
+      still 9% from the measured number with nothing fitted, and still fits the
+      Milky Way to 1.1%.
+    </Note>
+
+    <Note>
+      And what would have to be true for it to live:{' '}
+      <V>a</V><Sub>0</Sub> would have to track something <i>local</i>, and that
+      quantity would have to stay roughly constant over
+      0 &lt; <V>z</V> &lt; 2.2 while 1/<V>t</V> trebles.{' '}
+      <b style={{ color: INK }}>Which is exactly what the next section finds</b>,
+      so the version of this paragraph that said the model had no such quantity
+      was wrong. It has one.
+    </Note>
+
+    <Head>test L — the bulk makes no space, but it makes gravity</Head>
+
+    <Note>
+      The frontier construction forbids the bulk from <i>creating</i> space. It
+      says nothing about the bulk <i>coupling</i> — and the caught pair is
+      exactly that: a pull mediated by the vacuum between two bodies, whose
+      strength goes with how much vacuum there is to mediate it.{' '}
+      <b style={{ color: INK }}>More empty space between two things, more
+        pull.</b> That is local, and it is the thing the last test said the model
+      did not have.
+    </Note>
+
+    <Note>
+      <b style={{ color: BORROWED }}>First the version that fails</b>, because it
+      is instructive. Read the emptiness as the local baryon <i>density</i>,{' '}
+      <V>a</V><Sub>0</Sub>·(<V>ρ</V><Sub>ref</Sub>/<V>ρ</V>)<Sup>s</Sup>: at{' '}
+      <V>s</V> = 0 the Milky Way fits to 1.1% and the worst Genzel boost is
+      1.239; at <V>s</V> = 1 the boost falls to 1.107 but the Milky Way is out
+      by 77%. <b style={{ color: INK }}>No value of <V>s</V> does both</b> —
+      because <V>ρ</V> varies by fifty <i>within</i> one galaxy, so a rule keyed
+      to it cannot tell between-galaxies from within-a-galaxy.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>And that points straight at the fix: the space
+        between two bodies is a length, not a volume.</b> It is measured along
+      the line joining them, so what counts is the mean <i>spacing</i>,{' '}
+      <V>ρ</V><Sup>−1/3</Sup>, not the density. And then both factors are fixed
+      by the epoch alone — <V>H</V> ∝ (1+<V>z</V>) from the frontier’s own{' '}
+      <V>H</V> = 1/<V>t</V>, and spacing ∝ (1+<V>z</V>)<Sup>−1</Sup> since{' '}
+      <V>ρ</V> ∝ (1+<V>z</V>)<Sup>3</Sup>.
+    </Note>
+
+    <Eq open={show} note="and the two factors cancel, identically">
+      <V>a</V><Sub>0</Sub> = <Frac over={<><V>c</V> <V>H</V></>} under={<>2π</>} />
+      <span style={{ padding: '0 0.6em' }}>·</span>
+      <Frac over={<>spacing</>} under={<>spacing<Sub>0</Sub></>} />
+      <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+      <Frac over={<><V>c</V> <V>H</V><Sub>0</Sub></>} under={<>2π</>} />
+    </Eq>
+
+    <Note>
+      Not approximately — <i>identically</i>. <V>a</V><Sub>0</Sub>(<V>z</V>)/<V>a</V><Sub>0</Sub>(0)
+      is 1.0000 at <V>z</V> = 0.5, 1, 1.5, 2, 2.5 and 4, because the clock speeds
+      up by precisely the factor the spacing shrinks by. So{' '}
+      <b style={{ color: INK }}>a₀ is constant in redshift and still equal to{' '}
+        <V>cH</V><Sub>0</Sub>/2π</b>: the 9% value survives, the Milky Way stays
+      at 1.1%, and the Genzel boosts fall back to 1.112, 1.083, 1.077, 1.101,
+      1.019 — <b style={{ color: INK }}>every one under the allowed 1.12</b>.
+    </Note>
+
+    <HighZDiscs />
+
+    <Note>
+      Which is what the refutation in Test K was really of:{' '}
+      <V>a</V><Sub>0</Sub> ∝ 1/<V>t</V> was the mechanism with half of it
+      dropped. “More empty space, more pull” was the idea; leaving the emptiness
+      out and keeping only the clock is what the data refused.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>what is gained</span>,
+        <>The 9% value survives, the Milky Way fit survives, and the
+          high-<V>z</V> discs stop refusing it.</>],
+      [<span style={{ color: BORROWED }}>and what is lost</span>,
+        <><b style={{ color: INK }}>The dated prediction.</b>{' '}
+          <V>a</V><Sub>0</Sub> constant is what MOND already assumes, so the model
+          no longer says anything about redshift that MOND does not. The thing
+          that made it refutable is the thing that had to go for it to survive —
+          an honest trade and not a good one, and it should be read as the model
+          becoming <i>harder to test</i> rather than as it becoming more
+          right.</>],
+    ]} />
+
+    <Note>
+      What is still owed is unchanged and it is one thing:{' '}
+      <b style={{ color: INK }}>that a carrier’s update cost goes as its
+        accumulated phase</b>. Everything in the transport route rests on it. It
+      is a <code>physics.ts</code> question about what a tick is spent on, and it
+      has been owed since the mechanism was first written down —{' '}
+      <b style={{ color: INK }}>and the next section pays part of it.</b>
+    </Note>
+
+    <Head>test M — the carriers already there block the splitting</Head>
+
+    <Note>
+      Every test above wrote the turnover as{' '}
+      <V>g</V> = <V>g</V><Sub>N</Sub>/2 + √(<V>g</V><Sub>N</Sub><Sup>2</Sup>/4 +{' '}
+      <V>g</V><Sub>N</Sub><V>a</V><Sub>0</Sub>) and called it “the simple
+      interpolation, same algebra as MOND’s”. <b style={{ color: INK }}>It was
+        assumed.</b> Here is where it comes from, and it is already in the rules:
+      a neutral point becomes a ± pair, but{' '}
+      <b style={{ color: INK }}>a point that already has a carrier on it is
+        busy</b> — <K>through</K> says an arriving charge annihilates or
+      reverses, and either way that point does not split this tick. So splitting
+      is suppressed exactly where the carrier density is high, which by{' '}
+      <V>g</V> ∝ <V>n</V> is exactly where the field is strong.
+    </Note>
+
+    <Eq open={show} note="occupancy θ = g/a₀, free fraction 1/(1+θ), and it closes">
+      <V>g</V> = <V>g</V><Sub>N</Sub>·(1 + <V>a</V><Sub>0</Sub>/<V>g</V>)
+      <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+      <V>g</V> = <Frac over={<><V>g</V><Sub>N</Sub></>} under={<>2</>} /> + √(
+      <Frac over={<><V>g</V><Sub>N</Sub><Sup>2</Sup></>} under={<>4</>} /> +{' '}
+      <V>g</V><Sub>N</Sub><V>a</V><Sub>0</Sub>)
+    </Eq>
+
+    <Note>
+      <b style={{ color: INK }}>Which is the function, derived.</b> Over six
+      decades <V>g</V>/<V>g</V><Sub>N</Sub> runs 31.7, 10.5, 3.70, 1.62, 1.10,
+      1.010, 1.0010 against a deep limit √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>)
+      of 31.6, 10.0, 3.16 — agreeing where they should and parting where they
+      should. The μ-function stops being borrowed phenomenology.
+    </Note>
+
+    <Note>
+      And it makes <V>a</V><Sub>0</Sub> a <b style={{ color: INK }}>local
+        threshold rather than a clock reading</b>, which is what Test K needed
+      and Test L had to buy with a cosmological cancellation. The blocking is a
+      function of the field at the point and nothing else, so it cannot move with
+      redshift — there is nothing in it that could.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}><V>cH</V><Sub>0</Sub>/2π, isotropic</span>,
+        <>1.10·10<Sup>−10</Sup> — Milky Way <b style={{ color: INK }}>1.1%</b>,
+          worst Genzel boost <b style={{ color: INK }}>1.112</b>.{' '}
+          <b style={{ color: INK }}>All five pass.</b></>],
+      [<span style={{ color: FAINT }}>cone shut at cos θ &gt; 0.5</span>,
+        <>8.38·10<Sup>−11</Sup> — Milky Way 5.2%, worst boost 1.090. Still
+          passes, but the fit is going.</>],
+      [<span style={{ color: BORROWED }}>the <i>measured</i> <V>a</V><Sub>0</Sub></span>,
+        <>1.20·10<Sup>−10</Sup> — Milky Way 1.0%, worst boost{' '}
+          <b style={{ color: INK }}>1.120</b>, which <i>fails</i> by a hair.
+          Worth staring at: the model’s own smaller prediction passes where the
+          measured value does not, so the 9% it is “wrong” by is in the direction
+          the high-<V>z</V> data prefer.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>And then the direction, which is the part nobody
+        had asked.</b> A carrier streaming along <V>ĝ</V> occupies the cell in
+      that direction; the point has <K>WAYS</K> exits and only the occupied ones
+      are shut, so the pair goes out with the field direction <i>removed</i>.
+      That is an anisotropic source, and it costs a projection: ⟨|<V>ĉ</V>·<V>r̂</V>|⟩
+      falls from 0.4721 isotropic to 0.4510 with a narrow cone shut and 0.3610
+      with a wide one.
+    </Note>
+
+    <Note>
+      <b style={{ color: BORROWED }}>Shutting the forward cone reduces the radial
+        projection.</b> The surviving pairs carry <i>less</i> flux outward, not
+      more — so the anisotropy weakens the vacuum channel, and most where the
+      field is strong, which is the same direction the blocking already pushes.
+      The two compound rather than fight, which is why the shape of the
+      interpolation survives both: they are functions of the same occupancy, so
+      they can only move the <i>scale</i>.
+    </Note>
+
+    <Note>
+      And that is the one place it goes the wrong way. The projection multiplies{' '}
+      <V>a</V><Sub>0</Sub> by 0.955 or 0.765, and the measurement wants it 9%{' '}
+      <i>larger</i>. <b style={{ color: INK }}>So the anisotropy widens the gap it
+        was hoped to close.</b> Not fatal — the gap is still under a factor of
+      1.5 in a quantity nothing was fitted to — but it is the opposite of the
+      hoped-for result, and the cone cannot be shut far before the Milky Way fit
+      goes.
+    </Note>
+
+    <Note>
+      So what this buys, precisely:{' '}
+      <b style={{ color: INK }}>the interpolation function, derived from{' '}
+        <K>through</K> rather than borrowed</b>; <V>a</V><Sub>0</Sub> as a local
+      threshold, which settles the high-<V>z</V> discs without the cosmological
+      cancellation — so Test L is no longer load-bearing, though it survives as a
+      consistency check; and a bound on the anisotropy, since the cone cannot be
+      shut past about cos θ = 0.5. What it does <i>not</i> buy is the one link:
+      “the carrier density suppresses the splitting” is <K>through</K> and is
+      already in the file, but “the update cost goes as the accumulated phase”,
+      which is what makes the <i>drift</i> fall with density, is still owed.
     </Note>
 
     <Head>and speed is a budget, not a constant</Head>
@@ -4082,14 +5265,36 @@ export const Law = () => {
           the model’s own setting that is nothing.</>],
       [<span style={{ color: BORROWED }}>probably just wrong</span>,
         <>A neutron star shows about two thirds of its mass — outside any
-          equation of state, and pulsar timing measures those directly. And
-          cosmology comes
-          out empty seven separate ways, every one of them short rather than
-          long.</>],
-      [<span style={{ color: DERIVED }}>and one thing to shoot at</span>,
-        <>The shadow, 4.6% larger than general relativity’s at the same mass.
-          Parameter-free, and inside the reach of an instrument that already
-          exists.</>],
+          equation of state, and pulsar timing measures those directly.</>],
+      [<span style={{ color: DERIVED }}>and one that turned over</span>,
+        <><b style={{ color: INK }}>Dark matter.</b> The <i>force law</i> cannot
+          touch it — Newton, GR and this model agree to a part in a million and
+          all three miss by a factor of 3 at 20 kpc. Nine mechanisms were built
+          and measured against a fully relaxed galaxy; seven are retired in the
+          text with their reasons. What stands is <b style={{ color: INK }}>the
+            transport route</b>: the carrier’s drift goes as the density it is
+          passing through, flux conservation turns quadratic, and <i>both</i> the
+          1/<V>r</V> law and the √<V>M</V> come out of one mechanism. Its
+          crossover is <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π —{' '}
+          <b style={{ color: INK }}>computed from the frontier cosmology, not
+            fitted</b> — which lands 9% from the measured{' '}
+          <V>a</V><Sub>0</Sub> and fits the Milky Way’s curve to{' '}
+          <b style={{ color: INK }}>1.1%</b>. Because the mean spacing shrinks by
+          exactly the factor the clock speeds up by, that <V>a</V><Sub>0</Sub> is
+          constant in redshift, and Genzel’s <V>z</V> ≈ 2 discs pass. It owes one
+          link — that a carrier’s update cost goes as its accumulated phase.</>],
+      [<span style={{ color: DERIVED }}>and four things to shoot at</span>,
+        <>The shadow, <b style={{ color: INK }}>4.6% larger</b> than general
+          relativity’s at the same mass — parameter-free, and inside the reach
+          of an instrument that already exists. The age,{' '}
+          <b style={{ color: INK }}>forced to 1/<V>H</V><Sub>0</Sub></b> with no
+          freedom to miss, which the Hubble tension brackets.{' '}
+          <b style={{ color: INK }}><V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π</b>,
+          computed rather than fitted, 9% from the measured value. And the one
+          that dates it: <b style={{ color: INK }}><V>a</V><Sub>0</Sub> ∝ 1/<V>t</V></b>,
+          so rotation curves at <V>z</V> = 2 should flatten at three times
+          today’s acceleration — which MOND has no way to say and which the
+          measurements can already refuse.</>],
     ]} />
 
     <Head>and the record of a road not taken</Head>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
index 2eb5e64..d38f266 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
@@ -11,12 +11,30 @@
  * baryons — every other term it owns is checked and negligible:
  *
  *     the pull    GRAVITY·m_a·m_b/R²      G_LATTICE·l_P³/(MU·t_P²) = G exactly
- *     `reach`     Yukawa, λ = 1.6 Gpc     a deficit of 2·10⁻³ % at 30 kpc
- *     `carry`     1 + 2v²/c²              1.1·10⁻⁶ at 220 km/s
+ *     `reach`     Yukawa, λ = 1.55 Gpc    −1.9·10⁻¹⁰ on the pull at 30 kpc
+ *     `carry`     1 + 2v²/c²              +2.4·10⁻⁷ at 30 kpc
  *     `shows`     self-screening          nothing; a galaxy is transparent
  *
- * and the gap to close at 20 kpc is +195%. Between five and eight orders too
- * small, with no dial in the model that reaches.
+ * (`reach` is worth being exact about, because the potential and the force do
+ * not fall off together. e^{−x}/R is 1.9·10⁻⁵ down at 30 kpc, but the FORCE it
+ * differentiates to is e^{−x}(1+x)/R², whose deficit is x²/2 — five orders
+ * smaller again. It is the force a galaxy turns on, so it is the force quoted.)
+ *
+ * AND SO THE THREE ANSWERS, which is the whole panel:
+ *
+ *     r (kpc)    Newton    GR        this model   measured   missing
+ *     5          192.4     +4.1e−7   +8.2e−7      234.3      +48%
+ *     8          185.7     +3.8e−7   +7.7e−7      229.2      +52%
+ *     20         128.0     +1.8e−7   +3.7e−7      208.8      +166%
+ *     30         103.7     +1.2e−7   +2.4e−7      191.8      +242%
+ *
+ * (km/s; GR and the model as FRACTIONS of Newton's pull, since neither is
+ * distinguishable from it at this width — the last column is the fractional
+ * shortfall in the pull, which is the square of the shortfall in the speed.)
+ *
+ * The three theories agree to a part in a million. The data is out by a factor
+ * of three. Whatever is wrong here, it is not something a 10⁻⁶ correction was
+ * ever going to reach — and this model has no dial that is bigger.
  *
  * AND THE ANSWER TO "DOES THE OUTSIDE CANCEL". It does not, and it is worth
  * being exact about the sign because the intuition runs the other way:
@@ -40,7 +58,9 @@
 import { CanvasView, Surface } from "./canvas";
 
 const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19;
+const C = 2.99792458e8;
 const A0 = 1.2e-10;                                     // the MOND scale, for reference
+const GPC = 3.0857e25, LAM = 1.55 * GPC;                // `reach`, in metres
 
 /** the Milky Way's baryons, as measured rather than as fitted */
 const DISK = { M: 5.0e10 * MSUN, Rd: 2.6 * KPC, h: 0.30 * KPC };
@@ -79,21 +99,69 @@ const discPull = (d: Disc, r: number, NR = 420, NP = 480) => {
 const bulgePull = (r: number) =>
   G * BULGE.M * (r * r) / Math.pow(r + BULGE.a, 2) / (r * r);
 
+/**
+ * WHAT IS MEASURED. Eilers et al. 2019 — Gaia DR2 crossed with APOGEE, 23,000
+ * red giants, the Milky Way's circular speed from 5 to 25 kpc. It is a
+ * DECLINING curve, not a flat one: 229.0 km/s at the Sun's 8.122 kpc, falling
+ * at 1.7 km/s per kpc. Written as their fit rather than as invented points,
+ * because that is what it is, and the fit is the published result.
+ */
+const MEASURED = (rkpc: number) => 229.0 - 1.7 * (rkpc - 8.122);
+const MEASURED_FROM = 5, MEASURED_TO = 25;              // where they looked
+
+/**
+ * THE TRANSPORT ROUTE, WHICH IS THIS MODEL'S OWN — and the reason the constant
+ * below is `A0_MODEL` rather than the measured `A0`.
+ *
+ * The carrier's drift falls with the density it is passing through, so flux
+ * conservation `Φ = 4πr²·n·v` goes QUADRATIC in n and the profile turns over
+ * from 1/r² to 1/r. Same algebra as MOND's simple interpolation, arrived at
+ * from transport rather than assumed — see `caught` and the dark-matter section
+ * in `gravity.ts`.
+ *
+ * The crossover is where the galaxy's own field falls to the scale the
+ * EXPANSION already sets. The frontier cosmology forces `H₀ = 1/t₀` exactly, so
+ *
+ *     a₀ = c·H₀/2π = 1.096e−10 m/s²      against a measured 1.200e−10
+ *
+ * — 9% out, and NOTHING IN IT IS FITTED. That is the value drawn.
+ */
+const A0_MODEL = C * (70.9e3 / 3.0856775814913673e22) / (2 * Math.PI);
+const mond = (g: number) => g / 2 + Math.sqrt(g * g / 4 + g * A0_MODEL);
+
 export type Point = {
   r: number;          // metres
   disc: number; gas: number; bulge: number;
   inside: number; outside: number; total: number;
+
+  /** fractional excesses over Newton's pull — all three of them tiny */
+  gr: number;         // general relativity, the 1PN term: order v²/c²
+  carry: number;      // this model's `carry`: 2v²/c²
+  reach: number;      // this model's `reach`: negative, a Yukawa on the force
 };
 
 /** everything, at one radius */
 export const pullAt = (r: number): Point => {
   const a = discPull(DISK, r), b = discPull(GAS, r), c = bulgePull(r);
+  const total = a.inside + a.outside + b.inside + b.outside + c;
+
+  // v²/c² at this radius, which is the size of every relativistic term here.
+  // GR's coefficient is O(1) and depends on which speed you say you measured —
+  // the coordinate one, the locally measured one, the one a Doppler shift
+  // reports. The SIZE is the content; the coefficient is a rounding error on
+  // a discrepancy of 242%, so it is written as 1 and said out loud.
+  const vv = total * r / (C * C);
+  const x = r / LAM;
+
   return {
     r,
     disc: a.inside + a.outside, gas: b.inside + b.outside, bulge: c,
     inside: a.inside + b.inside + c,
     outside: a.outside + b.outside,
-    total: a.inside + a.outside + b.inside + b.outside + c,
+    total,
+    gr: vv,
+    carry: 2 * vv,
+    reach: Math.exp(-x) * (1 + x) - 1,
   };
 };
 
@@ -106,13 +174,84 @@ const CURVE: Point[] = (() => {
   return out;
 })();
 
-const OBSERVED = 220;                                   // km/s, flat, 5…25 kpc
+// ---------------------------------------------------------------------------
+// AND THE CAUGHT-PAIR LAW, which is the same sum with the force falling as 1/d.
+//
+// See `caught` in `gravity.ts`. A vacuum pair with one charge taken by each
+// body links them at a rate going as ∫d³P/(r_A²r_B²) = π³/R, so the force is
+// 1/R where Newton's is 1/R². The whole content here is what that does to a
+// DISC, which is not something the point-mass argument settles.
+
+/** the same ring sum, with the force falling as 1/d^p instead of 1/d² */
+const discPullP = (d: Disc, r: number, p: number, NR = 420, NP = 480) => {
+  const RMAX = 12 * d.Rd;
+  let acc = 0;
+  for (let i = 0; i < NR; i++) {
+    const R = RMAX * (i + 0.5) / NR, dR = RMAX / NR;
+    const s = sigma(d, R) * R * dR;
+    let a = 0;
+    for (let j = 0; j < NP; j++) {
+      const ph = 2 * Math.PI * (j + 0.5) / NP;
+      const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+      const d2 = dx * dx + dy * dy + d.h * d.h;
+      a += dx / Math.pow(d2, (p + 1) / 2);            // the unit vector, times 1/d^p
+    }
+    acc += -s * a * (2 * Math.PI / NP);
+  }
+  return acc;
+};
+
+/**
+ * The caught-pair pull, in arbitrary units — there is one free coupling κ and
+ * it is fixed below by matching the measured speed at the Sun. That is the
+ * "one overall scale" the prose admits to, and it is the only thing fitted.
+ *
+ * IT ADDS TO NEWTON RATHER THAN REPLACING IT, which is what the mechanism
+ * actually says: the direct meeting of A's charges with B's is still there and
+ * still 1/R², and the vacuum-mediated term is a second channel on top. Written
+ * as a replacement it fails in the inner galaxy for the obvious reason — 1/R is
+ * too weak where Newton needs to be strong — and no interpolation function is
+ * needed once it is written as the sum it is.
+ *
+ * The bulge is taken as its enclosed mass over r rather than summed: with a
+ * 1/d force there is no shell theorem, but the bulge is compact and nearly
+ * spherical and it is inside 2 kpc, where nothing being argued about happens.
+ */
+const caughtRaw = (r: number) =>
+  discPullP(DISK, r, 1) + discPullP(GAS, r, 1) +
+  BULGE.M * r / Math.pow(r + BULGE.a, 2);
+
+/**
+ * Newton plus the caught pair, with κ fitted at the Sun and nowhere else.
+ * Against the Gaia curve it runs 0.981, 1.000, 0.996, 0.985, 0.964, 0.955,
+ * 0.959, 0.974 at 6, 8, 10, 12, 16, 20, 25, 30 kpc — inside 4.5% across the
+ * whole range the data covers, on one constant. Below 5 kpc it falls away, and
+ * below 5 kpc there is no data either: the fit is not defined there.
+ */
+const CAUGHT: { r: number; v: number }[] = (() => {
+  const R0 = 8.122 * KPC, at0 = pullAt(R0);
+  const kappa =
+    (Math.pow(MEASURED(8.122) * 1e3, 2) - at0.total * R0) / (caughtRaw(R0) * R0);
+
+  return CURVE.map(p => ({
+    r: p.r,
+    v: Math.sqrt(Math.max(0, (p.total + kappa * caughtRaw(p.r)) * p.r)),
+  }));
+})();
 
 // ---------------------------------------------------------------------------
 
 const INK = "#c8cbd4", FAINT = "#5a5f6e", GRID = "rgba(255,255,255,0.055)";
 const MODEL = "#4aa8eb", DATA = "#eb964a", FLOOR = "#8bd48b";
 const PALE = "#6f7ba8", GASC = "#59806a", BULGEC = "#8a6f8f";
+const RELAT = "#9aa0b4";                                // grey, kept for `split`
+
+// WHAT IS MEASURED IS WHITE, EVERYWHERE. It is the one line on any of these
+// panels that is not a theory, so it gets the one colour that is not a choice —
+// and general relativity takes the orange it used to have. The measured curve
+// is then drawn UNDER both theories in the disc panel, in the same white, so
+// each is read against the same thing rather than against the panel beside it.
+const SEEN = "#eef0f5", GHOST = "rgba(238,240,245,0.40)";
 
 const frame = (s: Surface, pad = 46) => {
   const { ctx, width, height } = s;
@@ -120,8 +259,11 @@ const frame = (s: Surface, pad = 46) => {
   ctx.fillStyle = "#08090d";
   ctx.fillRect(0, 0, width, height);
   return {
-    x0: pad, x1: width - 14, y0: 12, y1: height - 26,
-    w: width - 14 - pad, h: height - 38,
+    // The bottom pad carries two lines — the tick labels and the axis caption
+    // — so it is deep enough for both. It was not, and they sat on top of one
+    // another, which is the sort of thing only looking at it tells you.
+    x0: pad, x1: width - 14, y0: 12, y1: height - 36,
+    w: width - 14 - pad, h: height - 48,
   };
 };
 
@@ -172,47 +314,125 @@ const tag = (s: Surface, x: number, y: number, text: string, css: string) => {
   ctx.fillText(text, x, y);
 };
 
+/** the x-axis caption, kept off the ticks it used to sit on top of */
+const under = (s: Surface, box: ReturnType<typeof frame>, text: string) => {
+  s.ctx.fillStyle = FAINT;
+  s.ctx.font = "400 10px ui-monospace, Menlo, monospace";
+  s.ctx.textAlign = "center";
+  s.ctx.fillText(text, (box.x0 + box.x1) / 2, s.height - 5);
+  s.ctx.textAlign = "left";
+};
+
 /**
- * THE ROTATION CURVE. What the model says, what each component of the baryons
- * contributes, what is measured, and — for scale rather than as a claim — what
- * a floor at a₀ would give.
+ * THE ROTATION CURVE, with all three answers on it: what Newton says, what GR
+ * says, what this model says, and what Gaia measured. The first three are one
+ * line, because they agree to a part in a million — which is the panel's
+ * point, and why the next one exists to show that they really do differ.
  */
 const curve = (s: Surface) => {
   const box = frame(s);
-  const XMAX = 30, YMAX = 260;
+  const XMAX = 30, YMAX = 280;                          // headroom for the unit
   const { X, Y } = axes(s, box, XMAX, 0, YMAX,
     [5, 10, 15, 20, 25, 30], [50, 100, 150, 200, 250], v => String(v));
 
-  // the measured flat disc, 5…25 kpc
-  s.ctx.fillStyle = "rgba(235,150,74,0.10)";
-  s.ctx.fillRect(X(5), Y(OBSERVED + 12), X(25) - X(5), Y(OBSERVED - 12) - Y(OBSERVED + 12));
-  path(s, CURVE.filter(p => p.r / KPC >= 3), X, Y, () => OBSERVED, DATA, 2);
+  // what was measured, over the radii it was measured at — and dotted where it
+  // is being read outside them, since that is extrapolation and not data
+  const inside = CURVE.filter(p => p.r / KPC >= MEASURED_FROM && p.r / KPC <= MEASURED_TO);
+  s.ctx.fillStyle = "rgba(238,240,245,0.09)";
+  s.ctx.beginPath();
+  inside.forEach((p, i) => {
+    const v = MEASURED(p.r / KPC);
+    const x = X(p.r / KPC);
+    if (i === 0) s.ctx.moveTo(x, Y(v * 1.025)); else s.ctx.lineTo(x, Y(v * 1.025));
+  });
+  for (let i = inside.length - 1; i >= 0; i--) {
+    const p = inside[i];
+    s.ctx.lineTo(X(p.r / KPC), Y(MEASURED(p.r / KPC) * 0.975));
+  }
+  s.ctx.closePath(); s.ctx.fill();
 
-  path(s, CURVE, X, Y, p => Math.sqrt(A0 * p.total * p.r) / 1e3, FLOOR, 1.3, [4, 3]);
+  path(s, CURVE.filter(p => p.r / KPC <= MEASURED_FROM), X, Y,
+    p => MEASURED(p.r / KPC), SEEN, 1.4, [3, 3]);
+  path(s, CURVE.filter(p => p.r / KPC >= MEASURED_TO), X, Y,
+    p => MEASURED(p.r / KPC), SEEN, 1.4, [3, 3]);
+  path(s, inside, X, Y, p => MEASURED(p.r / KPC), SEEN, 2.2);
+
+  path(s, CURVE, X, Y, p => kms(mond(p.total), p.r), FLOOR, 1.3, [5, 4]);
 
   path(s, CURVE, X, Y, p => kms(p.disc, p.r), PALE, 1.1);
   path(s, CURVE, X, Y, p => kms(p.gas, p.r), GASC, 1.1);
   path(s, CURVE, X, Y, p => kms(p.bulge, p.r), BULGEC, 1.1);
   path(s, CURVE, X, Y, p => kms(p.total, p.r), MODEL, 2.4);
 
-  // placed against the computed values so nothing sits on a line it does not
-  // belong to: disc peaks 173 near 6, gas 52 at 21, bulge 102 at 2.6, model
-  // 168 at 11.5, floor 187 at 21, and the measured band spans 208…232.
-  tag(s, X(13.4), Y(243), "measured — flat at 220 km/s", DATA);
-  tag(s, X(21.4), Y(172), "a floor at a₀", FLOOR);
-  tag(s, X(11.4), Y(190), "THE MODEL — Newton on the baryons", MODEL);
-  tag(s, X(5.8), Y(152), "stars", PALE);
-  tag(s, X(21.0), Y(40), "gas", GASC);
-  tag(s, X(2.6), Y(88), "bulge", BULGEC);
-
+  // Placed against the computed values, so nothing sits on a line it does not
+  // belong to. Newton peaks 192.8 at 5.5 and is 103.7 at 30; MOND peaks 231.6
+  // at 7.6 and is 200.9 at 30; measured runs 239 at 1 kpc to 191.8 at 30;
+  // stars peak 172.5 at 6, gas 53.1 at 15, bulge 111 at 2.
+  tag(s, X(1.2), Y(272), "measured — Gaia DR2 × APOGEE", SEEN);
+  tag(s, X(13.6), Y(252), "THE TRANSPORT ROUTE — a₀ = cH₀/2π, computed not fitted", FLOOR);
+  tag(s, X(11.0), Y(178), "NEWTON = GR = THE FORCE LAW ALONE", MODEL);
+  tag(s, X(21.6), Y(97), "stars", PALE);
+  tag(s, X(24.6), Y(38), "gas", GASC);
+  tag(s, X(3.3), Y(70), "bulge", BULGEC);
+
+  under(s, box, "radius (kpc)");
   s.ctx.fillStyle = FAINT;
   s.ctx.font = "400 10px ui-monospace, Menlo, monospace";
-  s.ctx.textAlign = "center";
-  s.ctx.fillText("radius (kpc)", (box.x0 + box.x1) / 2, s.height - 4);
-  s.ctx.textAlign = "left";
   s.ctx.fillText("km/s", 6, 20);
 };
 
+/**
+ * AND HOW FAR APART THE THREE OF THEM REALLY ARE — on a log axis, because a
+ * linear one cannot show a difference of ten orders and a difference of a
+ * factor of three on the same picture.
+ *
+ * Everything is a fraction of Newton's pull. The top line is what is missing.
+ * The two in the middle are everything general relativity adds to Newton and
+ * everything this model adds to Newton, and they are the same size because
+ * this model has β = γ = 1 and reproduces the same 1PN term. The bottom line
+ * is `reach`, which is the only genuinely NEW thing in this model's force law
+ * — and it is thirteen orders below the problem.
+ */
+const apart = (s: Surface) => {
+  const box = frame(s, 54);
+  const XMAX = 30, LO = -13, HI = 1;                      // decades
+  const { ctx } = s;
+
+  const X = (r: number) => box.x0 + box.w * r / XMAX;
+  const Y = (v: number) =>
+    box.y1 - box.h * (Math.log10(Math.max(Math.abs(v), 1e-30)) - LO) / (HI - LO);
+
+  ctx.font = "400 10px ui-monospace, Menlo, monospace";
+  ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+  for (let d = LO; d <= HI; d += 2) {
+    const y = Y(Math.pow(10, d));
+    ctx.beginPath(); ctx.moveTo(box.x0, y); ctx.lineTo(box.x1, y); ctx.stroke();
+    ctx.fillStyle = FAINT; ctx.textAlign = "right";
+    ctx.fillText(d === 0 ? "1" : `1e${d}`, box.x0 - 6, y + 3);
+  }
+  for (const t of [5, 10, 15, 20, 25, 30]) {
+    ctx.beginPath(); ctx.moveTo(X(t), box.y0); ctx.lineTo(X(t), box.y1); ctx.stroke();
+    ctx.fillStyle = FAINT; ctx.textAlign = "center";
+    ctx.fillText(String(t), X(t), box.y1 + 15);
+  }
+  ctx.textAlign = "left";
+
+  path(s, CURVE, X, Y, p => Math.pow(MEASURED(p.r / KPC) * 1e3, 2) / (p.total * p.r) - 1,
+    SEEN, 2.4);
+  path(s, CURVE, X, Y, p => p.gr, DATA, 2.2);
+  path(s, CURVE, X, Y, p => p.carry, MODEL, 2.2, [5, 3]);
+  path(s, CURVE, X, Y, p => p.reach, MODEL, 1.4, [2, 3]);
+
+  // observed runs 0.48…2.42, GR 4.1e−7 down to 1.2e−7, `carry` twice that,
+  // `reach` 5e−12 at 5 kpc to 1.9e−10 at 30 — so these do not collide
+  tag(s, X(11), Y(6.0), "WHAT IS MISSING", SEEN);
+  tag(s, X(1.2), Y(4.0e-6), "this model, `carry` — 2v²/c²", MODEL);
+  tag(s, X(14.6), Y(2.2e-8), "general relativity beyond Newton — order v²/c²", DATA);
+  tag(s, X(12.4), Y(4.0e-12), "this model, `reach` — and it SUBTRACTS", MODEL);
+
+  under(s, box, "radius (kpc)");
+};
+
 /**
  * AND THE SPLIT, which is the thing actually being asked. Inward from the mass
  * inside the orbit, outward from the mass beyond it, and the net.
@@ -234,15 +454,188 @@ const split = (s: Surface) => {
 
   tag(s, X(16.4), Y(1.09), "pull from inside r  (set to 1)", PALE);
   tag(s, X(15), Y(0.80), "net", MODEL);
-  tag(s, X(13), Y(-0.16), "pull from OUTSIDE r — outward, so it subtracts", DATA);
+  tag(s, X(11.5), Y(-0.21), "pull from OUTSIDE r — outward, so it subtracts", DATA);
 
-  s.ctx.fillStyle = FAINT;
-  s.ctx.font = "400 10px ui-monospace, Menlo, monospace";
-  s.ctx.textAlign = "center";
-  s.ctx.fillText("radius (kpc)", (box.x0 + box.x1) / 2, s.height - 4);
-  s.ctx.textAlign = "left";
+  under(s, box, "radius (kpc)");
 };
 
+// ---------------------------------------------------------------------------
+// THE DISC, TURNING — three of them, side by side, under three different laws.
+//
+// A rotation curve is a graph and a graph hides what it means. What a rotation
+// curve IS, is how fast the thing actually goes round, and the difference
+// between these three theories is a difference you can watch: a spoke of stars
+// laid down along one radius shears into a spiral at a rate set entirely by
+// dΩ/dr, and the three laws shear it differently within one turn of the Sun.
+//
+// THIS IS KINEMATIC AND SAYS SO. Every star is put on the circular orbit its
+// law gives at its radius and moved at that speed. It is not an N-body run and
+// nothing here is self-consistent: no spiral structure forms, nothing responds
+// to anything. The speeds are real — summed from the same baryons by the same
+// code as the panels above — and the winding is what those speeds imply.
+
+const GYR = 3.1557e16;
+
+/** v at any radius, interpolated from a table computed on the half-kpc grid */
+const speeder = (table: { r: number; v: number }[]) => (r: number) => {
+  const x = r / (0.5 * KPC) - 1;
+  if (x <= 0) return table[0].v * (r / table[0].r);       // solid body inside
+  const i = Math.min(table.length - 2, Math.floor(x));
+  const f = x - i;
+  return table[i].v * (1 - f) + table[i + 1].v * f;
+};
+
+const LAWS = [
+  {
+    name: "GENERAL RELATIVITY",
+    under: "= Newton on the baryons, to a part in 10⁶",
+    css: DATA,
+    v: speeder(CURVE.map(p => ({ r: p.r, v: kms(p.total, p.r) * 1e3 }))),
+  },
+  {
+    name: "MEASURED",
+    under: "Gaia DR2 × APOGEE",
+    css: SEEN,
+    v: speeder(CURVE.map(p => ({ r: p.r, v: MEASURED(p.r / KPC) * 1e3 }))),
+  },
+  {
+    name: "THE CAUGHT PAIR",
+    under: "the 1/R law, one scale fitted",
+    css: MODEL,
+    v: speeder(CAUGHT),
+  },
+];
+
+const R_VIEW = 15 * KPC;                                  // as far as the data goes
+
+/**
+ * The background disc — sampled from the real surface density, so it is
+ * centrally concentrated the way a galaxy is. It carries no information; it is
+ * there so that the thing being sheared looks like a galaxy.
+ */
+const STARS = (() => {
+  const out: { r: number; th: number }[] = [];
+  let seed = 20260812;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+
+  const invert = (Rd: number) => {                        // M(<x) = 1 − e^{−x}(1+x)
+    const u = rnd(); let lo = 0, hi = 14;
+    for (let i = 0; i < 40; i++) {
+      const m = (lo + hi) / 2;
+      if (1 - Math.exp(-m) * (1 + m) < u) lo = m; else hi = m;
+    }
+    return (lo + hi) / 2 * Rd;
+  };
+
+  for (let i = 0; i < 2600; i++) {
+    const r = invert(rnd() < 0.19 ? GAS.Rd : DISK.Rd);
+    if (r > R_VIEW) continue;
+    out.push({ r, th: rnd() * 2 * Math.PI });
+  }
+  for (let i = 0; i < 300; i++)
+    out.push({ r: BULGE.a * Math.sqrt(rnd()) * 2.0, th: rnd() * 2 * Math.PI });
+
+  return out;
+})();
+
+/**
+ * And the tracers, which carry all of it. Four spokes, EVENLY SPACED IN RADIUS
+ * rather than drawn from the density — because the question is what happens
+ * between 2 and 15 kpc, and a mass-weighted sample puts almost nothing there.
+ * Each spoke starts as a straight radial line and is sheared by dΩ/dr alone.
+ */
+const TRACERS = (() => {
+  const out: { r: number; th: number }[] = [];
+  for (let s = 0; s < 4; s++)
+    for (let i = 0; i <= 28; i++)
+      out.push({ r: (5 + (10 * i) / 28) * KPC, th: s * Math.PI / 2 });
+  return out;
+})();
+
+const discs = (() => {
+  let t = 0;                                              // seconds, simulated
+
+  return (s: Surface, dt: number) => {
+    const { ctx, width, height } = s;
+
+    t += dt * 0.12 * GYR;
+    if (t > 0.5 * GYR) t = 0;
+
+    ctx.clearRect(0, 0, width, height);
+    ctx.fillStyle = "#08090d";
+    ctx.fillRect(0, 0, width, height);
+
+    const gap = 10, w = (width - gap * 2) / 3;
+    const top = 32, side = Math.min(w, height - top - 22);
+
+    LAWS.forEach((law, n) => {
+      const x0 = n * (w + gap);
+      const cx = x0 + w / 2, cy = top + side / 2;
+      const k = side * 0.48 / R_VIEW;
+
+      ctx.fillStyle = law.css;
+      ctx.font = "600 10px ui-sans-serif, system-ui, sans-serif";
+      ctx.fillText(law.name, x0 + 2, 12);
+      ctx.fillStyle = FAINT;
+      ctx.font = "400 9.5px ui-monospace, Menlo, monospace";
+      ctx.fillText(law.under, x0 + 2, 24);
+
+      // the Sun's orbit, so all three carry one shared ruler
+      ctx.strokeStyle = "rgba(255,255,255,0.11)";
+      ctx.lineWidth = 1;
+      ctx.beginPath();
+      ctx.arc(cx, cy, 8.122 * KPC * k, 0, 2 * Math.PI);
+      ctx.stroke();
+
+      ctx.fillStyle = "rgba(190,195,208,0.20)";
+      for (const st of STARS) {
+        const th = st.th + law.v(st.r) / st.r * t;
+        ctx.fillRect(cx + Math.cos(th) * st.r * k - 0.7,
+          cy + Math.sin(th) * st.r * k - 0.7, 1.4, 1.4);
+      }
+
+      // The spokes, drawn as curves so the winding reads as a shape — and in
+      // EVERY panel the measured spoke is drawn underneath as a ghost, because
+      // three pictures side by side cannot be compared and two curves in one
+      // picture can. Where the bright curve leaves the ghost is the error.
+      const spokes = (of: (r: number) => number, css: string, wide: number,
+        dash: number[]) => {
+        ctx.strokeStyle = css; ctx.lineWidth = wide; ctx.setLineDash(dash);
+        for (let s = 0; s < 4; s++) {
+          ctx.beginPath();
+          for (let i = 0; i <= 28; i++) {
+            const tr = TRACERS[s * 29 + i];
+            const th = tr.th + of(tr.r) / tr.r * t;
+            const x = cx + Math.cos(th) * tr.r * k, y = cy + Math.sin(th) * tr.r * k;
+            if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
+          }
+          ctx.stroke();
+        }
+        ctx.setLineDash([]);
+      };
+
+      if (n !== 1) spokes(LAWS[1].v, GHOST, 1.3, [3, 3]);
+      spokes(law.v, law.css, 1.7, []);
+
+      ctx.fillStyle = law.css;
+      for (const tr of TRACERS) {
+        const th = tr.th + law.v(tr.r) / tr.r * t;
+        ctx.fillRect(cx + Math.cos(th) * tr.r * k - 1.1,
+          cy + Math.sin(th) * tr.r * k - 1.1, 2.2, 2.2);
+      }
+    });
+
+    ctx.fillStyle = FAINT;
+    ctx.font = "400 10px ui-monospace, Menlo, monospace";
+    ctx.fillText(`${(t / GYR).toFixed(2)} Gyr — the Sun goes round once in 0.22`,
+      2, height - 6);
+    ctx.textAlign = "right";
+    ctx.fillText("kinematic: each star on the circular orbit its own law gives, 5–15 kpc",
+      width - 2, height - 6);
+    ctx.textAlign = "left";
+  };
+})();
+
 const Panel = (
   { paint, height, note }: { paint: (s: Surface) => void; height: number; note: string },
 ) => <div style={{ marginBottom: "1.1rem" }}>
@@ -261,7 +654,288 @@ export const Rotation = ({ height = 340 }: { height?: number }) =>
   <Panel paint={curve} height={height}
     note="the Milky Way, summed directly over its baryons — no shell theorem" />;
 
+/** the same three, turning — because a curve hides what the curve means */
+export const Discs = ({ height = 300 }: { height?: number }) =>
+  <div style={{ marginBottom: "1.1rem" }}>
+    <div style={{
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+      color: FAINT, marginBottom: 6,
+    }}>four spokes of stars, sheared by three laws — dashed is the measured one, drawn in every panel</div>
+    <div style={{ height, background: "#08090d" }}>
+      <CanvasView deps={["discs"]} paint={() => ({ frame: discs })} />
+    </div>
+  </div>;
+
+/** and the three theories against each other, where they can be told apart */
+export const Apart = ({ height = 300 }: { height?: number }) =>
+  <Panel paint={apart} height={height}
+    note="everything Newton, GR and this model add, as a fraction of Newton's pull" />;
+
 /** and where the pull comes from, inside the orbit and beyond it */
 export const Split = ({ height = 260 }: { height?: number }) =>
   <Panel paint={split} height={height}
     note="does the mass outside cancel? — as a fraction of the pull from inside" />;
+
+// ---------------------------------------------------------------------------
+// THE HIGH-REDSHIFT DISCS, WHICH ARE WHERE THE MODEL'S OWN PREDICTION DIES.
+//
+// `a₀ = c/(2πt)` makes the acceleration scale a clock reading, so at z ≈ 2 it
+// is three times today's and MORE of a galaxy should be boosted. Genzel et al.
+// (2017) measure six massive discs at z = 0.85–2.24 and find the opposite:
+// declining outer curves, baryon-dominated, f_DM(<Re) under 0.2.
+//
+// Drawn because a table of five numbers hides which way the disagreement runs,
+// and because this is the prediction that distinguishes the model from the
+// phenomenology it otherwise reproduces.
+
+type HighZ = { name: string; z: number; logMs: number; fgas: number; Re: number };
+
+/** Genzel et al. 2017, Nature 543, 397 — Table 1, approximately */
+const DISCS: HighZ[] = [
+  { name: "COS4_01351", z: 0.854, logMs: 11.07, fgas: 0.35, Re: 8.2 },
+  { name: "D3a_6397", z: 1.500, logMs: 11.07, fgas: 0.45, Re: 7.4 },
+  { name: "GS4_43501", z: 1.613, logMs: 10.71, fgas: 0.50, Re: 4.9 },
+  { name: "zC_406690", z: 2.196, logMs: 10.62, fgas: 0.55, Re: 5.5 },
+  { name: "zC_400569", z: 2.242, logMs: 11.07, fgas: 0.45, Re: 3.3 },
+];
+
+const H0_SI = 70.9e3 / 3.0856775814913673e22;
+const A0_FIXED = C * H0_SI / (2 * Math.PI);
+const a0At = (z: number) => A0_FIXED * (1 + z);        // coasting: 1+z = t₀/t
+
+/** the boost over the purely baryonic speed, inside one effective radius */
+const boostAt = (d: HighZ, a0: number) => {
+  const M = Math.pow(10, d.logMs) * MSUN / (1 - d.fgas);
+  const gN = G * M / Math.pow(d.Re * KPC, 2);
+  return Math.sqrt((gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0)) / gN);
+};
+
+/** what Genzel's f_DM < 0.2 allows, as a boost factor */
+const ALLOWED = 1.12;
+
+const highz = (s: Surface) => {
+  const box = frame(s, 58);
+  const { ctx } = s;
+  const X = (z: number) => box.x0 + box.w * (z - 0.6) / 1.9;
+  const Y = (b: number) => box.y1 - box.h * (b - 1.0) / 0.62;
+
+  ctx.font = "400 10px ui-monospace, Menlo, monospace";
+  ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+  for (const t of [1.0, 1.1, 1.2, 1.3, 1.4, 1.5]) {
+    ctx.beginPath(); ctx.moveTo(box.x0, Y(t)); ctx.lineTo(box.x1, Y(t)); ctx.stroke();
+    ctx.fillStyle = FAINT; ctx.textAlign = "right";
+    ctx.fillText(t.toFixed(2), box.x0 - 6, Y(t) + 3);
+  }
+  for (const t of [1.0, 1.5, 2.0, 2.5]) {
+    ctx.beginPath(); ctx.moveTo(X(t), box.y0); ctx.lineTo(X(t), box.y1); ctx.stroke();
+    ctx.fillStyle = FAINT; ctx.textAlign = "center";
+    ctx.fillText(t.toFixed(1), X(t), box.y1 + 15);
+  }
+  ctx.textAlign = "left";
+
+  // what the measurement allows — everything above this line is excluded
+  ctx.fillStyle = "rgba(235,90,90,0.10)";
+  ctx.fillRect(box.x0, box.y0, box.w, Y(ALLOWED) - box.y0);
+  ctx.strokeStyle = SEEN; ctx.lineWidth = 1.6; ctx.setLineDash([5, 4]);
+  ctx.beginPath(); ctx.moveTo(box.x0, Y(ALLOWED)); ctx.lineTo(box.x1, Y(ALLOWED)); ctx.stroke();
+  ctx.setLineDash([]);
+
+  // and the five galaxies, under each reading
+  for (const d of DISCS) {
+    const bf = boostAt(d, A0_FIXED), bm = boostAt(d, a0At(d.z));
+    ctx.strokeStyle = "rgba(255,255,255,0.16)"; ctx.lineWidth = 1;
+    ctx.beginPath(); ctx.moveTo(X(d.z), Y(bf)); ctx.lineTo(X(d.z), Y(bm)); ctx.stroke();
+
+    ctx.fillStyle = DATA;
+    ctx.beginPath(); ctx.arc(X(d.z), Y(bf), 3.1, 0, 2 * Math.PI); ctx.fill();
+    ctx.fillStyle = MODEL;
+    ctx.beginPath(); ctx.arc(X(d.z), Y(bm), 3.6, 0, 2 * Math.PI); ctx.fill();
+
+    ctx.fillStyle = FAINT;
+    ctx.font = "400 8.5px ui-monospace, Menlo, monospace";
+    ctx.save();
+    ctx.translate(X(d.z) + 6, Y(bm) - 6); ctx.rotate(-Math.PI / 4);
+    ctx.fillText(d.name, 0, 0);
+    ctx.restore();
+  }
+
+  tag(s, X(0.66), Y(1.44), "EXCLUDED — Genzel measures f_DM(<Re) < 0.2, i.e. under 1.12", SEEN);
+  tag(s, X(0.66), Y(1.325), "a₀ = cH₀/2π·(1+z) — THIS MODEL", MODEL);
+  tag(s, X(0.66), Y(1.265), "a₀ fixed — ordinary MOND", DATA);
+
+  under(s, box, "redshift");
+  ctx.fillStyle = FAINT;
+  ctx.font = "400 10px ui-monospace, Menlo, monospace";
+  ctx.fillText("v / v_baryons, inside one effective radius", 6, 20);
+};
+
+/** the prediction that dates the model, against the measurement that refuses it */
+export const HighRedshift = ({ height = 320 }: { height?: number }) =>
+  <Panel paint={highz} height={height}
+    note="six massive discs at z ≈ 1–2 — where a₀ ∝ 1/t is refused" />;
+
+// ---------------------------------------------------------------------------
+// AND THE SAME PICTURE AT z ≈ 2, WHICH IS WHERE THE READINGS COME APART.
+//
+// A disc like Genzel's GS4_43501 — 1.0e11 M☉ of baryons inside 4.9 kpc, so a
+// compact, dense, fast thing — sheared under the three readings of a₀. What is
+// measured there is a DECLINING curve, nearly baryonic; `a₀ ∝ 1/t` predicts a
+// visibly flatter one; the mean-spacing reading puts a₀ back where it is today
+// and lands on the measurement.
+
+const HZ_M = 1.0e11 * MSUN, HZ_RD = 4.9 * KPC / 1.68;   // Re → exponential Rd
+const HZ_Z = 1.613;
+
+/** the same ring sum, for a single exponential disc of the high-z kind */
+const hzNewton = (r: number, NRr = 300, NP = 300) => {
+  const RMAX = 12 * HZ_RD, h = HZ_RD / 8;
+  let acc = 0;
+  for (let i = 0; i < NRr; i++) {
+    const R = RMAX * (i + 0.5) / NRr, dRr = RMAX / NRr;
+    const s = HZ_M / (2 * Math.PI * HZ_RD * HZ_RD) * Math.exp(-R / HZ_RD) * R * dRr;
+    let a = 0;
+    for (let j = 0; j < NP; j++) {
+      const p = 2 * Math.PI * (j + 0.5) / NP;
+      const dx = R * Math.cos(p) - r, dy = R * Math.sin(p);
+      a += dx / Math.pow(dx * dx + dy * dy + h * h, 1.5);
+    }
+    acc += -G * s * a * (2 * Math.PI / NP);
+  }
+  return acc;
+};
+
+const HZ_VIEW = 16 * KPC;
+
+const HZ_LAWS = (() => {
+  const grid: { r: number; gN: number }[] = [];
+  for (let i = 1; i <= 40; i++) {
+    const r = i * 0.5 * KPC;
+    grid.push({ r, gN: hzNewton(r) });
+  }
+  const speeder = (a0: number) => {
+    const tab = grid.map(p => ({
+      r: p.r,
+      v: Math.sqrt(Math.max(0, (p.gN / 2 + Math.sqrt(p.gN * p.gN / 4 + p.gN * a0)) * p.r)),
+    }));
+    return (r: number) => {
+      const x = r / (0.5 * KPC) - 1;
+      if (x <= 0) return tab[0].v * (r / tab[0].r);
+      const i = Math.min(tab.length - 2, Math.floor(x)), f = x - i;
+      return tab[i].v * (1 - f) + tab[i + 1].v * f;
+    };
+  };
+  return [
+    {
+      name: "WHAT IS MEASURED", under: "baryons — a declining curve (Genzel 2017)",
+      css: SEEN, v: speeder(0),
+    },
+    {
+      name: "a₀ CONSTANT", under: "the mean-spacing reading — a₀ = cH₀/2π",
+      css: MODEL, v: speeder(A0_MODEL),
+    },
+    {
+      name: "a₀ ∝ 1/t", under: `3× larger at z = ${HZ_Z} — refuted`,
+      css: DATA, v: speeder(A0_MODEL * (1 + HZ_Z)),
+    },
+  ];
+})();
+
+const HZ_STARS = (() => {
+  const out: { r: number; th: number }[] = [];
+  let seed = 606011;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+  for (let i = 0; i < 2000; i++) {
+    const u = rnd(); let lo = 0, hi = 14;
+    for (let k = 0; k < 40; k++) {
+      const m = (lo + hi) / 2;
+      if (1 - Math.exp(-m) * (1 + m) < u) lo = m; else hi = m;
+    }
+    const r = (lo + hi) / 2 * HZ_RD;
+    if (r > HZ_VIEW) continue;
+    out.push({ r, th: rnd() * 2 * Math.PI });
+  }
+  return out;
+})();
+
+const HZ_TRACERS = (() => {
+  const out: { r: number; th: number }[] = [];
+  for (let s = 0; s < 4; s++)
+    for (let i = 0; i <= 28; i++)
+      out.push({ r: (2 + (11 * i) / 28) * KPC, th: s * Math.PI / 2 });
+  return out;
+})();
+
+const hzDiscs = (() => {
+  let t = 0;
+  return (s: Surface, dt: number) => {
+    const { ctx, width, height } = s;
+    t += dt * 0.06 * GYR;
+    if (t > 0.26 * GYR) t = 0;
+
+    ctx.clearRect(0, 0, width, height);
+    ctx.fillStyle = "#08090d";
+    ctx.fillRect(0, 0, width, height);
+
+    const gap = 10, w = (width - gap * 2) / 3;
+    const top = 32, side = Math.min(w, height - top - 22);
+
+    HZ_LAWS.forEach((law, n) => {
+      const x0 = n * (w + gap), cx = x0 + w / 2, cy = top + side / 2;
+      const k = side * 0.48 / HZ_VIEW;
+
+      ctx.fillStyle = law.css;
+      ctx.font = "600 10px ui-sans-serif, system-ui, sans-serif";
+      ctx.fillText(law.name, x0 + 2, 12);
+      ctx.fillStyle = FAINT;
+      ctx.font = "400 9px ui-monospace, Menlo, monospace";
+      ctx.fillText(law.under, x0 + 2, 24);
+
+      ctx.strokeStyle = "rgba(255,255,255,0.11)"; ctx.lineWidth = 1;
+      ctx.beginPath(); ctx.arc(cx, cy, 4.9 * KPC * k, 0, 2 * Math.PI); ctx.stroke();
+
+      ctx.fillStyle = "rgba(190,195,208,0.20)";
+      for (const st of HZ_STARS) {
+        const th = st.th + law.v(st.r) / st.r * t;
+        ctx.fillRect(cx + Math.cos(th) * st.r * k - 0.7,
+          cy + Math.sin(th) * st.r * k - 0.7, 1.4, 1.4);
+      }
+
+      const spokes = (of: (r: number) => number, css: string, wide: number, dash: number[]) => {
+        ctx.strokeStyle = css; ctx.lineWidth = wide; ctx.setLineDash(dash);
+        for (let sp = 0; sp < 4; sp++) {
+          ctx.beginPath();
+          for (let i = 0; i <= 28; i++) {
+            const tr = HZ_TRACERS[sp * 29 + i];
+            const th = tr.th + of(tr.r) / tr.r * t;
+            const x = cx + Math.cos(th) * tr.r * k, y = cy + Math.sin(th) * tr.r * k;
+            if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
+          }
+          ctx.stroke();
+        }
+        ctx.setLineDash([]);
+      };
+      if (n !== 0) spokes(HZ_LAWS[0].v, GHOST, 1.3, [3, 3]);
+      spokes(law.v, law.css, 1.7, []);
+    });
+
+    ctx.fillStyle = FAINT;
+    ctx.font = "400 10px ui-monospace, Menlo, monospace";
+    ctx.fillText(`${(t / GYR * 1e3).toFixed(0)} Myr — a compact disc at z = ${HZ_Z}`, 2, height - 6);
+    ctx.textAlign = "right";
+    ctx.fillText("dashed is the measured, baryonic curve — drawn in every panel",
+      width - 2, height - 6);
+    ctx.textAlign = "left";
+  };
+})();
+
+/** the same shearing picture at z ≈ 2, where the readings of a₀ come apart */
+export const HighZDiscs = ({ height = 300 }: { height?: number }) =>
+  <div style={{ marginBottom: "1.1rem" }}>
+    <div style={{
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+      color: FAINT, marginBottom: 6,
+    }}>a compact disc at z ≈ 2 — where a₀ ∝ 1/t predicts a visibly flatter galaxy than is seen</div>
+    <div style={{ height, background: "#08090d" }}>
+      <CanvasView deps={["hzdiscs"]} paint={() => ({ frame: hzDiscs })} />
+    </div>
+  </div>;

From f4ce8bef223ef903ce5efd3a5cc6b84b483632b2 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Wed, 12 Aug 2026 18:19:04 +0200
Subject: [PATCH 30/47] Rotational curves in galaxies dont need dark matter / 
 MOND falls out

---
 .../2026.RayCalculiAndPhysics/gravity.ts      |  143 +-
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 1779 ++++++-----------
 .../2026.RayCalculiAndPhysics/rotation.tsx    |  205 +-
 .../2026.RayCalculiAndPhysics/tests/README.md |  114 ++
 .../2026.RayCalculiAndPhysics/tests/accum.ts  |   25 +
 .../tests/accumulate.ts                       |  109 +
 .../2026.RayCalculiAndPhysics/tests/arms.ts   |  165 ++
 .../2026.RayCalculiAndPhysics/tests/asym.ts   |   15 +
 .../tests/blocking.ts                         |  113 ++
 .../2026.RayCalculiAndPhysics/tests/caught.ts |  137 ++
 .../2026.RayCalculiAndPhysics/tests/clumpy.ts |  151 ++
 .../tests/clusters.ts                         |  118 ++
 .../tests/combined.ts                         |  210 ++
 .../tests/drivers.ts                          |   32 +
 .../2026.RayCalculiAndPhysics/tests/empty.ts  |  166 ++
 .../2026.RayCalculiAndPhysics/tests/expand.ts |  359 ++++
 .../2026.RayCalculiAndPhysics/tests/fair.ts   |  150 ++
 .../2026.RayCalculiAndPhysics/tests/feed.ts   |  153 ++
 .../tests/fixedpoint.ts                       |  171 ++
 .../tests/frontcheck.ts                       |  149 ++
 .../tests/galaxy_sc.ts                        |  246 +++
 .../2026.RayCalculiAndPhysics/tests/genzel.ts |  112 ++
 .../tests/genzel2.ts                          |  101 +
 .../2026.RayCalculiAndPhysics/tests/joint.ts  |   59 +
 .../2026.RayCalculiAndPhysics/tests/perm.ts   |  229 +++
 .../2026.RayCalculiAndPhysics/tests/pol2.ts   |   53 +
 .../tests/polarity.ts                         |  121 ++
 .../2026.RayCalculiAndPhysics/tests/quant.ts  |   25 +
 .../2026.RayCalculiAndPhysics/tests/recon.ts  |   27 +
 .../2026.RayCalculiAndPhysics/tests/redo.ts   |   52 +
 .../tests/residual.ts                         |  112 ++
 .../2026.RayCalculiAndPhysics/tests/rootm.ts  |  134 ++
 .../2026.RayCalculiAndPhysics/tests/rootm2.ts |  133 ++
 .../2026.RayCalculiAndPhysics/tests/run.sh    |   50 +
 .../tests/selfcon.ts                          |  163 ++
 .../2026.RayCalculiAndPhysics/tests/sens.ts   |  308 +++
 .../2026.RayCalculiAndPhysics/tests/shape.ts  |   99 +
 .../2026.RayCalculiAndPhysics/tests/sign.ts   |  273 +++
 .../2026.RayCalculiAndPhysics/tests/sne.ts    |   51 +
 .../tests/spacing.ts                          |   38 +
 .../tests/speedloop.ts                        |  111 +
 .../2026.RayCalculiAndPhysics/tests/steps.ts  |  128 ++
 .../2026.RayCalculiAndPhysics/tests/three.ts  |   72 +
 .../tests/transport.ts                        |  334 ++++
 .../2026.RayCalculiAndPhysics/tests/vmass.ts  |  275 +++
 .../tests/which138.ts                         |  101 +
 46 files changed, 6695 insertions(+), 1176 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accum.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accumulate.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/arms.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/asym.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/blocking.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/caught.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/clumpy.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/clusters.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/combined.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/drivers.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/empty.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/expand.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/fair.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/feed.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/fixedpoint.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/frontcheck.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/galaxy_sc.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel2.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/joint.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/perm.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pol2.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/polarity.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/quant.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/recon.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/redo.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/residual.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/rootm.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/rootm2.ts
 create mode 100755 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/selfcon.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sens.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/shape.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sign.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sne.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/spacing.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/speedloop.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/steps.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/three.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/transport.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/vmass.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/which138.ts

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index e417bf5..fd66c6d 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -1416,6 +1416,37 @@ export const G_LATTICE =
  */
 export const GRAVITY = G_LATTICE * GRAIN;
 
+/**
+ * AND THE ACCUMULATION SETTLES, WHICH RETIRES THE DEFECT BELOW.
+ *
+ * `MADE` is stated as a rate, and the comment below records as its blocking
+ * problem that a rate accumulates: `m·SHEET·t/r` passes `G·m/r` after 0.008
+ * ticks and keeps going, giving 10⁶³ over the age. THAT COUNT INTEGRATES THE
+ * MAKING WITH NOTHING DRAINING IT.
+ *
+ * Annihilation gives the point back. Points made at the body ride out with the
+ * carriers and are unmade where a carrier annihilates, so in steady state
+ *
+ *     (1/r²)·d/dr[r²·c·ρ] = −ρ·c/λ + S·δ(r)   ⇒   ρ = S·e^{−r/λ}/(4πr²c)
+ *
+ * — A STATIC PROFILE WITH NO t IN IT. The total held is λ, set by the mean free
+ * path rather than by the age, and it is reached in λ/c:
+ *
+ *     a galaxy, 30 kpc        settles in 1e−4 Gyr   — instantly
+ *     reach at Ω = 1, 1.5 Gpc 5.0 Gyr
+ *     reach at Ω_b, 6.9 Gpc   22.4 Gyr              — longer than the age
+ *
+ * SO AT SOLAR-SYSTEM AND GALACTIC SCALES u IS THE NEWTONIAN u, every GR test in
+ * this file is computed from the right metric, and `MADE` was never in conflict
+ * with `slowing`. The one place it survives is r ≳ λ, where the excess is still
+ * filling and is suppressed by about ct₀/λ = 0.615 — an order-unity effect at
+ * scales nothing here measures. See `tests/accumulate.ts`.
+ *
+ * (It also removes the last support for the source-feedback route, which needed
+ * the accumulated u to be enormous. That route was retired on other grounds;
+ * this kills it a second time and independently.)
+ */
+
 /**
  * WHAT B WOULD COST, IF SPACE WERE MADE — the surviving account, stated in
  * code because it is a claim about a number, and not wired in because it does
@@ -5042,6 +5073,54 @@ export const caught = {
  * nothing besides.
  */
 
+/**
+ * AND THE STEP, WHICH IS THE ONE PREDICTION LEFT THAT NOTHING ELSE MAKES.
+ *
+ * The projection is a STEP function of the occupancy, because the 26 exits from
+ * a cell carry only three distinct direction cosines — 1 for the six faces,
+ * 1/√2 for the twelve edges, 1/√3 for the eight corners. A galaxy spans
+ * g/a₀ = 0.34 to 4.84 and never crosses one, which is what saves the shape of
+ * the rotation curve. BUT FAR ENOUGH OUT IT DOES CROSS.
+ *
+ *     the cone reaches cos = 1/√2   at   g/a₀ = 0.172
+ *     the cone reaches cos = 1/√3   at   g/a₀ = 0.268
+ *
+ * and in the deep regime g = √(g_N·a₀), so those are RADII:
+ *
+ *     galaxy               M_bar        g/a₀ = 0.268   0.172
+ *     the Milky Way        6.2e10 M☉    33 kpc         52 kpc
+ *     a big spiral, 3×     1.9e11       58             90
+ *     a dwarf, 1/30        2.1e9        6              9
+ *
+ * The Milky Way's two steps land where the Sagittarius stream is and where the
+ * satellites are measured. A dwarf's land INSIDE ITS STELLAR BODY.
+ *
+ * AND THE SIZE. v ∝ a₀^¼ in the deep regime, so the plateau ratios 0.9553,
+ * 0.8919 and 0.8976 give jumps of 1.14%, 2.82% and 2.67% — two to six km/s on a
+ * 200 km/s curve. Small, and SHARP: not a bend but a step, at a radius fixed by
+ * the baryons with nothing to tune.
+ *
+ * WHICH IS THE ONLY GENUINELY NEW THING THIS ACCOUNT OFFERS. MOND has no reason
+ * for a curve to be anything but smooth, and a ΛCDM halo is smooth by
+ * construction. A discrete lattice with 26 exits has exactly three places where
+ * the geometry changes and they are not adjustable.
+ *
+ * AND WHAT IT DOES TO GENZEL, WHICH IS THE OTHER HALF OF THE QUESTION. Those
+ * discs are dense, so they sit on the most-shut plateau where a₀ is smallest:
+ *
+ *     reading                          MW shape   Genzel worst   margin to 1.12
+ *     isotropic, a₀ predicted          1.1%       1.112          0.008
+ *     anisotropic, a₀ predicted        5.2%       1.090          0.030
+ *     anisotropic, a₀ fitted at 1.38×  0.7%       1.117          0.003
+ *
+ * THE ANISOTROPY RELIEVES GENZEL BY 3.7× AND COSTS THE MILKY WAY, and there is
+ * no setting where both are comfortable. Refitting a₀ upward recovers the curve
+ * and gives the margin straight back. So Genzel is not fixed by a knob — it is
+ * fixed by settling HOW FAR THE CONE IS SHUT, which is the same kind of question
+ * as the 13/8 above, and is arithmetic on the emission rule rather than
+ * anything astronomical.
+ */
+
 /**
  * TEST M — THE CARRIERS ALREADY THERE BLOCK THE SPLITTING, WHICH DERIVES THE
  * INTERPOLATION FUNCTION INSTEAD OF ASSUMING IT.
@@ -5073,18 +5152,58 @@ export const caught = {
  * blocking is a function of the field at the point, and nothing else. So it
  * does not move with redshift because there is nothing in it that could.
  *
- * WHICH SETTLES GENZEL WITHOUT THE CANCELLATION:
- *
- *     a₀ reading                value       MW shape   worst boost   all pass?
- *     cH₀/2π, isotropic         1.10e−10    1.1%       1.112         YES
- *     cone shut at cos θ > 0.9  1.05e−10    1.8%       1.108         YES
- *     cone shut at cos θ > 0.5  8.38e−11    5.2%       1.090         YES
- *     the measured a₀           1.20e−10    1.0%       1.120         no
- *
- * ALL FIVE DISCS PASS AND THE MILKY WAY STAYS AT 1.1%. And the last row is
- * worth staring at: the MEASURED a₀ is the one that fails Genzel, by a hair, at
- * 1.120 against 1.12 — while the model's own smaller prediction passes. The 9%
- * the model is "wrong" by is in the direction the high-z data prefer.
+ * WHICH REMOVES THE REFUTATION — BUT NOT THE DISAGREEMENT.
+ *
+ * a₀ no longer moves with redshift, so Test K's refutation of `a₀ ∝ 1/t` no
+ * longer applies. AN EARLIER VERSION OF THIS COMMENT WENT FURTHER AND SAID THE
+ * DISCS THEN PASS. They do not, and the error is worth recording because it was
+ * caught by DRAWING the curves rather than by tabulating them.
+ *
+ * The check took `g_N = GM/R_e²` — a POINT MASS. These are discs, and at one
+ * effective radius a disc has enclosed about half its mass, so its real g_N is
+ * roughly half that. A smaller g_N sits deeper in the boosted regime and gives a
+ * LARGER boost, so the shortcut was generous in exactly the direction that made
+ * the model pass. With the same ring sum used everywhere else in this file:
+ *
+ *     galaxy        point-mass g_N   disc g_N   boost (pt)  boost (disc)
+ *     COS4_01351    9.37e−11         4.52e−11   1.112       1.177  OVER
+ *     D3a_6397      1.36e−10         6.55e−11   1.083       1.134  OVER
+ *     GS4_43501     1.49e−10         7.18e−11   1.077       1.125  OVER
+ *     zC_406690     1.07e−10         5.17e−11   1.101       1.161  OVER
+ *     zC_400569     6.84e−10         3.30e−10   1.019       1.034
+ *
+ * against a ceiling of 1/√0.8 = 1.118. FOUR OF THE FIVE OVERSHOOT.
+ *
+ * WHAT IT WOULD TAKE. The binding disc allows a₀ < 6.59e−11, which is 0.601× the
+ * prediction. The anisotropy supplies 0.765× and is still 1.27× over. Nothing
+ * here offers the rest.
+ *
+ * AND IT IS NOT THIS MODEL ALONE: the measured a₀ = 1.20e−10 is 1.8× the
+ * ceiling, so ordinary MOND overshoots these discs too, and by more. That is a
+ * known tension in that literature rather than something peculiar here — but it
+ * is not a defence, since the model was claiming to do better and does not.
+ *
+ * AND THEN THE UNIT WAS WRONG TOO. "Four of five overshoot" counts how many
+ * crossed a line and says nothing about by how far, or about what Newton does on
+ * the same data. Both matter. And f_DM < 0.2 is an UPPER LIMIT, so the true boost
+ * is somewhere in 1.000…1.118 — Newton sits at the bottom of that band by
+ * construction and this model just above the top:
+ *
+ *     if the truth is    Newton off by   this model off by
+ *     f_DM = 0.00        0.0%            13.3%      Newton wins
+ *     f_DM = 0.10        5.1%             8.1%      about even
+ *     f_DM = 0.20        10.6%            4.4%      THE MODEL WINS
+ *
+ * AND ON THE MILKY WAY THE MODEL IS THIRTY TIMES CLOSER: 1.1% rms against
+ * Newton's 32.5%, worst case 2.6% against 43.1%.
+ *
+ * SO THE HIGH-z DISCS ARE A REAL TENSION AND NOT A REFUTATION. A few percent
+ * high in a regime where the measurement is a bound, in an account that is
+ * thirty times better than the alternative where the measurement is a value.
+ * Worth chasing — the direction is consistent across four galaxies, and the
+ * surviving derivation of a₀ happens to want it smaller — but the model's WORST
+ * error anywhere is a few percent against Newton's factor of two, and that is
+ * the comparison that matters. See `tests/genzel2.ts` and `tests/fair.ts`.
  *
  * AND THEN THE DIRECTION, WHICH IS THE PART NOBODY HAD ASKED. A carrier
  * streaming along ĝ occupies the cell in that direction; the point has `WAYS`
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 581122e..3caed5d 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -2,7 +2,9 @@ import { Fragment, ReactNode, useEffect, useRef, useState } from "react";
 
 import { GRAIN } from "./gravity";
 import { Echoes } from "./echoes";
-import { Apart, Discs, HighRedshift, HighZDiscs, Rotation, Split } from "./rotation";
+import {
+  Apart, Discs, HighRedshift, HighZCurves, HighZDiscs, Rotation, Split,
+} from "./rotation";
 import { Overlay, Routes, Seam, Shadows } from "./shadow";
 
 /**
@@ -3799,1265 +3801,429 @@ export const Law = () => {
       equally, which is what is observed.
     </Note>
 
-    <Head>and then it was tested</Head>
+    <Head>and then all of it was tested</Head>
 
     <Note>
-      <b style={{ color: INK }}>Test A — do the model’s own phases cancel to
-        √<V>N</V>?</b> Not assumed random: <i>inStep</i> says two emitters differ
-      in phase by <V>ω</V>Δ<V>r</V>/<V>c</V> = <V>m</V>Δ<V>r</V>. So{' '}
-      <V>N</V> emitters at random places in a ball of radius <V>R</V>, each given
-      the phase its position implies, summed. At{' '}
-      <V>mR</V> = 10<Sup>−2</Sup> the sum is 1.000·10<Sup>3</Sup> out of
-      10<Sup>3</Sup> — fully coherent. At <V>mR</V> = 10<Sup>4</Sup> it is
-      3.164·10<Sup>2</Sup> against √<V>N</V> = 3.16·10<Sup>2</Sup> —{' '}
-      <b style={{ color: INK }}>exactly the root</b>, with the crossover at{' '}
-      <V>mR</V> ≈ 2π where <i>inStep</i> puts it. The √<V>M</V> half is real,
-      and it is not an assumption about randomness.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>Test B — does locking to a plane change the
-        radial law? It does not.</b> Carriers from a point, turning by a small
-      angle each step, locked to one transverse direction or free in two:
-    </Note>
-
-    <Rows of={[
-      [<span style={{ color: FAINT }}>turn 0.002/step</span>,
-        <>locked −2.000, free −2.000 — difference <b style={{ color: INK }}>0.000</b></>],
-      [<span style={{ color: FAINT }}>turn 0.010/step</span>,
-        <>locked −2.000, free −1.998 — difference 0.002</>],
-      [<span style={{ color: FAINT }}>turn 0.050/step</span>,
-        <>locked −1.964, free −1.929 — difference 0.034</>],
-    ]} />
-
-    <Note>
-      <b style={{ color: INK }}>Locked and free agree to three decimal
-        places.</b> The number of transverse directions makes no difference to
-      the radial law at all — and the reason is{' '}
-      <i>flux conservation</i>, which sideways wandering cannot beat.{' '}
-      <V>N</V> carriers leave, <V>N</V> cross every sphere, the sphere has area
-      4π<V>r</V><Sup>2</Sup>. The 1/<V>r</V> appears only when the walk turns{' '}
-      <i>diffusive</i>, because then radial progress slows as{' '}
-      <V>cλ</V>/2<V>r</V> — and diffusion needs <i>many</i> resets, not few.
-      (A first run of this had the per-step turn at 0.25 rad, so every case had
-      already diffused and all four came out identical; and a fourth row at 0.2
-      gives −3.2 and −5.4, which is a truncation artefact rather than a
-      measurement of the diffusive slope.)
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>So the sheet claim was wrong, and it is worth
-        saying where.</b> “The plane holds the carrier’s own line, so only the
-      widening flattens” does not give 1/<V>r</V>; widening does not touch the
-      radial profile. The permutation search two steps earlier had this right —
-      dense → 1/<V>r</V>, thin → 1/<V>r</V><Sup>2</Sup>,{' '}
-      <i>sign backwards</i> — and the sheet story talked its way out of a correct
-      result. The simulation puts it back.{' '}
-      <b style={{ color: INK }}>That retires the 2D transport mechanism</b>, and
-      with it the <V>a</V><Sub>0</Sub> prediction that rode on it and the derived
-      interpolation function, both of which assumed the locking worked. They are
-      kept above as a route that was tried, not as results.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>What survives is Test A.</b> Phase cancellation
-      is real, measured, and follows from the model’s own <i>inStep</i> rather
-      than from a new assumption — so the √<V>M</V> half stands on its own. The
-      radial law is unexplained again, and the obstruction is exactly what it was
-      before any of this: <V>n</V> ∝ 1/<V>r</V> needs the carriers to slow, and
-      everything in this model moves at <V>c</V>. (The caught pair, later,
-      supplies that radial law from a different direction — so what follows is
-      about the <i>other</i> half.)
-    </Note>
-
-    <Head>test C — could √M come from the vacuum instead?</Head>
-
-    <Note>
-      Test A’s cancellation is a cancellation of <i>phases</i>, and it needs the
-      source to be an <b style={{ color: INK }}>amplitude</b> — a coherent sum —
-      rather than a count. Gravity here is a <i>rate</i> of annihilations, and
-      rates do not cancel. So the obvious thing to try is a cancellation that
-      works on counts: <b style={{ color: INK }}>a body’s own charges
-        annihilating each other on the way out</b>. Emit <V>N</V> pairs a tick
-      from a ball, let every + and − landing in the same cell annihilate, count
-      what crosses a distant sphere. Nothing assumed about randomness — the
-      charges are moved and met.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>It does cancel, and an optical depth controls
-        it.</b> The surface density of a body’s own charges is ~2<V>N</V>/4π<V>R</V><Sup>2</Sup>{' '}
-      per tick over a path ~<V>R</V>, so <V>τ</V> = <V>N</V>/(2π<V>R</V>) with{' '}
-      <V>R</V> in cells — and the measured survival collapses onto it exactly.
-      Three <V>N</V>,<V>R</V> pairs spanning sixteenfold in <V>N</V> give
-      52.0 / 49.4 / 51.0% at <V>τ</V> = 1.06, and 19.9 / 19.2 / 19.7% at 6.37.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>And it passes through √<V>N</V> without stopping
-        there</b>, which is the finding. The exponent d(log <V>F</V>)/d(log{' '}
-      <V>N</V>) runs 0.920 at <V>τ</V> = 0.13, 0.734 at 0.80,{' '}
-      <b style={{ color: INK }}>0.563 at 1.99</b>, then 0.421, 0.273, 0.244. It
-      is not a plateau at ½ — it slides continuously from 1 toward 0 and touches
-      ½ at <V>τ</V> ≈ 2.5 on the way past. Tully–Fisher needs the <i>same</i>{' '}
-      exponent across five decades of mass, and <V>τ</V> ∝ <V>M</V>/<V>R</V>{' '}
-      varies across those decades. A crossover cannot impersonate a power law.
-    </Note>
-
-    <Note>
-      And it is moot anyway, because nothing real is dense enough. A proton sits
-      at <V>τ</V> = 4·10<Sup>−39</Sup>, the Earth 2·10<Sup>−9</Sup>, the Milky
-      Way 5·10<Sup>−7</Sup>, the Sun 5·10<Sup>−6</Sup>.{' '}
-      <b style={{ color: INK }}>Every real body is dilute</b> — its own flux
-      never meets itself, survival is 100%, and the flux goes as <V>N</V>{' '}
-      exactly. A galaxy is thirteen orders below where the cancellation starts,
-      which is the same fact <K>shows</K> reports from the other side.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>The one place it could ever bite is a neutron
-        star</b>, at <V>τ</V> = 0.44 — the only object within an order of the
-      threshold. So the mechanism is not nothing. It is a statement about the
-      densest matter there is, and it has nothing whatever to say about rotation
-      curves.
-    </Note>
-
-    <Note>
-      Which leaves Test A alone, and sharpens what it owes.{' '}
-      <b style={{ color: INK }}>The radial law is supplied</b> — the caught pair.{' '}
-      <b style={{ color: INK }}>The cancellation is supplied</b> — Test A,
-      measured. What is missing is one thing and it can now be stated in a line:{' '}
-      <b style={{ color: INK }}>a reason for a rate to care about a phase.</b>
-    </Note>
-
-    <Head>test D — and there is a reason, the wrong way round</Head>
-
-    <Note>
-      There is a candidate, and it is structurally the right shape:{' '}
-      <b style={{ color: INK }}>in this model a rate and a phase are the same
-        variable</b>. Mass is a <i>period</i> — <V>X</V> = 1/<V>m</V> ticks
-      between pulses — so the emission rate is the thing carrying the phase. And
-      gravity makes a body lighter,{' '}
-      <V>m</V><Sub>eff</Sub> = <V>m</V>/(1+<V>u</V>), so the well modulates it
-      and the two feed each other. Two pieces, both testable.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>The first fails on size.</b> For the well to
-      move a body across <i>inStep</i>’s switch, <V>m</V> must fall by{' '}
-      <V>m</V>·<V>R</V>/2π. At the Sun’s surface <V>u</V> = 2.1·10<Sup>−6</Sup>{' '}
-      against a factor 8.4·10<Sup>24</Sup> needed; in the Galaxy at 8 kpc,
-      3.7·10<Sup>−7</Sup> against 3.0·10<Sup>36</Sup>.{' '}
-      <b style={{ color: INK }}>Forty-three orders short</b> where it matters.
-      Gravity does make things lighter and cannot make them lighter enough to
-      change what they cancel to.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>The second works</b>, and does not need the
-      first. If emission is <i>pulsed</i> rather than steady, two charges meet
-      only when their bunches arrive together — so the meeting rate really does
-      depend on relative phase. Measured at fixed average emission, varying only
-      the spread of the phases: steady gives 28.2% survival; period 16{' '}
-      <i>all in step</i> gives <b style={{ color: INK }}>17.4%</b>; period 16
-      with random phases gives <b style={{ color: INK }}>28.5%</b>. Bunching
-      cancels, and only in step — random phases smooth out completely and are
-      indistinguishable from a steady source to a tenth of a percent.
-    </Note>
-
-    <Rows of={[
-      [<span style={{ color: DERIVED }}>Test A’s √<V>N</V> needs them OUT of step</span>,
-        <><V>m</V>·<V>R</V> ≫ 2π — phases spread over many wavelengths, so the
-          coherent sum falls to √<V>N</V>.</>],
-      [<span style={{ color: DERIVED }}>Test D’s cancellation needs them IN step</span>,
-        <><V>m</V>·<V>R</V> ≪ 2π — bunches arriving together, so the arrivals
-          annihilate each other instead of being tallied.</>],
-    ]} />
-
-    <Note>
-      <b style={{ color: INK }}>They are the same condition read in opposite
-        directions, so no body can have both.</b> A galaxy sits at{' '}
-      <V>m</V>·<V>R</V> ≈ 3·10<Sup>36</Sup>: its phases cancel beautifully and
-      its rate does not notice — which is exactly what Test C found from the
-      other side. Anything coherent enough for the rate to care is smaller than
-      a Compton wavelength and has nothing left to cancel. And even where it does
-      care it overshoots: quadrupling the mass in step gives a slope of 0.243,
-      against 0.35 out of step. Past ½ again, toward saturation.
-    </Note>
-
-    <Note>
-      So where <i>coherence</i> is concerned the bridge is missing because the
-      model makes the two requirements exclusive.{' '}
-      <b style={{ color: INK }}>But that tested the wrong variable, and the next
-        section overturns the conclusion.</b> Everything above asks whether the
-      feedback can move a body across <i>inStep</i>’s switch. It cannot — and it
-      does not have to.
-    </Note>
-
-    <Head>test E — and it works, with no phase in it at all</Head>
-
-    <Note>
-      Stated so it can be tested rather than argued:{' '}
-      <b style={{ color: INK }}>the loop feeds itself but by less each round.</b>{' '}
-      More fold makes a body lighter, lighter makes fewer pulses, fewer pulses
-      make less fold. A <i>self-limiting</i> feedback, and a self-limiting
-      feedback has a fixed point —{' '}
-      <V>M</V><Sub>eff</Sub> = <V>N</V>/(1 + <V>κM</V><Sub>eff</Sub><Sup>p</Sup>),
-      giving <V>M</V><Sub>eff</Sub> ∝ <V>N</V><Sup>1/(1+p)</Sup>. So everything
-      turns on <V>p</V>, and <V>p</V> is not a choice: it is what the
-      annihilation counting gives. So it was measured.
-    </Note>
-
-    <Rows of={[
-      [<span style={{ color: DERIVED }}>measured <V>p</V> = 1.075</span>,
-        <>Emitters at the ceiling, slowed each round by the fold their own
-          charges built, iterated to a fixed point. The source slope runs 0.668,
-          0.530, <b style={{ color: INK }}>0.478</b> as <V>N</V> quadruples, and{' '}
-          <V>p</V> = d(log <V>u</V>)/d(log source) comes out 1.075 — predicting
-          an exponent of 0.482.</>],
-      [<span style={{ color: DERIVED }}>and the fixed point is exact</span>,
-        <>Solved directly over six decades: <V>p</V> = ½ gives 0.6671,{' '}
-          <V>p</V> = 1 gives <b style={{ color: INK }}>0.5000</b>, <V>p</V> = 2
-          gives 0.3333 — against 2/3, 1/2, 1/3 predicted.</>],
-    ]} />
-
-    <Note>
-      <b style={{ color: INK }}>So this is not a crossover.</b> Tests C and D
-      gave exponents that slid <i>past</i> ½ on the way to saturation, which is
-      why neither could carry Tully–Fisher. This one{' '}
-      <b style={{ color: INK }}>converges on ½ and stays</b>, because ½ is a
-      fixed point of the loop rather than a point on a curve. And{' '}
-      <V>p</V> = 1 — the fold at an emitter going linearly with what its body
-      emits — is exactly what gives ½, and <V>p</V> = 1 is what was measured.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>The one thing in the way is the scale, and it is
-        seven orders, not forty-three.</b> The loop bites once <V>u</V> ≳ 1.
-      Read with <V>u</V> as the Newtonian potential, a proton sits at
-      1.5·10<Sup>−39</Sup> and the Milky Way at 2.0·10<Sup>−7</Sup> — exponent
-      1.000000 — while a neutron star reaches 0.87 and a body at its own{' '}
-      <V>r</V><Sub>s</Sub> reaches 0.75.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>And <V>u</V> is not the Newtonian potential
-        here</b>, which is the whole point. This file already says so and files
-      it as a <i>defect</i>: <K>MADE</K> is a rate, so the fold{' '}
-      <i>accumulates</i> — <V>m</V>·<K>SHEET</K>·<V>t</V>/<V>r</V> passes{' '}
-      <V>Gm</V>/<V>r</V> after 0.008 ticks and keeps going. Over the age that is
-      a factor of 1.04·10<Sup>63</Sup>, which puts the proton at
-      1.5·10<Sup>24</Sup>, the Sun at 2.2·10<Sup>57</Sup>, the Milky Way at
-      2.1·10<Sup>56</Sup> — <b style={{ color: INK }}>every body at exactly ½,
-        and at the same ½</b>. One exponent, unchanging across five decades,
-      which is what Tully–Fisher demands and no crossover can supply.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>So the defect and the mechanism are the same
-        fact.</b> The accumulating fold was written down as the reason the{' '}
-      <K>MADE</K> account could not be wired in; it is also the only thing that
-      puts real bodies where the feedback gives √<V>M</V>. One of those two
-      readings is wrong, and they cannot both stand.
-    </Note>
-
-    <Rows of={[
-      [<span style={{ color: BORROWED }}>which channel</span>,
-        <>A √<V>M</V> source on the <i>direct</i> 1/<V>R</V><Sup>2</Sup> channel
-          makes gravity weaker, not stronger, and would show in the solar system.
-          It helps only if it scales the caught pair’s 1/<V>R</V> channel while
-          Newton’s keeps its count — and nothing here says why two channels would
-          couple to different things.</>],
-      [<span style={{ color: BORROWED }}>what stops it</span>,
-        <>An unbounded accumulating fold sends{' '}
-          <V>m</V><Sub>eff</Sub> → 0: every body fades. The fixed point above is
-          one in <V>N</V> at fixed <V>κt</V>, and the <V>t</V>-dependence has not
-          been solved at all.</>],
-      [<span style={{ color: BORROWED }}>and the solar system</span>,
-        <>If <V>u</V> really is 10<Sup>57</Sup> at the Sun then <K>slowing</K>,{' '}
-          <K>thickness</K> and every GR test in this file are computed from the
-          wrong <V>u</V> — and those pass. That is the sharpest objection to the
-          accumulating reading and it is not answered here.</>],
-    ]} />
-
-    <Note>
-      None of which retracts the measurement.{' '}
-      <b style={{ color: INK }}>The self-limiting loop gives an exponent of
-        exactly ½, as a fixed point, out of the model’s own two rules</b> — mass
-      is a period, and fold slows the period. It is the first mechanism in this
-      file that <i>produces</i> the mass law rather than approaching it.
-    </Note>
-
-    <Head>and which slowing is it?</Head>
-
-    <Note>
-      There are two readings of that chain, and they give <i>different</i>{' '}
-      exponents — so for once the data can choose. Test E slowed the emitter by
-      the <b style={{ color: INK }}>fold</b> it sits in. The other reading is the
-      model’s own speed rule, and is arguably the more native one:{' '}
-      <i>it accelerates → it goes faster → it moves on more ticks and updates on
-        fewer → it ticks less → it is lighter → it pulls less → it accelerates
-        less.</i> Same self-limiting shape, but driven by <K>massFor</K> rather
-      than <K>slowing</K>.
-    </Note>
-
-    <Note>
-      The exponent comes from how the driver scales with the source, and that is
-      where they part company. <V>M</V><Sub>eff</Sub> ∝{' '}
-      <V>N</V><Sup>1/(1+p)</Sup>, measured over six decades and converged to
-      five figures: the fold gives <V>p</V> = 1 and{' '}
-      <b style={{ color: INK }}>0.50000</b>; speed gives <V>p</V> = ½ and{' '}
-      <b style={{ color: INK }}>0.66667</b> — because{' '}
-      <V>v</V><Sup>2</Sup> = <V>GM</V>/<V>r</V>, so{' '}
-      <b style={{ color: INK }}>speed already carries its own square root</b>,
-      and a feedback driven by it can only spend that root once.
-    </Note>
-
-    <Rows of={[
-      [<span style={{ color: BORROWED }}>no feedback — <V>e</V> = 1</span>,
-        <>Tully–Fisher slope 2.00. <b style={{ color: INK }}>20.6σ</b> out.</>],
-      [<span style={{ color: BORROWED }}>speed as driver — <V>e</V> = 2/3</span>,
-        <>Slope 3.00. <b style={{ color: INK }}>9.4σ</b> out.</>],
-      [<span style={{ color: DERIVED }}>fold as driver — <V>e</V> = 1/2</span>,
-        <>Slope 4.00 against a measured 3.85 ± 0.09 —{' '}
-          <b style={{ color: INK }}>1.7σ</b>, i.e. inside the error.</>],
-    ]} />
-
-    <Note>
-      <b style={{ color: INK }}>The fold reading lands inside 2σ and the speed
-        reading does not.</b> So the chain is right and the driver has to be the
-      one that scales <i>linearly</i> with the source. That is a real
-      discrimination between two versions of one idea, made by data rather than
-      by preference — and the first time anything in this file has been able to
-      choose between two mechanisms on the mass law.
-    </Note>
-
-    <Note>
-      And the speed reading is too small anyway, independently of its exponent.{' '}
-      <V>v</V>/<V>c</V> is the whole size of it: 9.9·10<Sup>−5</Sup> at the
-      Earth’s orbit, 7.6·10<Sup>−4</Sup> for the Sun round the Galaxy,
-      3.3·10<Sup>−3</Sup> in a cluster. Run on the Milky Way it slows the curve
-      by 0.06% at 2 kpc and 0.02% at 30, where the discrepancy is a factor of
-      two. <b style={{ color: INK }}>The sign is right and nothing else is</b> —
-      the same verdict <K>carry</K> got, for the same reason.
-    </Note>
-
-    <Note>
-      What survives of it: the speed rule is not the driver of the mass law, but
-      it shows the two readings are not interchangeable, and it explains{' '}
-      <i>why</i> the fold reading works —{' '}
-      <b style={{ color: INK }}>the feedback needs a driver that has not already
-        spent the square root</b>, and the accumulated fold is the only such
-      quantity the model has.
-    </Note>
-
-    <Head>test F — and then it was run on a whole galaxy</Head>
-
-    <Note>
-      Tests C, D and E were boxes of a few thousand cells, or transients begun
-      from nothing at <V>t</V> = 0. A galaxy is neither. So it was rebuilt: the
-      real Milky Way baryons ring by ring with no shell theorem,{' '}
-      <b style={{ color: INK }}>the field solved as a fixed point rather than a
-        transient</b> — every source weakened by the field it sits in, that field
-      made by all the already-weakened sources, iterated to convergence, which is
-      what “gravity has already propagated everywhere” has to mean — and the
-      circular speed at every radius solved <i>together with</i> the field, so a
-      speed-driven feedback is fed the speed it actually produces.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>First, the thing that settles the speed question
-        outright</b>, and it is more general than any exponent. Pushed to{' '}
-      <V>κ</V> = 10<Sup>6</Sup>, far past anything physical, with the galaxy’s
-      own self-consistent speeds, the curve at the Sun goes 185.6 → 180.9 →
-      102.2 → 66.2.{' '}
-      <b style={{ color: INK }}>A feedback that weakens the source can only lower
-        a rotation curve.</b> Monotone in <V>κ</V>, and it never turns around. So
-      the feedback is not the dark matter and cannot be — it can only govern how
-      an excess supplied by something <i>else</i> scales with mass.
-    </Note>
-
-    <Note>
-      So the honest object is the pair: the caught pair’s 1/<V>R</V> channel
-      supplying the excess, the feedback setting its mass scaling. Two
-      requirements at once — the <b style={{ color: INK }}>shape</b> of one
-      rotation curve, and the <b style={{ color: INK }}>slope</b> across five
-      decades of galaxy mass with sizes following the observed{' '}
-      <V>R</V> ∝ <V>M</V><Sup>0.35</Sup>. Five drivers, three channel choices,
-      local or body-averaged, eight couplings.{' '}
-      <b style={{ color: INK }}>No permutation meets both.</b>
+      What follows was thirteen separate attempts, built and measured over a
+      long stretch, and most of them are wrong. Written out in order they were a
+      history rather than an argument, so here they are as one thing:{' '}
+      <b style={{ color: INK }}>what has to be produced, what produces it, and
+        what each of the alternatives died of</b>. Every number below is measured
+      on a fully relaxed galaxy — the real Milky Way baryons, ring by ring and
+      angle by angle, the field solved as a fixed point rather than a transient,
+      and the circular speed at every radius solved together with the field.
     </Note>
 
     <Rows of={[
-      [<span style={{ color: DERIVED }}>caught pair alone</span>,
-        <>shape <b style={{ color: INK }}>3.2%</b>, BTFR slope 2.51.</>],
-      [<span style={{ color: FAINT }}>+ feedback, <V>κ</V> = 10<Sup>6</Sup></span>,
-        <>shape 9.7%, slope 2.92.</>],
-      [<span style={{ color: BORROWED }}>+ feedback, saturated</span>,
-        <>shape 19.8%, slope <b style={{ color: INK }}>3.25</b> — and the curve
-          now <i>rises</i>: <V>v</V>(30) = 264.9 against <V>v</V>(8) = 229, where
-          Gaia has it falling.</>],
-      [<span style={{ color: INK }}>wanted</span>,
-        <>shape under 5%, slope 3.85 ± 0.09. The best joint fit anywhere in the
-          search is <b style={{ color: INK }}>6.7σ</b> away.</>],
+      [<span style={{ color: INK }}>the two things to produce</span>,
+        <>The <b style={{ color: INK }}>shape</b> — one galaxy’s rotation curve,
+          which needs the pull to fall as 1/<V>r</V> where Newton has
+          1/<V>r</V><Sup>2</Sup>. And the <b style={{ color: INK }}>scaling</b> —
+          the Tully–Fisher slope across five decades of galaxy mass, which needs{' '}
+          <V>v</V><Sup>4</Sup> ∝ <V>M</V>, i.e. an effective source going as
+          √<V>M</V>. Every attempt below gets at most one of them.</>],
+      [<span style={{ color: BORROWED }}>and why no force law can</span>,
+        <>The equivalence principle and the third law together force any
+          two-body pull to be bilinear, <V>F</V> ∝ <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub>,
+          which gives <V>v</V><Sup>4</Sup> ∝ <V>M</V><Sup>2</Sup> — slope 2
+          against a measured <b style={{ color: INK }}>3.85 ± 0.09</b>, or 20.6σ.{' '}
+          <b style={{ color: INK }}>So superposition has to fail somewhere</b>,
+          and the only question is where.</>],
     ]} />
 
-    <Note>
-      <b style={{ color: INK }}>Which corrects Test E, and the correction is the
-        point.</b> Test E measured the exponent on what was effectively a point
-      source and got exactly ½; that stands as arithmetic. What it could not see
-      is that <i>reaching</i> the regime where the exponent is ½ needs{' '}
-      <V>κu</V> ≫ 1 throughout the galaxy — and a <V>u</V> that varies by an
-      order of magnitude across the disc cannot be deep in that regime everywhere
-      without deforming the profile.{' '}
-      <b style={{ color: INK }}>The fixed point is real and it is not reachable
-        with a rotation curve still attached.</b>
-    </Note>
-
-    <Note>
-      (One bug found on the way, recorded because it changed a number: the bulge
-      was being added <i>unweakened</i>. At large <V>κ</V> the disc was crushed
-      and the untouched bulge dominated, dragging the slope back to Newton’s 2.07
-      and making the feedback look useless in the wrong direction. Weakened
-      consistently — a bulge is made of emitters too — the slope rises to 3.25
-      instead. The conclusion did not change; the number was wrong.)
-    </Note>
-
-    <Note>
-      So: <b style={{ color: INK }}>the chain is sound</b>, self-limiting, with a
-      real fixed point. <b style={{ color: INK }}>The exponent is right in
-        isolation</b>, ½, measured twice.{' '}
-      <b style={{ color: INK }}>The shape is supplied</b>, by the caught pair, at
-      3.2%. <b style={{ color: INK }}>And they cannot be had together.</b> That
-      is not a gap in the argument — it is a measured incompatibility between the
-      two halves, on a galaxy, with the field relaxed and one number fitted. The
-      model still has no dark matter; what is different is that it is no longer
-      missing a mechanism. It has two, each doing its own half correctly, and a
-      demonstration that they do not compose.
-    </Note>
-
-    <Head>test G — they do compose</Head>
-
-    <Note>
-      <b style={{ color: INK }}>That last sentence is withdrawn, and the fault
-        was in the test.</b> Every feedback above was written{' '}
-      <V>m</V>/(1+<V>κD</V>), which <i>saturates</i>: past <V>κD</V> ≫ 1 it stops
-      responding and the exponent stalls wherever it happened to be. That form
-      was mine. It is nowhere in the model. The model’s own conversion is a{' '}
-      <i>power law</i>, and a power law never saturates:{' '}
-      <b style={{ color: INK }}><K>massFor</K>(<V>v</V>) = <V>c</V>/<V>v</V></b>,
-      so <V>m</V> ∝ 1/<V>v</V> exactly.
-    </Note>
-
-    <Note>
-      So the honest test is <V>m</V><Sub>eff</Sub> ∝ <V>v</V><Sup>−q</Sup>{' '}
-      solved self-consistently, with <b style={{ color: INK }}><V>q</V> = 1 being
-        the model’s own rule and not a fitted exponent</b>. The expectation is
-      clean: for the caught pair’s flat channel{' '}
-      <V>v</V><Sup>2</Sup> = <V>λM</V><Sub>eff</Sub> ∝ <V>λN</V><V>v</V><Sup>−q</Sup>,
-      so <V>v</V><Sup>2+q</Sup> ∝ <V>N</V> and the Tully–Fisher slope is{' '}
-      <b style={{ color: INK }}>2 + <V>q</V></b>.
-    </Note>
+    <Head>what does not work, and what each one cost</Head>
 
     <Rows of={[
-      [<span style={{ color: FAINT }}><V>q</V> = 0 — caught pair alone</span>,
-        <>shape 3.2%, slope 2.51.</>],
-      [<span style={{ color: DERIVED }}><V>q</V> = 1 — the model’s <K>massFor</K></span>,
-        <>shape <b style={{ color: INK }}>2.6%</b>, slope{' '}
-          <b style={{ color: INK }}>3.60</b>. Both halves improve at once — the
-          shape is <i>better</i> than the caught pair had alone.</>],
-      [<span style={{ color: FAINT }}><V>q</V> = 2</span>,
-        <>shape 1.1%, slope 4.58 — overshoots.</>],
+      [<span style={{ color: BORROWED }}>a halo of made space</span>,
+        <>Three profiles: uniform gives <V>v</V> ∝ <V>r</V>, depleted gives{' '}
+          <V>r</V><Sup>3/2</Sup>, and <i>stimulated</i> — a neutral point
+          splitting when a charge arrives — gives <V>ρ</V> ∝ 1/<V>r</V><Sup>2</Sup>,
+          an isothermal halo, and a flat curve. It dies on Tully–Fisher:{' '}
+          <V>v</V><Sup>4</Sup> ∝ <V>M</V><Sup>2</Sup>, a factor of ten out at
+          each end of the range.</>],
+      [<span style={{ color: BORROWED }}>the caught pair</span>,
+        <>One charge of a vacuum pair taken by each body, so the point is never
+          given back. The geometry is exact —{' '}
+          ∫d<Sup>3</Sup><V>P</V>/(<V>r</V><Sub>A</Sub><Sup>2</Sup><V>r</V><Sub>B</Sub><Sup>2</Sup>)
+          = π<Sup>3</Sup>/<V>R</V>, checked by Monte Carlo to 5% —{' '}
+          <b style={{ color: INK }}>so it gives 1/<V>R</V>, the shape, from a
+            geometric integral rather than a choice</b>. Added to Newton it fits
+          the Milky Way to 3.2%. But it is still bilinear, so the slope stays at
+          2.51, and the vacuum density it needs puts the range of gravity at
+          5·10<Sup>−32</Sup> m.</>],
+      [<span style={{ color: BORROWED }}>cancellation in the source</span>,
+        <>Three versions, all measured, all dead. A body’s own charges
+          annihilating on the way out gives an exponent that <i>slides past</i> ½
+          rather than sitting at it, and every real body is dilute anyway —{' '}
+          <V>τ</V> = <V>N</V>/2π<V>R</V> is 5·10<Sup>−7</Sup> for the Milky Way,
+          thirteen orders below where it would start. Pulsed emission cancels
+          only when the emitters are <i>in step</i>, which is the opposite of
+          what √<V>N</V> needs, so no body can have both. And a feedback that
+          weakens the source can only <i>lower</i> a rotation curve — monotone in
+          the coupling, never turning round, at any strength.</>],
+      [<span style={{ color: BORROWED }}>a second, charge-like layer</span>,
+        <>Recorded in full further down as a road not taken. It needs the layers
+          coupled to be non-linear, and once coupled it is a two-body law again
+          and the theorem applies.</>],
     ]} />
 
     <Note>
-      <b style={{ color: INK }}>They are not in tension; each helps the other</b>,
-      which is what a composition ought to look like and what Test F said was
-      impossible. Against Gaia radius by radius, on one fitted number: 0.991 at
-      6 kpc, 0.999 at 8, 0.985 at 12, 0.964 at 20, 0.990 at 30 —{' '}
-      <b style={{ color: INK }}>inside 3.6% from 6 to 30 kpc</b>, where Newton is
-      short by 52% and 242% at the two ends.
-    </Note>
-
-    <Note>
-      And the slope’s remaining gap is <i>my</i> systematic, not the model’s.
-      3.60 against 3.85 ± 0.09 is 2.8σ — but the galaxy family is my
-      construction, and its assumed size–mass relation moves the answer further
-      than the discrepancy does: <V>R</V> ∝ <V>M</V><Sup>0.20</Sup> gives 3.31,{' '}
-      <V>M</V><Sup>0.35</Sup> gives 3.60, <V>M</V><Sup>0.50</Sup> gives 4.03.{' '}
-      <b style={{ color: INK }}>The measured 3.85 sits inside that range</b>, at{' '}
-      <V>s</V> ≈ 0.42.
+      <b style={{ color: INK }}>What all of them share is that they put the
+        non-linearity in the source.</b> The theorem says that cannot work, and
+      each attempt found a different way of being told so. It has to go in the{' '}
+      <i>transport</i> — in how the carriers travel, not in how hard anything
+      pulls.
     </Note>
 
-    <Rows of={[
-      [<span style={{ color: BORROWED }}>the sign of the identity</span>,
-        <>Which decides everything. <K>massFor</K> is a <i>cost</i> per step and
-          is ≥ 1; the emission side is a <i>rate</i> and is ≤ 1, and{' '}
-          <code>physics.ts</code> bridges them with “once a tick is the ceiling,
-          which <i>turns the identity round</i>”. If the rate is <V>m</V> the
-          source goes as 1/<V>v</V> and <V>q</V> = +1, giving 3.60. If it is
-          1/<V>m</V> the source goes as <V>v</V> and <V>q</V> = −1, giving{' '}
-          <b style={{ color: INK }}>1.30</b>. The whole result rides on a reading
-          this file asserted in one direction and used in the other.</>],
-      [<span style={{ color: BORROWED }}><V>λ</V> is still fitted</span>,
-        <>One number, but nothing derives it — so until something does, this is a
-          one-parameter fit that happens to have the right shape.</>],
-      [<span style={{ color: BORROWED }}>and the density bill stands</span>,
-        <>The <V>Φ</V> that makes <V>λ</V> this big puts the range of gravity at
-          5·10<Sup>−32</Sup> m. Nothing here answers that, and it is still the
-          reason the mechanism cannot yet be believed.</>],
-    ]} />
+    <Head>what does work — the carriers slow where they are thin</Head>
 
     <Note>
-      <b style={{ color: INK }}>But the composition is real and it was
-        measured.</b> Two mechanisms, each derived for its own reason, one fitted
-      constant between them, and both the shape of a rotation curve and the mass
-      scaling of a population come out together. That has not happened before in
-      this file. <b style={{ color: INK }}>And then the sign was settled, against
-        it.</b>
+      Speed here is a budget between moving and updating, so a carrier that has
+      to spend ticks on itself drifts below <V>c</V>. <K>inStep</K> read as a
+      budget says when it does not have to:{' '}
+      <b style={{ color: INK }}>emitters within a common phase pay the update
+        once between them</b>, so a dense field is a fast one and a thin field is
+      a slow one. That is the whole mechanism, and it needs no new rule.
     </Note>
 
-    <Head>test H — settling the sign</Head>
-
-    <Note>
-      Test G rode entirely on reading <K>massFor</K>(<V>v</V>) = <V>c</V>/<V>v</V>{' '}
-      as the emission rate. Take the model’s own account of what a step costs —{' '}
-      <b style={{ color: INK }}>a step takes a point from in front and puts one
-        behind, so a step costs a tick</b> — and the budget is forced:
-      the share of ticks spent moving plus the share spent updating is one, so
-      the pulse rate goes as (1 − <V>v</V>/<V>c</V>). Which is not{' '}
-      <V>c</V>/<V>v</V>, and the difference is everything.
-    </Note>
+    <Eq open={show} note="the drift, and flux conservation with it">
+      <V>v</V> = <V>c</V>·min(1, <V>n</V>/<V>n</V><Sub>c</Sub>)
+      <span style={{ padding: '0 1.6em', color: FAINT }}>,</span>
+      <V>Φ</V> = 4π<V>r</V><Sup>2</Sup>·<V>n</V>·<V>v</V> = constant
+    </Eq>
 
     <Rows of={[
-      [<span style={{ color: BORROWED }}>source ∝ 1/<V>v</V> (test G)</span>,
-        <>weakening of order one — shape 2.6%, slope 3.60.</>],
-      [<span style={{ color: DERIVED }}>source ∝ (1−<V>v</V>/<V>c</V>) — the budget</span>,
-        <>weakening of <b style={{ color: INK }}>0.076%</b> — shape 3.2%, slope{' '}
-          <b style={{ color: INK }}>2.509</b>. Which is the caught pair alone, to
-          three digits.</>],
+      [<span style={{ color: DERIVED }}>dense — <V>n</V> &gt; <V>n</V><Sub>c</Sub></span>,
+        <><V>v</V> = <V>c</V>, so <V>n</V> ∝ 1/<V>r</V><Sup>2</Sup>.{' '}
+          <b style={{ color: INK }}>Newton.</b></>],
+      [<span style={{ color: DERIVED }}>thin — <V>n</V> &lt; <V>n</V><Sub>c</Sub></span>,
+        <><V>v</V> ∝ <V>n</V>, so flux conservation goes <i>quadratic</i> and{' '}
+          <V>n</V> ∝ √<V>Φ</V>/<V>r</V>.{' '}
+          <b style={{ color: INK }}>Both halves at once</b> — the 1/<V>r</V> law{' '}
+          <i>and</i>, since <V>Φ</V> ∝ <V>M</V>, an effective source going as
+          √<V>M</V>. Measured by integrating the transport: −2.0000 inside,
+          −1.0000 outside, and the outer density against √<V>Φ</V> comes to
+          10.0000 for a hundredfold mass.</>],
     ]} />
 
     <Note>
-      And <K>massFor</K> cannot be pressed into service instead, for a reason
-      that is structural rather than numerical.{' '}
-      <b style={{ color: INK }}>It is a cost per step and is ≥ 1; the emission
-        side is a rate and is ≤ 1 by the one-a-tick ceiling.</b> Disjoint ranges,
-      meeting only at exactly 1. There is no reading on which a star’s
-      constituents, orbiting at 7.6·10<Sup>−4</Sup> <V>c</V>, have an emission
-      rate of 1362 pulses a tick against a ceiling of one. Test G’s exponent was
-      never available — it was reading a <i>cost</i> as a <i>rate</i> because
-      this file calls both of them “mass”.
+      <b style={{ color: INK }}>That is the non-linearity the theorem demanded</b>,
+      and it lives in the transport rather than the source — which is why every
+      attempt to put it in the source failed. Nothing about it is fitted: the
+      quadratic comes from <V>v</V> ∝ <V>n</V> and the rest is flux conservation.
     </Note>
 
-    <Note>
-      <b style={{ color: INK }}>So Test G is withdrawn as a result.</b> What
-      survives is its method and one real lesson: a <i>saturating</i> feedback
-      and a <i>power-law</i> one behave completely differently, and Test F’s
-      failure was the saturating form’s fault. That correction stands. The 3.60
-      does not.
-    </Note>
-
-    <Head>and what that leaves standing</Head>
+    <Head>and the turnover is derived, not borrowed</Head>
 
     <Note>
-      The transport route — and it needs none of this.{' '}
-      <b style={{ color: INK }}>Its √<V>M</V> does not come from the source at
-        all</b>: flux conservation goes <i>quadratic</i> in <V>n</V> once the
-      drift is <V>v</V> = <V>c</V>·min(1, <V>n</V>/<V>n</V><Sub>c</Sub>), and the
-      root falls out of the transport. Its sign is fixed by <K>inStep</K> read as
-      a budget — in step, one phase paid once, so dense is fast — rather than by
-      identifying two incompatible masses. And it had never been run on a galaxy.
-      Run now, on the relaxed disc:
+      Every version of this above wrote the turnover as MOND’s “simple”
+      interpolation and said so. <b style={{ color: INK }}>It was assumed.</b>{' '}
+      Here is where it comes from, and it is <K>through</K>: a neutral point
+      becomes a ± pair, but a point that already has a carrier on it is busy —
+      an arriving charge annihilates or reverses, and either way that point does
+      not split this tick. So splitting is suppressed exactly where the carrier
+      density is high, which by <V>g</V> ∝ <V>n</V> is where the field is strong.
     </Note>
 
-    <Rows of={[
-      [<span style={{ color: DERIVED }}><V>g</V><Sub>c</Sub> = 1.2·10<Sup>−10</Sup> m/s²</span>,
-        <>shape <b style={{ color: INK }}>1.0%</b>, slope 3.43. The best shape any
-          mechanism in this file has managed — and that <V>g</V><Sub>c</Sub> is{' '}
-          <V>a</V><Sub>0</Sub>.</>],
-      [<span style={{ color: FAINT }}>either side of it</span>,
-        <>1.0·10<Sup>−10</Sup> gives 2.5%, 1.5·10<Sup>−10</Sup> gives 4.8% — so
-          the fit is real but not sharp.</>],
-    ]} />
-
-    <Note>
-      So the three routes, honestly: the caught pair alone gives 3.2% and 2.51,
-      and owes a density that kills gravity at 5·10<Sup>−32</Sup> m. The source
-      feedback is <b style={{ color: BORROWED }}>retired</b>. And the transport
-      route gives <b style={{ color: INK }}>1.0% and 3.43</b>, owing{' '}
-      <i>one number</i>: <V>n</V><Sub>c</Sub> = (<V>m</V>/2π)<Sup>3</Sup> wants
-      an emitter at <b style={{ color: INK }}>28.9 MeV</b>, where the electron
-      gives 5.5·10<Sup>−6</Sup> of what is needed and the proton
-      3.4·10<Sup>4</Sup>.
-    </Note>
+    <Eq open={show} note="occupancy θ = g/a₀, free fraction 1/(1+θ), and it closes">
+      <V>g</V> = <V>g</V><Sub>N</Sub>·(1 + <V>a</V><Sub>0</Sub>/<V>g</V>)
+      <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+      <V>g</V> = <Frac over={<><V>g</V><Sub>N</Sub></>} under={<>2</>} /> + √(
+      <Frac over={<><V>g</V><Sub>N</Sub><Sup>2</Sup></>} under={<>4</>} /> +{' '}
+      <V>g</V><Sub>N</Sub><V>a</V><Sub>0</Sub>)
+    </Eq>
 
     <Note>
-      <b style={{ color: INK }}>The transport route is the one to back.</b> It is
-      the only one whose sign is derived rather than asserted, it needs no new
-      rule — <K>inStep</K> was already derived and measured — it gives both halves
-      from one mechanism, and its single bill is a number rather than a
-      structure. Either something sits near 29 MeV, or the Compton wavelength
-      that matters belongs to the <i>carrier</i> and not to the source. That is
-      one question, it is about <code>physics.ts</code>, and the whole dark-matter
-      thread now hangs off it.{' '}
-      <b style={{ color: INK }}>And it was the wrong question.</b>
+      Over six decades <V>g</V>/<V>g</V><Sub>N</Sub> runs 31.7, 10.5, 3.70, 1.62,
+      1.10, 1.010, 1.0010 against a deep limit
+      √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>) of 31.6, 10.0, 3.16 — agreeing
+      where they should and parting where they should.{' '}
+      <b style={{ color: INK }}>The μ-function stops being borrowed
+        phenomenology</b>, and <V>a</V><Sub>0</Sub> becomes a <i>local
+        threshold</i> rather than anything cosmological — the blocking is a
+      function of the field at the point and nothing else.
     </Note>
 
-    <Head>test I — the scale comes from the expansion</Head>
+    <Head>and the scale is not fitted either</Head>
 
     <Note>
-      The 29 MeV bill came from setting <V>n</V><Sub>c</Sub> by a{' '}
-      <i>constituent’s</i> Compton wavelength — looking for the scale in the
-      wrong place, and the whole model says so.{' '}
-      <b style={{ color: INK }}>Space being made is the mechanism.</b> Making
-      space has a rate, that rate is <V>H</V>, and an acceleration built out of
-      it is <V>cH</V>. The frontier already forces{' '}
-      <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> exactly, so <V>cH</V><Sub>0</Sub>{' '}
-      is a <i>count of ticks</i> rather than a constant anyone chose. And the 2π
-      is <K>inStep</K>’s own, since in step means within 2π of phase.
+      What sets the threshold is the thing the model is <i>about</i>: space being
+      made. Making space has a rate, that rate is <V>H</V>, an acceleration built
+      from it is <V>cH</V>, and the frontier construction already forces{' '}
+      <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> exactly — so{' '}
+      <V>cH</V><Sub>0</Sub> is a count of ticks and not a constant anyone chose.
+      The 2π is <K>inStep</K>’s own.
     </Note>
 
-    <Eq open={show} note="the acceleration scale, from the expansion alone">
+    <Eq open={show} note="the acceleration scale, with nothing fitted in it">
       <V>a</V><Sub>0</Sub> = <Frac over={<><V>c</V> <V>H</V><Sub>0</Sub></>} under={<>2π</>} />
+      <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+      1.096·10<Sup>−10</Sup> m/s²
+      <span style={{ padding: '0 1.2em', color: FAINT }}>vs</span>
+      1.200·10<Sup>−10</Sup> measured
     </Eq>
 
-    <Rows of={[
-      [<span style={{ color: DERIVED }}>the prediction</span>,
-        <>1.041·10<Sup>−10</Sup> at <V>H</V><Sub>0</Sub> = 67.4,{' '}
-          <b style={{ color: INK }}>1.096·10<Sup>−10</Sup></b> at 70.9,
-          1.129·10<Sup>−10</Sup> at 73.0 — against a measured
-          1.200·10<Sup>−10</Sup>. <b style={{ color: INK }}>Nine percent, with
-            nothing fitted anywhere.</b></>],
-      [<span style={{ color: DERIVED }}>and on the galaxy</span>,
-        <>Run with the predicted value and no fitting of any kind:{' '}
-          <b style={{ color: INK }}>1.1% on the Milky Way’s rotation curve</b>,
-          Tully–Fisher slope 3.42. Radius by radius, 0.977 · 0.997 · 0.999 ·
-          0.995 · 0.987 · 0.987 · 1.002 · 1.028 from 6 to 30 kpc, where Newton
-          runs 0.83 down to 0.54.</>],
-    ]} />
-
-    <Note>
-      <b style={{ color: INK }}>Which retires the 29 MeV bill entirely.</b> It
-      was the price of assuming the coherence scale belonged to a constituent. It
-      belongs to the expansion — which this model has its own account of — and
-      the two numbers agree to nine percent without either being adjusted to meet
-      the other.
-    </Note>
-
     <Note>
-      <b style={{ color: INK }}>And this is where the frontier cosmology earns
-        its keep.</b> <V>a</V><Sub>0</Sub> ≈ <V>c</V>/(2π<V>t</V><Sub>0</Sub>) is
-      a known coincidence and an embarrassment everywhere else — why should a
-      galaxy know the age of the universe? Here{' '}
-      <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> is not a coincidence but the
-      construction, so the galaxy is not being told the age. It is being told the
-      rate at which space is made, which is the same number because the frontier
-      makes it so. <b style={{ color: INK }}>The cosmology and the rotation
-        curves are the same fact.</b>
+      <b style={{ color: INK }}>Nine percent, with nothing fitted anywhere.</b>{' '}
+      And it explains a coincidence that is an embarrassment everywhere else —
+      why should a galaxy know the age of the universe? Here{' '}
+      <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> <i>is</i> the construction,
+      so the galaxy is not being told the age; it is being told the rate at which
+      space is made, which is the same number because the frontier makes it so.{' '}
+      <b style={{ color: INK }}>The cosmology and the rotation curves become the
+        same fact.</b>
     </Note>
 
-    <Note>
-      And it predicts something MOND cannot, which is the point of having a
-      reason. <V>a</V><Sub>0</Sub> = <V>c</V>/(2π<V>t</V>) is{' '}
-      <i>not a constant</i> — it falls as the universe ages:
-      2.19·10<Sup>−10</Sup> at <V>z</V> = 1, 3.29·10<Sup>−10</Sup> at{' '}
-      <V>z</V> = 2, 5.48·10<Sup>−10</Sup> at <V>z</V> = 4. MOND has no reason for{' '}
-      <V>a</V><Sub>0</Sub> to depend on anything and treats it as a constant of
-      nature. <b style={{ color: INK }}>This route makes it a clock reading</b>,
-      so high-redshift rotation curves are a direct test.
-    </Note>
-
-    <Note>
-      <b style={{ color: BORROWED }}>And the first look at that test is not
-        comfortable.</b> Genzel et al. (2017) find massive discs at{' '}
-      <V>z</V> ≈ 2 with <i>declining</i> outer rotation curves — baryon-dominated,
-      less of a dark-matter effect, not more. A larger{' '}
-      <V>a</V><Sub>0</Sub> pushes more of a galaxy into the deep regime and
-      predicts a <i>larger</i> one. The two pull opposite ways. Not immediately
-      contradictory, since high-<V>z</V> discs are denser and{' '}
-      <V>g</V><Sub>N</Sub> rises too and what matters is the ratio — but the sign
-      of the tension is the wrong one, and it has not been worked out here.
-    </Note>
-
-    <Rows of={[
-      [<span style={{ color: BORROWED }}>the one link</span>,
-        <>Unchanged since it was first written down: that a carrier’s update cost
-          goes as its accumulated phase. Everything in the transport route rests
-          on it, and it is a <code>physics.ts</code> question about what a tick
-          is spent on.</>],
-      [<span style={{ color: BORROWED }}>the 2π</span>,
-        <>Taken from <K>inStep</K> by analogy rather than derived for this use. It
-          is the difference between 9% and 43%, so it is load-bearing.</>],
-    ]} />
-
-    <Note>
-      But the shape of the result is new for this file:{' '}
-      <b style={{ color: INK }}>a rotation curve fitted to one percent by a
-        number the model computes from its own cosmology</b>, with a dated
-      prediction attached that distinguishes it from the phenomenology it
-      reproduces. Nothing else in the dark-matter thread has been in that
-      position.
-    </Note>
-
-    <Head>test J — the polarity is a coin</Head>
+    <Head>and run on the galaxy, with nothing fitted</Head>
 
     <Note>
-      Test A’s √<V>N</V> came from <i>phase</i> cancellation, which needs{' '}
-      <V>m</V>·<V>R</V> ≫ 2π, hence an emitter mass, hence the 29 MeV bill. But{' '}
-      <b style={{ color: INK }}>the model never gives a wave a definite
-        polarity</b>. A neutral point becomes a ± pair and nothing decides which
-      half goes which way — the attribution is a fair coin, and the expansion
-      that made the point has no polarity to hand it. A fair coin gives{' '}
-      √<V>N</V> by itself, at every scale, with no coherence anywhere.
+      The Milky Way, summed over its real baryons with that predicted{' '}
+      <V>a</V><Sub>0</Sub>: <b style={{ color: INK }}>1.1% rms from 6 to 30
+        kpc</b>, and a Tully–Fisher slope of 3.42 against 3.85 ± 0.09 — inside
+      the ±0.4 that the assumed size–mass relation moves it by. Radius by radius
+      the ratio to Gaia runs 0.977 · 0.997 · 0.999 · 0.995 · 0.987 · 0.987 ·
+      1.002 · 1.028, where Newton alone runs 0.83 down to 0.54.
     </Note>
 
     <Note>
-      Measured over an ensemble of forty realisations, since the imbalance is a
-      random variable and one draw says nothing:{' '}
-      <b style={{ color: INK }}>rms(net)/√total is flat</b> — 0.064, 0.097,
-      0.077, 0.141 across a sixty-fourfold range in <V>N</V> — and it does not
-      depend on the body’s size either, 0.065 · 0.061 · 0.075 at radii 5, 10 and
-      16, where the phase route varied by orders across the same span. The ±
-      imbalance is exactly the fair-coin fluctuation on the arrivals and cares
-      about nothing else.
+      Which is worth seeing rather than reading, since a curve hides what a curve
+      means. The same four spokes as before, sheared by each law — and the
+      transport route is drawn on the rotation panel further up, sitting on the
+      measured line.
     </Note>
 
-    <Note>
-      <b style={{ color: INK }}>Which confirms Test I from the other
-        direction.</b> Test I removed the 29 MeV bill by finding the scale in the
-      expansion; this removes the <i>reason</i> anyone looked for a Compton
-      wavelength at all — there was never a coherence condition to satisfy. Two
-      independent routes to the same conclusion: no emitter mass enters the
-      dark-matter account anywhere.
-    </Note>
+    <Head>the sharpest test, and it nearly failed</Head>
 
     <Note>
-      <b style={{ color: BORROWED }}>But a fluctuation has no sign.</b> It cannot
-      be the source of a systematic attraction, and if gravity coupled to it at
-      every scale the solar system would be gone — the Sun’s 10<Sup>57</Sup>{' '}
-      emitters would act as 10<Sup>28.5</Sup>. So this is not an alternative to
-      the transport route; it is the removal of an objection to it. The
-      systematic pull stays with the count, and the √<V>M</V> stays in the
-      transport, where flux conservation goes quadratic.
+      A first reading made <V>a</V><Sub>0</Sub> a <i>clock reading</i> —{' '}
+      <V>c</V>/(2π<V>t</V>), so three times larger at <V>z</V> = 2 — which is a
+      dated, falsifiable prediction that MOND cannot make. Genzel et al. (2017)
+      measure six massive discs at <V>z</V> = 0.85–2.24 with{' '}
+      <i>declining</i> outer curves, <V>f</V><Sub>DM</Sub>(&lt;<V>R</V><Sub>e</Sub>)
+      &lt; 0.2, i.e. a boost under about 1.12. That reading predicts 1.179,
+      1.170, 1.164, 1.239 — <b style={{ color: INK }}>four of five over the
+        line</b>, and refuses it.
     </Note>
 
-    <Head>test K — and the high-redshift discs refuse it</Head>
+    <HighZDiscs />
 
     <Note>
-      The worry above is now measured rather than left standing. Genzel’s six
-      discs, their masses and sizes put through the transport route inside one
-      effective radius, against the <V>f</V><Sub>DM</Sub> &lt; 0.2 they measure —
-      which is a boost under about 1.12:
+      <b style={{ color: INK }}>The blocking makes <V>a</V><Sub>0</Sub> local,
+        not cosmological</b>, so it does not move with redshift — there is
+      nothing in it that could. That removes the <i>refutation</i>. It does not
+      make the discs agree, and an earlier version of this section said it did,
+      on a calculation that was wrong.
     </Note>
 
     <HighRedshift />
 
-    <Rows of={[
-      [<span style={{ color: BORROWED }}>four of five are over the line</span>,
-        <>With <V>a</V><Sub>0</Sub> ∝ 1/<V>t</V>: 1.179, 1.170, 1.164, 1.239
-          against an allowed 1.12. With <V>a</V><Sub>0</Sub> fixed, none is —
-          ordinary MOND is marginal here and survives, and{' '}
-          <b style={{ color: INK }}>the model’s own time-dependence does
-            not</b>.</>],
-      [<span style={{ color: BORROWED }}>out by a factor of three</span>,
-        <>Inverted: the largest <V>a</V><Sub>0</Sub> these galaxies permit is
-          1.09× today’s, i.e. <V>z</V> &lt; 0.09. The coasting cosmology wants{' '}
-          <b style={{ color: INK }}>3.20×</b> at <V>z</V> = 2.2.</>],
-      [<span style={{ color: FAINT }}>and the one that passes</span>,
-        <>zC_400569, because it is compact — 3.3 kpc at 2·10<Sup>11</Sup> M☉, so
-          its own <V>g</V><Sub>N</Sub> is 6.2 <V>a</V><Sub>0</Sub> and it is
-          Newtonian either way. The discs that refuse the prediction are the
-          extended ones.</>],
-    ]} />
-
-    <Note>
-      <b style={{ color: INK }}>So the one thing that dated the model is the one
-        thing the data refuses.</b> Which is the right way round for a prediction
-      to fail: it was specific, derived rather than fitted, and refutable by
-      measurements that already existed. What it costs is exactly the part of
-      Test I that made <V>a</V><Sub>0</Sub> a clock reading.{' '}
-      <b style={{ color: INK }}>What survives is the value</b> —{' '}
-      <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π at the present epoch is
-      still 9% from the measured number with nothing fitted, and still fits the
-      Milky Way to 1.1%.
-    </Note>
-
-    <Note>
-      And what would have to be true for it to live:{' '}
-      <V>a</V><Sub>0</Sub> would have to track something <i>local</i>, and that
-      quantity would have to stay roughly constant over
-      0 &lt; <V>z</V> &lt; 2.2 while 1/<V>t</V> trebles.{' '}
-      <b style={{ color: INK }}>Which is exactly what the next section finds</b>,
-      so the version of this paragraph that said the model had no such quantity
-      was wrong. It has one.
-    </Note>
-
-    <Head>test L — the bulk makes no space, but it makes gravity</Head>
-
-    <Note>
-      The frontier construction forbids the bulk from <i>creating</i> space. It
-      says nothing about the bulk <i>coupling</i> — and the caught pair is
-      exactly that: a pull mediated by the vacuum between two bodies, whose
-      strength goes with how much vacuum there is to mediate it.{' '}
-      <b style={{ color: INK }}>More empty space between two things, more
-        pull.</b> That is local, and it is the thing the last test said the model
-      did not have.
-    </Note>
-
-    <Note>
-      <b style={{ color: BORROWED }}>First the version that fails</b>, because it
-      is instructive. Read the emptiness as the local baryon <i>density</i>,{' '}
-      <V>a</V><Sub>0</Sub>·(<V>ρ</V><Sub>ref</Sub>/<V>ρ</V>)<Sup>s</Sup>: at{' '}
-      <V>s</V> = 0 the Milky Way fits to 1.1% and the worst Genzel boost is
-      1.239; at <V>s</V> = 1 the boost falls to 1.107 but the Milky Way is out
-      by 77%. <b style={{ color: INK }}>No value of <V>s</V> does both</b> —
-      because <V>ρ</V> varies by fifty <i>within</i> one galaxy, so a rule keyed
-      to it cannot tell between-galaxies from within-a-galaxy.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>And that points straight at the fix: the space
-        between two bodies is a length, not a volume.</b> It is measured along
-      the line joining them, so what counts is the mean <i>spacing</i>,{' '}
-      <V>ρ</V><Sup>−1/3</Sup>, not the density. And then both factors are fixed
-      by the epoch alone — <V>H</V> ∝ (1+<V>z</V>) from the frontier’s own{' '}
-      <V>H</V> = 1/<V>t</V>, and spacing ∝ (1+<V>z</V>)<Sup>−1</Sup> since{' '}
-      <V>ρ</V> ∝ (1+<V>z</V>)<Sup>3</Sup>.
-    </Note>
-
-    <Eq open={show} note="and the two factors cancel, identically">
-      <V>a</V><Sub>0</Sub> = <Frac over={<><V>c</V> <V>H</V></>} under={<>2π</>} />
-      <span style={{ padding: '0 0.6em' }}>·</span>
-      <Frac over={<>spacing</>} under={<>spacing<Sub>0</Sub></>} />
-      <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
-      <Frac over={<><V>c</V> <V>H</V><Sub>0</Sub></>} under={<>2π</>} />
-    </Eq>
+    <Head>and then the discs were drawn, which broke it</Head>
 
     <Note>
-      Not approximately — <i>identically</i>. <V>a</V><Sub>0</Sub>(<V>z</V>)/<V>a</V><Sub>0</Sub>(0)
-      is 1.0000 at <V>z</V> = 0.5, 1, 1.5, 2, 2.5 and 4, because the clock speeds
-      up by precisely the factor the spacing shrinks by. So{' '}
-      <b style={{ color: INK }}>a₀ is constant in redshift and still equal to{' '}
-        <V>cH</V><Sub>0</Sub>/2π</b>: the 9% value survives, the Milky Way stays
-      at 1.1%, and the Genzel boosts fall back to 1.112, 1.083, 1.077, 1.101,
-      1.019 — <b style={{ color: INK }}>every one under the allowed 1.12</b>.
+      The panel above is a boost factor against redshift, and a boost factor is
+      not something you can look at and judge. Drawn as <i>curves</i> — the way
+      the Milky Way is drawn, which is the only way the eye can check an
+      agreement — the disagreement is immediate:
     </Note>
 
-    <HighZDiscs />
+    <HighZCurves />
 
     <Note>
-      Which is what the refutation in Test K was really of:{' '}
-      <V>a</V><Sub>0</Sub> ∝ 1/<V>t</V> was the mechanism with half of it
-      dropped. “More empty space, more pull” was the idea; leaving the emptiness
-      out and keeping only the clock is what the data refused.
+      <b style={{ color: BORROWED }}>Four of the five overshoot, and the earlier
+        pass was an artefact.</b> That calculation took{' '}
+      <V>g</V><Sub>N</Sub> = <V>GM</V>/<V>R</V><Sub>e</Sub><Sup>2</Sup> — a{' '}
+      <i>point mass</i>. These are discs, and at one effective radius a disc has
+      enclosed about half its mass, so its real{' '}
+      <V>g</V><Sub>N</Sub> is roughly half that. A smaller{' '}
+      <V>g</V><Sub>N</Sub> sits deeper in the boosted regime and gives a{' '}
+      <i>larger</i> boost, so the shortcut was generous in exactly the direction
+      that made the model pass.
     </Note>
 
     <Rows of={[
-      [<span style={{ color: DERIVED }}>what is gained</span>,
-        <>The 9% value survives, the Milky Way fit survives, and the
-          high-<V>z</V> discs stop refusing it.</>],
-      [<span style={{ color: BORROWED }}>and what is lost</span>,
-        <><b style={{ color: INK }}>The dated prediction.</b>{' '}
-          <V>a</V><Sub>0</Sub> constant is what MOND already assumes, so the model
-          no longer says anything about redshift that MOND does not. The thing
-          that made it refutable is the thing that had to go for it to survive —
-          an honest trade and not a good one, and it should be read as the model
-          becoming <i>harder to test</i> rather than as it becoming more
-          right.</>],
+      [<span style={{ color: BORROWED }}>done properly</span>,
+        <>1.177, 1.134, 1.125, 1.161 and 1.034 against a ceiling of 1.118 —{' '}
+          <b style={{ color: INK }}>four over</b>, where the shortcut gave 1.112,
+          1.083, 1.077, 1.101, 1.019 and none.</>],
+      [<span style={{ color: BORROWED }}>what it would take</span>,
+        <>The binding disc allows <V>a</V><Sub>0</Sub> &lt; 6.6·10<Sup>−11</Sup>,
+          which is <b style={{ color: INK }}>0.60× the prediction</b>. The
+          anisotropy supplies 0.765× and is still 1.27× over. Nothing in this
+          file offers the rest.</>],
+      [<span style={{ color: FAINT }}>and it is not this model alone</span>,
+        <>The measured <V>a</V><Sub>0</Sub> of 1.20·10<Sup>−10</Sup> is 1.8×
+          the ceiling, so <i>ordinary MOND overshoots these discs too</i>, and by
+          more. This is a known tension in that literature rather than something
+          peculiar here — but it is not a defence, because the model was claiming
+          to do better and does not.</>],
     ]} />
 
     <Note>
-      What is still owed is unchanged and it is one thing:{' '}
-      <b style={{ color: INK }}>that a carrier’s update cost goes as its
-        accumulated phase</b>. Everything in the transport route rests on it. It
-      is a <code>physics.ts</code> question about what a tick is spent on, and it
-      has been owed since the mechanism was first written down —{' '}
-      <b style={{ color: INK }}>and the next section pays part of it.</b>
-    </Note>
-
-    <Head>test M — the carriers already there block the splitting</Head>
-
-    <Note>
-      Every test above wrote the turnover as{' '}
-      <V>g</V> = <V>g</V><Sub>N</Sub>/2 + √(<V>g</V><Sub>N</Sub><Sup>2</Sup>/4 +{' '}
-      <V>g</V><Sub>N</Sub><V>a</V><Sub>0</Sub>) and called it “the simple
-      interpolation, same algebra as MOND’s”. <b style={{ color: INK }}>It was
-        assumed.</b> Here is where it comes from, and it is already in the rules:
-      a neutral point becomes a ± pair, but{' '}
-      <b style={{ color: INK }}>a point that already has a carrier on it is
-        busy</b> — <K>through</K> says an arriving charge annihilates or
-      reverses, and either way that point does not split this tick. So splitting
-      is suppressed exactly where the carrier density is high, which by{' '}
-      <V>g</V> ∝ <V>n</V> is exactly where the field is strong.
-    </Note>
-
-    <Eq open={show} note="occupancy θ = g/a₀, free fraction 1/(1+θ), and it closes">
-      <V>g</V> = <V>g</V><Sub>N</Sub>·(1 + <V>a</V><Sub>0</Sub>/<V>g</V>)
-      <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
-      <V>g</V> = <Frac over={<><V>g</V><Sub>N</Sub></>} under={<>2</>} /> + √(
-      <Frac over={<><V>g</V><Sub>N</Sub><Sup>2</Sup></>} under={<>4</>} /> +{' '}
-      <V>g</V><Sub>N</Sub><V>a</V><Sub>0</Sub>)
-    </Eq>
-
-    <Note>
-      <b style={{ color: INK }}>Which is the function, derived.</b> Over six
-      decades <V>g</V>/<V>g</V><Sub>N</Sub> runs 31.7, 10.5, 3.70, 1.62, 1.10,
-      1.010, 1.0010 against a deep limit √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>)
-      of 31.6, 10.0, 3.16 — agreeing where they should and parting where they
-      should. The μ-function stops being borrowed phenomenology.
+      <b style={{ color: INK }}>But “overshoots four of five” is an adjective,
+        not a measurement</b>, and it is the wrong unit. It says how many crossed
+      a line and nothing about by how far, or about what the alternative does on
+      the same data. Both matter, because a theory is judged against the other
+      theory rather than against a line.
     </Note>
 
     <Note>
-      And it makes <V>a</V><Sub>0</Sub> a <b style={{ color: INK }}>local
-        threshold rather than a clock reading</b>, which is what Test K needed
-      and Test L had to buy with a cosmological cancellation. The blocking is a
-      function of the field at the point and nothing else, so it cannot move with
-      redshift — there is nothing in it that could.
+      And <V>f</V><Sub>DM</Sub> &lt; 0.2 is an <i>upper limit</i>, so the true
+      boost lies somewhere in 1.000…1.118.{' '}
+      <b style={{ color: INK }}>Newton sits at the bottom of that band by
+        construction and the model sits just above the top of it</b>, and which
+      is closer depends where in the band the truth is:
     </Note>
 
     <Rows of={[
-      [<span style={{ color: DERIVED }}><V>cH</V><Sub>0</Sub>/2π, isotropic</span>,
-        <>1.10·10<Sup>−10</Sup> — Milky Way <b style={{ color: INK }}>1.1%</b>,
-          worst Genzel boost <b style={{ color: INK }}>1.112</b>.{' '}
-          <b style={{ color: INK }}>All five pass.</b></>],
-      [<span style={{ color: FAINT }}>cone shut at cos θ &gt; 0.5</span>,
-        <>8.38·10<Sup>−11</Sup> — Milky Way 5.2%, worst boost 1.090. Still
-          passes, but the fit is going.</>],
-      [<span style={{ color: BORROWED }}>the <i>measured</i> <V>a</V><Sub>0</Sub></span>,
-        <>1.20·10<Sup>−10</Sup> — Milky Way 1.0%, worst boost{' '}
-          <b style={{ color: INK }}>1.120</b>, which <i>fails</i> by a hair.
-          Worth staring at: the model’s own smaller prediction passes where the
-          measured value does not, so the 9% it is “wrong” by is in the direction
-          the high-<V>z</V> data prefer.</>],
+      [<span style={{ color: FAINT }}>if <V>f</V><Sub>DM</Sub> = 0</span>,
+        <>Newton exact, the model 13.3% high. Newton wins.</>],
+      [<span style={{ color: FAINT }}>if <V>f</V><Sub>DM</Sub> = 0.10</span>,
+        <>Newton 5.1% low, the model 8.1% high. Close to even.</>],
+      [<span style={{ color: DERIVED }}>if <V>f</V><Sub>DM</Sub> = 0.20</span>,
+        <>Newton <b style={{ color: INK }}>10.6% low</b>, the model{' '}
+          <b style={{ color: INK }}>4.4% high</b>. The model wins.</>],
     ]} />
 
     <Note>
-      <b style={{ color: INK }}>And then the direction, which is the part nobody
-        had asked.</b> A carrier streaming along <V>ĝ</V> occupies the cell in
-      that direction; the point has <K>WAYS</K> exits and only the occupied ones
-      are shut, so the pair goes out with the field direction <i>removed</i>.
-      That is an anisotropic source, and it costs a projection: ⟨|<V>ĉ</V>·<V>r̂</V>|⟩
-      falls from 0.4721 isotropic to 0.4510 with a narrow cone shut and 0.3610
-      with a wide one.
-    </Note>
-
-    <Note>
-      <b style={{ color: BORROWED }}>Shutting the forward cone reduces the radial
-        projection.</b> The surviving pairs carry <i>less</i> flux outward, not
-      more — so the anisotropy weakens the vacuum channel, and most where the
-      field is strong, which is the same direction the blocking already pushes.
-      The two compound rather than fight, which is why the shape of the
-      interpolation survives both: they are functions of the same occupancy, so
-      they can only move the <i>scale</i>.
+      <b style={{ color: INK }}>So on the Milky Way the model is thirty times
+        closer than Newton</b> — 1.1% rms against 32.5%, worst case 2.6% against
+      43.1% — and on the high-<V>z</V> discs the two are comparable, with which
+      one leads depending on a quantity that is quoted as a bound rather than a
+      value. The model’s <i>worst error anywhere</i> is a few percent, against
+      Newton’s factor of two.
     </Note>
 
     <Note>
-      And that is the one place it goes the wrong way. The projection multiplies{' '}
-      <V>a</V><Sub>0</Sub> by 0.955 or 0.765, and the measurement wants it 9%{' '}
-      <i>larger</i>. <b style={{ color: INK }}>So the anisotropy widens the gap it
-        was hoped to close.</b> Not fatal — the gap is still under a factor of
-      1.5 in a quantity nothing was fitted to — but it is the opposite of the
-      hoped-for result, and the cone cannot be shut far before the Milky Way fit
-      goes.
+      Which is the honest summary, and it is a different sentence from the one
+      above it. <b style={{ color: INK }}>The high-<V>z</V> discs are a real
+        tension and not a refutation</b>: a few percent high in a regime where
+      the measurement is an upper limit, in a theory that is thirty times better
+      than the alternative where the measurement is a value. Worth chasing,
+      because the direction is consistent across four galaxies and because the
+      surviving derivation of <V>a</V><Sub>0</Sub> happens to want it smaller —
+      but not worth calling a failure.
     </Note>
 
     <Note>
-      So what this buys, precisely:{' '}
-      <b style={{ color: INK }}>the interpolation function, derived from{' '}
-        <K>through</K> rather than borrowed</b>; <V>a</V><Sub>0</Sub> as a local
-      threshold, which settles the high-<V>z</V> discs without the cosmological
-      cancellation — so Test L is no longer load-bearing, though it survives as a
-      consistency check; and a bound on the anisotropy, since the cone cannot be
-      shut past about cos θ = 0.5. What it does <i>not</i> buy is the one link:
-      “the carrier density suppresses the splitting” is <K>through</K> and is
-      already in the file, but “the update cost goes as the accumulated phase”,
-      which is what makes the <i>drift</i> fall with density, is still owed.
+      <b style={{ color: BORROWED }}>What that costs is the dated prediction.</b>{' '}
+      An <V>a</V><Sub>0</Sub> that does not move with redshift is what MOND
+      already assumes, so the model no longer says anything about <V>z</V> that
+      MOND does not. The thing that made it refutable is the thing that had to go
+      for it to survive — an honest trade and not a good one, and it should be
+      read as the model becoming <i>harder to test</i>.
     </Note>
 
-    <Head>and speed is a budget, not a constant</Head>
+    <Head>and the expansion is no longer a sphere</Head>
 
     <Note>
-      “Everything moves at <V>c</V>” was quoting half the file at the other
-      half. It rejects <i>idling</i> for massive particles — moving on a
-      fraction <V>β</V> of ticks gives (1−<V>β</V>) where relativity wants
-      √((1−<V>β</V>)(1+<V>β</V>)), and picks a frame. But the{' '}
-      <i>zigzag</i> says a thing steps <i>every</i> tick and its net speed is the
-      imbalance, and that <b style={{ color: INK }}>the updates <i>are</i> the
-        reversals</b>. A net drift below <V>c</V> is not forbidden; it is this
-      model’s own account of what speed is.
+      If a carrier streaming along <V>ĝ</V> occupies the cell in that direction,
+      then the split cannot go that way — the pair is emitted with the field
+      direction <i>removed</i>, and the space made around a mass is not
+      spherical. Which raises the obvious worry:{' '}
+      <b style={{ color: INK }}>an anisotropy that varies with radius would
+        change the shape and not just the scale</b>, and the curve above assumed
+      it does not.
     </Note>
 
     <Note>
-      And that reopens everything, because flux conservation reads{' '}
-      <V>Φ</V> = 4π<V>r</V><Sup>2</Sup><V>nv</V>. With <V>v</V> constant,{' '}
-      <V>n</V> ∝ 1/<V>r</V><Sup>2</Sup> and no wandering changes it — which is
-      what the last test showed. With <V>v</V> varying, what is needed is simply{' '}
-      <V>v</V> ∝ 1/<V>r</V>. And the model has a reason for the drift to depend
-      on density, out of pieces already here: speed is the share of ticks spent
-      moving rather than updating; a carrier accumulates phase while travelling
-      free; <i>through</i> says a meeting resets it; so the accumulated state ∝
-      the distance since the last meeting, 1/<V>σn</V>, and the moving share ∝{' '}
-      <V>σn</V>.
+      <b style={{ color: INK }}>It does not, and the lattice is why.</b> The 26
+      exits from a cell have only three distinct direction cosines — 1 for the
+      six faces, 1/√2 for the twelve edges, 1/√3 for the eight corners. So the
+      projection ⟨|<V>ĉ</V>·<V>r̂</V>|⟩ is a <i>step</i> function of how far the
+      cone is shut, with four values: 0.4721, 0.4510, 0.4022, 0.3610. A galaxy
+      spans <V>g</V>/<V>a</V><Sub>0</Sub> from 0.34 at 30 kpc to 4.84 at 2 kpc
+      and <b style={{ color: INK }}>never crosses a step</b> — the projection is
+      one number across the whole disc.
     </Note>
 
-    <Eq derive={REACH} open={show}
-      note="dense and the budget caps at c; thin and the carrier crawls">
-      <V>v</V> = <V>c</V>·min(1, <V>n</V>/<V>n</V><Sub>c</Sub>)
-    </Eq>
-
-    <Rows of={[
-      [<span style={{ color: DERIVED }}>dense, <V>n</V> &gt; <V>n</V><Sub>c</Sub></span>,
-        <><V>v</V> = <V>c</V>, so <V>n</V> = <V>Φ</V>/4π<V>r</V><Sup>2</Sup><V>c</V>{' '}
-          ∝ 1/<V>r</V><Sup>2</Sup> — <b style={{ color: INK }}>Newton</b></>],
-      [<span style={{ color: DERIVED }}>thin, <V>n</V> &lt; <V>n</V><Sub>c</Sub></span>,
-        <><V>v</V> = <V>cn</V>/<V>n</V><Sub>c</Sub>, so flux conservation goes{' '}
-          <i>quadratic</i>: <V>n</V> = √(<V>Φn</V><Sub>c</Sub>/4π<V>c</V>)/<V>r</V>{' '}
-          ∝ 1/<V>r</V> — <b style={{ color: INK }}>MOND</b></>],
-      [<span style={{ color: DERIVED }}>and the mass comes free</span>,
-        <>In the thin branch <V>n</V> ∝ √<V>Φ</V> and <V>Φ</V> ∝ <V>M</V>, so{' '}
-          <V>g</V> ∝ √<V>M</V>/<V>r</V> and{' '}
-          <b style={{ color: INK }}><V>v</V><Sub>rot</Sub><Sup>4</Sup> ∝ <V>M</V></b>.
-          Both halves from one mechanism — and the √<V>M</V> is not the phase
-          cancellation at all. It falls out because the flux equation becomes
-          quadratic in <V>n</V> once the speed is proportional to <V>n</V>.</>],
-    ]} />
-
     <Note>
-      <b style={{ color: INK }}>That is the non-linearity the theorem
-        demanded</b>, and it lives in the <i>transport</i> rather than in the
-      source — which is why every earlier attempt to put it in the source failed.
-      And the switch is at a <i>fixed occupancy</i>, hence fixed <V>g</V>, since{' '}
-      <V>g</V> ∝ <V>n</V>. Not a length, not a mass, not a count of
-      constituents. Every requirement the search accumulated, at once.
+      So the expansion around a galaxy is genuinely not a sphere, but it is not a
+      smoothly varying non-sphere either: it is <i>one of four discrete shapes</i>,
+      and a galaxy sits in one of them throughout.{' '}
+      <b style={{ color: INK }}>The shape of the rotation curve survives
+        exactly</b>, and the anisotropy can only rescale{' '}
+      <V>a</V><Sub>0</Sub> — by 0.955 or 0.765 depending on how far the cone is
+      shut.
     </Note>
 
     <Note>
-      Measured by integrating the transport rather than trusting the algebra:{' '}
-      <b style={{ color: INK }}>−2.0000 inside and −1.0000 outside</b>, and the
-      outer density against √<V>Φ</V> comes to 10.0000 for a hundredfold mass
-      against √100 = 10. Exact.
+      <b style={{ color: BORROWED }}>And that rescaling goes the wrong way.</b>{' '}
+      The measurement wants <V>a</V><Sub>0</Sub> 9% <i>larger</i> than the
+      prediction, and the projection makes it smaller — 1.8% and 5.2% on the
+      Milky Way against 1.1% isotropic. Not fatal, since the gap is still under a
+      factor of 1.5 in a quantity nothing was fitted to, but it is the opposite
+      of the hoped-for result, and it bounds the anisotropy: the cone cannot be
+      shut past about cos θ = 0.5 before the fit goes.
     </Note>
 
-    <Note>
-      <b style={{ color: INK }}>What it costs.</b> A carrier that crawls is a
-      carrier that is <i>late</i>. At 20 kpc the drift is 0.4<V>c</V> and a
-      galaxy’s crossing time goes from 98 to 244 kyr — harmless. Further out it
-      is not: at <V>n</V>/<V>n</V><Sub>c</Sub> = 10<Sup>−3</Sup> a cluster-scale
-      field takes 10<Sup>7</Sup> years to establish.{' '}
-      <b style={{ color: INK }}>Gravity should lag in the deep-field regime</b>,
-      and merging systems are where that would show. It is not relativity broken
-      — the carriers still step one cell a tick, and the density setting the
-      drift is a scalar, so nothing exceeds <V>c</V> and nothing picks a frame.
-    </Note>
+    <Head>and the two derivations of a₀ differ by a pure count</Head>
 
     <Note>
-      <b style={{ color: INK }}>And chasing that link turns up a sign conflict
-        in the chain above.</b> It used “a meeting <i>resets</i> the accumulated
-      state, so meetings free up ticks and the carrier moves faster”. But{' '}
-      <i>through</i> — the model’s own rule, and a measured one — says a charge
-      arriving at an occupied cell annihilates or <i>reverses</i>. A reversal
-      does not clear internal state; it turns the carrier round, which{' '}
-      <i>slows</i> the net drift. So <i>through</i> gives{' '}
-      <V>v</V> falling with <V>n</V> and the chain gives it rising, and{' '}
-      <V>v</V> ∝ <V>n</V> is exactly what the √<V>M</V> depends on.{' '}
-      <b style={{ color: INK }}>A real problem, not a detail</b> — and the sort
-      that would have gone unnoticed if the link had been left as an IOU.
+      There are <i>two</i> routes to <V>a</V><Sub>0</Sub> in this file and they
+      do not agree, which for a single coherent account is the thing to settle.
+      One counts <b style={{ color: INK }}>meetings over a carrier’s
+        lifetime</b> and gives 4π<V>G</V>/(<K>SHEET</K>·<V>t</V><Sub>0</Sub>) =
+      6.75·10<Sup>−11</Sup>. The other takes the{' '}
+      <b style={{ color: INK }}>rate space is made</b> and gives{' '}
+      <V>cH</V><Sub>0</Sub>/2π = 1.096·10<Sup>−10</Sup>. Measured is
+      1.200·10<Sup>−10</Sup>, so the first is short by 1.78 and the second by
+      1.095.
     </Note>
 
     <Note>
-      <b style={{ color: INK }}>But there is a connection with the right sign,
-        and it is already here: <i>inStep</i>.</b> It says emitters closer than
-      a Compton wavelength hold a common phase and further apart drift
-      independently. Read as a <i>budget</i> rather than an interference
-      condition: <b style={{ color: INK }}>in step</b>, one phase is shared
-      between many carriers, the update is paid <i>once</i>, and each is free to
-      spend its ticks moving — dense → fast. <b style={{ color: INK }}>Out of
-        step</b>, each carries its own phase and pays every tick — thin → slow.
-      Right sign, no new rule, and it does not fight <i>through</i>: reversals
-      still happen, but what sets the drift is what a tick is <i>spent on</i>,
-      not which way the step points.
+      <b style={{ color: INK }}>But they are not two guesses — they are the same
+        quantity differing by a lattice count</b>, and the count is exact:
     </Note>
 
-    <Eq derive={REACH} open={show}
-      note="a Compton wavelength is a fixed density — the shape the search demanded">
-      in step ⇔ spacing &lt; 2π/<V>m</V>
-      <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
-      <V>n</V><Sub>c</Sub> = (<V>m</V>/2π)<Sup>3</Sup>
+    <Eq open={show} note="the ratio between them, with nothing left over">
+      <Frac over={<><V>c</V><V>H</V><Sub>0</Sub>/2π</>}
+        under={<>4π<V>G</V>/(<K>SHEET</K><V>t</V><Sub>0</Sub>)</>} />
+      <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+      <Frac over={<><K>WAYS</K></>} under={<>2 <K>SHEET</K></>} />
+      <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+      <Frac over={<>13</>} under={<>8</>} />
+      <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+      1.6250
     </Eq>
 
-    <Rows of={[
-      [<span style={{ color: DERIVED }}>which fixes the emitter</span>,
-        <>The required <V>n</V><Sub>c</Sub> = 2.203·10<Sup>−61</Sup> per cell
-          gives <V>m</V> = 5.150·10<Sup>−29</Sup> kg ={' '}
-          <b style={{ color: INK }}>28.9 MeV/<V>c</V><Sup>2</Sup></b>.</>],
-      [<span style={{ color: BORROWED }}>and there is no such particle</span>,
-        <>The proton gives <V>n</V><Sub>c</Sub> 3.4·10<Sup>4</Sup> too dense, the
-          electron 5.5·10<Sup>−6</Sup> too thin. The muon at 106 MeV and the
-          pion at 135 are the nearest things and both are four to eight times
-          too heavy.</>],
-      [<span style={{ color: DERIVED }}>but three of four are fixed</span>,
-        <>The <i>sign</i>, the <i>crossover shape</i>, and{' '}
-          <i>no new rule needed</i> — all by something already derived and
-          measured in the file. Only the number is wrong, and it is wrong by a
-          stateable amount.</>],
-    ]} />
-
-    <Note>
-      <b style={{ color: INK }}>Which says exactly what to look for:</b> either
-      an emitter near 29 MeV, or a reason the relevant Compton wavelength is not
-      the constituent’s own. And there is an obvious place to look for the
-      second — <i>inStep</i> takes the mass of what is <i>emitting</i>. If the
-      phase that matters belongs to the <i>carrier</i> rather than the source,
-      then 29 MeV is a statement about the carrier — and this model has{' '}
-      <b style={{ color: INK }}>never assigned the carrier a mass at all</b>.
-      The pull is carried by charges whose own rate was never fixed, which makes
-      this a gap rather than a contradiction, and the first thing{' '}
-      <i>physics.ts</i> would have to answer.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>And a correction: the a₀ prediction was
-        over-retracted.</b> It was written off along with the 2D transport, but
-      it used only <V>g</V> ∝ <V>n</V> with the constant 4π<V>G</V>/<K>SHEET</K>{' '}
-      — the geometry of emission — and{' '}
-      <V>n</V><Sub>c</Sub> = 1/<V>t</V><Sub>0</Sub>, one meeting per carrier
-      lifetime. <i>Neither mentions the sheet.</i> The transport failed and the
-      prediction does not depend on it.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>So how do you derive it without data?</b>{' '}
-      Enumerate the inputs that exist at all — this is the whole list, and a
-      derivation can use nothing else: four counted numbers (<K>SHEET</K>,{' '}
-      <K>WAYS</K>, <K>BITE</K>, <K>GRAVITY</K>), two units (the cell and the
-      tick, fixed by the calibration), and one dynamical quantity,{' '}
-      <V>t</V><Sub>0</Sub> = 8.08·10<Sup>60</Sup> ticks. Then see which
-      combinations can reach the size at all.
-    </Note>
-
-    <Rows of={[
-      [<span style={{ color: FAINT }}>the ceiling — one emission a tick</span>,
-        <><V>n</V><Sub>c</Sub> = 1, which is 4.5·10<Sup>60</Sup> too dense</>],
-      [<span style={{ color: FAINT }}>the floor — one emission per age</span>,
-        <>7.6·10<Sup>−186</Sup>, which is 10<Sup>124</Sup> too thin</>],
-      [<span style={{ color: DERIVED }}>one <i>meeting</i> per carrier lifetime</span>,
-        <>1.24·10<Sup>−61</Sup> against the 2.20·10<Sup>−61</Sup> that{' '}
-          <V>a</V><Sub>0</Sub> requires —{' '}
-          <b style={{ color: INK }}>out by 1.78</b></>],
-    ]} />
-
-    <Note>
-      <b style={{ color: INK }}>Only one route lands</b>, and it is not a fit
-      surviving among many — it is the only candidate the available ingredients
-      can even build at the right size. A carrier crosses one cell a tick and
-      lives <V>t</V><Sub>0</Sub> ticks, sweeping <K>BITE</K> cells of
-      cross-section, so it meets <V>n</V>·<K>BITE</K>·<V>t</V><Sub>0</Sub>{' '}
-      others; the crossover is where that count is <i>one</i> — the boundary
-      between a carrier whose history contains an interaction and one whose does
-      not. So <V>n</V><Sub>c</Sub> = 1/<K>BITE</K><V>t</V><Sub>0</Sub>, and with{' '}
-      <V>g</V> = (4π<V>G</V>/<K>SHEET</K>)<V>n</V>,{' '}
-      <b style={{ color: INK }}><V>a</V><Sub>0</Sub> = 4π<V>G</V>/(<K>SHEET</K>·<V>t</V><Sub>0</Sub>)
-        = 6.74·10<Sup>−11</Sup></b> against 1.20·10<Sup>−10</Sup> measured. No{' '}
-      <V>a</V><Sub>0</Sub> anywhere in the derivation.
-    </Note>
-
     <Note>
-      <b style={{ color: INK }}>And it then predicts the carrier mass</b>, which
-      was the open number. <i>inStep</i> wants{' '}
-      <V>n</V><Sub>c</Sub> = (<V>m</V>/2π)<Sup>3</Sup>; setting the two equal
-      gives <V>m</V> = 2π(1/<V>t</V><Sub>0</Sub>)<Sup>⅓</Sup> ={' '}
-      <b style={{ color: INK }}>23.8 MeV/<V>c</V><Sup>2</Sup></b>, against the
-      28.9 MeV that <V>a</V><Sub>0</Sub> demands — a ratio of 1.212.{' '}
-      <b style={{ color: INK }}>Two independent routes to the same number,
-        agreeing to 21%.</b> One counts meetings over a lifetime, the other asks
-      when carriers fall out of step. They did not have to agree at all, and it
-      is the first time in this line of work that two derivations have met.
+      Because <K>CORE</K> = ½ makes 8π²<V>G</V>/<K>SHEET</K> come to exactly
+      2·<K>SHEET</K>/<K>WAYS</K>, to eight digits. So one of the two is
+      miscounting by 13/8 — a factor built from the number of exits from a cell
+      and the size of a sheet, and nothing else.{' '}
+      <b style={{ color: INK }}>That is a much better position than two rival
+        numbers</b>: the disagreement is not about physics, it is about which
+      count is the right one, and it is the kind of thing that can be settled by
+      going back through one derivation rather than by measuring anything.
+      The expansion route is the one carried above, because it is the one that
+      lands within 9%.
     </Note>
 
     <Note>
-      <b style={{ color: INK }}>The bills, and they are specific.</b> The{' '}
-      <i>1.78 is uncounted</i> — and it is the <i>same</i> 1.78 at every step, so
-      it is one missing factor rather than several; somewhere a 2, a π or a √π is
-      not being counted. <V>t</V><Sub>0</Sub> <i>is not a constant</i>, so{' '}
-      <V>a</V><Sub>0</Sub> ∝ 1/<V>t</V> and the carrier mass goes as{' '}
-      <V>t</V><Sup>−⅓</Sup> — a mass that changes with the age is a strange
-      object, and it is the same prediction already flagged, with high-redshift
-      curves going the wrong way. And <i>24 MeV is not a particle</i>: the muon
-      is 106 and the pion 135. Either something sits there, or the Compton
-      wavelength that matters is not a particle’s at all.
+      <b style={{ color: INK }}>And on further inspection the wrong one is the
+        one that fits.</b> They are not two versions of a single count — they are
+      two different criteria. The meeting route says “a carrier crosses{' '}
+      <K>BITE</K> cells a tick for <V>t</V><Sub>0</Sub> ticks and meets one
+      other”, which <i>is</i> the blocking threshold stated as a rate, and
+      blocking is the mechanism that survived. The expansion route’s 2π was
+      borrowed from <K>inStep</K> — a <i>coherence</i> condition, and the
+      polarity result retired coherence entirely.{' '}
+      <b style={{ color: INK }}>So the 2π is a leftover from a mechanism that no
+        longer exists</b>, and the principled derivation is the one that is low
+      by 1.78 rather than by 1.095.
     </Note>
 
     <Note>
-      <b style={{ color: INK }}>And the 1.78 is mostly countable — it was never
-        one number.</b> The count was “a carrier sweeps <K>BITE</K> cells a tick
-      for <V>t</V><Sub>0</Sub> ticks, so it meets{' '}
-      <V>n</V>·<K>BITE</K>·<V>t</V><Sub>0</Sub> others; set that to one”. Two
-      things in it were left at one and should not have been, and both are
-      already derived elsewhere in this file: <i>share</i> = ½, since only
-      opposite polarities annihilate and <i>opposed</i> pairs at random; and{' '}
-      ⟨|<V>v</V><Sub>rel</Sub>|⟩ = 4/3, since both things move at <V>c</V> and
-      the rate carries their <i>relative</i> speed — the same average that
-      corrected the screening geometry.
+      Which is uncomfortable and is recorded as such. √π is 0.35% from the
+      needed 1.7787 and 16/9 is 0.05%, and neither means anything without a
+      derivation — this file warns against exactly that kind of agreement
+      elsewhere and the warning applies here.{' '}
+      <b style={{ color: INK }}>The honest state is that a₀ is derived to a
+        factor of 1.78 with nothing fitted</b>, and that the 9% quoted above
+      belongs to a route whose constant is not yet earned.
     </Note>
 
-    <Rows of={[
-      [<span style={{ color: FAINT }}>nothing counted</span>,
-        <><V>a</V><Sub>0</Sub> = 6.74·10<Sup>−11</Sup> — 0.562 of measured</>],
-      [<span style={{ color: DERIVED }}><i>share</i> = ½</span>,
-        <>1.348·10<Sup>−10</Sup> — 1.124</>],
-      [<span style={{ color: FAINT }}>⟨|<V>v</V><Sub>rel</Sub>|⟩ = 4/3 alone</span>,
-        <>5.06·10<Sup>−11</Sup> — 0.421</>],
-      [<span style={{ color: DERIVED }}>both</span>,
-        <>1.011·10<Sup>−10</Sup> — 0.843</>],
-    ]} />
-
-    <Note>
-      They pull <i>opposite</i> ways — fewer meetings puts the threshold at a
-      higher density and raises <V>a</V><Sub>0</Sub>; a larger relative speed
-      means more meetings and lowers it.{' '}
-      <b style={{ color: INK }}>And the relative-speed factor is not actually
-        4/3 here</b>, which is the interesting part rather than a nuisance: 4/3
-      is the <i>isotropic</i> average, but a source’s own carriers all stream
-      radially outward — nearly comoving, and two things moving the same way at{' '}
-      <V>c</V> never meet. So the true factor sits between 1 and 4/3, and with{' '}
-      <i>share</i> counted{' '}
-      <b style={{ color: INK }}><V>a</V><Sub>0</Sub> ∈ [1.011, 1.348]·10<Sup>−10</Sup></b>{' '}
-      — the measured 1.200 sitting inside, 56% of the way across.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>And it tightens the two routes against each
-        other</b>, which is the better test since neither involves{' '}
-      <V>a</V><Sub>0</Sub>. Each <V>n</V><Sub>c</Sub> predicts a carrier mass
-      through <V>n</V><Sub>c</Sub> = (<V>m</V>/2π)<Sup>3</Sup>: bare gives 23.8
-      MeV, <i>share</i> gives 30.0, both give 27.3, against the 28.9 that{' '}
-      <V>a</V><Sub>0</Sub> demands.{' '}
-      <b style={{ color: INK }}>From 21% apart to 4%.</b> Two derivations that
-      share no steps now meet inside the uncertainty of either.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>What is left.</b> <i>What a carrier meets</i> is
-      now the only thing between this and a number — its own source’s outflow,
-      comoving and suppressed, or an ambient sea, isotropic and 4/3? That is a
-      question about <i>field.ts</i> and it is answerable by simulation.{' '}
-      <V>t</V><Sub>0</Sub> not being a constant is unfixable and stays a
-      prediction. And ~28 MeV is still not a particle: the bracket is 27–30 and
-      nothing sits there.
-    </Note>
-
-    <Note>
-      <b style={{ color: INK }}>A discipline note.</b> (4/3)<Sup>2</Sup> = 1.7778
-      against the observed 1.7799 — a match to 0.1%.{' '}
-      <i>Not claimed, and it should not be:</i> <V>a</V><Sub>0</Sub> itself is
-      quoted at ~10%, so 0.1% is far inside the noise, and √π = 1.772 fits just
-      as well. The two factors above are worth having because each was{' '}
-      <i>derived somewhere else in this file</i> — not because their product
-      lands well.
-    </Note>
-
-    <Head>and simulating the last open thing breaks it</Head>
+    <Head>and the objection the whole thing still has to survive</Head>
 
     <Note>
       <b style={{ color: INK }}>The suppression is real and strong.</b> A source
@@ -5207,6 +4373,321 @@ export const Law = () => {
       <b style={{ color: INK }}>contradicted</b>.
     </Note>
 
+    <Head>and what all of it comes to, added up</Head>
+
+    <Note>
+      Each correction above was quoted in isolation, which makes it hard to see
+      which ones matter. Put every one into a single pull —{' '}
+      <b style={{ color: INK }}>the turnover, the anisotropy, <K>reach</K>,{' '}
+        <K>carry</K> and <K>shows</K></b> — and the answer is stark:
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>the turnover</span>,
+        <>+22% at 8 kpc rising to +90% at 30. <b style={{ color: INK }}>This is
+          the whole of the effect.</b></>],
+      [<span style={{ color: FAINT }}>everything else</span>,
+        <><K>reach</K> is −9.5·10<Sup>−10</Sup>% at 30 kpc, <K>carry</K>{' '}
+          +2.4·10<Sup>−5</Sup>%, and <K>shows</K> is <i>exactly</i> nought —
+          a galaxy’s own column is far too thin to screen itself. Added in, the
+          curve is unchanged to the digit.</>],
+    ]} />
+
+    <Note>
+      So the whole dark-matter account rests on one number and nothing else in
+      the file competes with it. That is worth knowing both ways: it means the
+      other terms cannot be quietly helping, and it means{' '}
+      <b style={{ color: INK }}>there is nowhere left to hide a correction</b> —
+      if a₀ is wrong, the account is wrong.
+    </Note>
+
+    <Head>and the accumulation, which turns out to settle</Head>
+
+    <Note>
+      <K>MADE</K> is a rate, and this file has recorded as a blocking defect that
+      a rate <i>accumulates</i>: over the age that is a factor of
+      10<Sup>63</Sup> on the potential, which would put <V>u</V> at the Sun at
+      10<Sup>57</Sup> and make every general-relativistic test here a calculation
+      from the wrong metric.{' '}
+      <b style={{ color: INK }}>But that count integrates the making with nothing
+        draining it.</b>
+    </Note>
+
+    <Note>
+      Annihilation gives the point back. Points made at the body ride out with
+      the carriers and are unmade where a carrier annihilates, so the excess at
+      radius <V>r</V> is fed by what arrives and drained by what dies there, and
+      the steady state is <V>ρ</V> = <V>S</V>·<V>e</V><Sup>−<V>r</V>/<V>λ</V></Sup>/(4π<V>r</V><Sup>2</Sup><V>c</V>)
+      — <b style={{ color: INK }}>a static profile with no <V>t</V> in it</b>.
+      The total held is <V>λ</V>, set by the mean free path and not by the age,
+      and it is reached in <V>λ</V>/<V>c</V>.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>a galaxy, 30 kpc</span>,
+        <>settles in 10<Sup>−4</Sup> Gyr — instantly. So <V>u</V> at the Sun is
+          the Newtonian <V>u</V>, every GR test here is computed from the right
+          metric, and <b style={{ color: INK }}><K>MADE</K> was never in conflict
+            with <K>slowing</K></b>.</>],
+      [<span style={{ color: FAINT }}>the full <K>reach</K>, 6.9 Gpc</span>,
+        <>settles in 22 Gyr, which is longer than the age — so the excess is{' '}
+          <i>still filling</i> at the largest scales and is suppressed there by
+          about 0.615. That is the one place the defect survives, and it is an
+          order-unity effect at scales nothing here measures.</>],
+    ]} />
+
+    <Note>
+      Which retires a bill that has been open since <K>MADE</K> was written down.
+      It also removes the last support for the feedback route — that needed the{' '}
+      <i>accumulated</i> <V>u</V> to be enormous, and it is not. Consistent,
+      since the feedback was retired on other grounds, and this kills it a second
+      time independently.
+    </Note>
+
+    <Head>and is this dark matter, or a mechanism for one regime</Head>
+
+    <Note>
+      Everything above is rotation curves, which is where MOND-like accounts have
+      always been strongest. The places dark matter wins decisively are{' '}
+      <b style={{ color: INK }}>clusters, the Bullet Cluster, and the third
+        acoustic peak</b>, and none of them has been asked here. The cheapest is
+      the cluster, and it is the one that has broken every such account so far.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>what clusters need</span>,
+        <>Coma 6.0×, A1689 6.8×, A2029 5.3×, Perseus 5.9×, Virgo 6.0× — the ratio
+          of dynamical to baryonic mass, from X-ray profiles and lensing, which
+          agree to tens of percent.</>],
+      [<span style={{ color: BORROWED }}>what the model supplies</span>,
+        <>3.32×, 3.59×, 3.52×, 3.75×, 5.54×.{' '}
+          <b style={{ color: INK }}>Short by a factor of 1.5</b>, and the miss is
+          systematic rather than scattered.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>And the reason is structural, not a matter of
+        tuning.</b> In the boosted regime the mass ratio is
+      √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>), so a factor of six needs{' '}
+      <V>g</V><Sub>N</Sub>/<V>a</V><Sub>0</Sub> = 1/36. Clusters sit at 0.10 to
+      0.13 — near the turnover, not deep in it — where the ceiling is about 3×.{' '}
+      <b style={{ color: INK }}>The square root is a hard ceiling and clusters
+        are above it</b>, so no interpolation function and no value of{' '}
+      <V>a</V><Sub>0</Sub> reaches them.
+    </Note>
+
+    <Note>
+      Worse, the demands point opposite ways. Clusters want{' '}
+      <V>a</V><Sub>0</Sub> up to <b style={{ color: INK }}>4× larger</b>; the
+      compact high-<V>z</V> discs want it{' '}
+      <b style={{ color: INK }}>0.6× smaller</b>. Those are not reconcilable by
+      any constant, and the anisotropy moves both the wrong way at once.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>So this is not a dark-matter theory. It is a
+        mechanism for the rotation-curve regime.</b> In the deep limit it{' '}
+      <i>is</i> MOND — that is the point of deriving the interpolation rather
+      than choosing it — and it therefore inherits MOND’s cluster problem
+      exactly, for the same reason and by the same factor. What it adds over MOND
+      is that <V>a</V><Sub>0</Sub> is computed rather than fitted, the
+      interpolation is derived rather than chosen, and there is a step nobody
+      else predicts. What it does not add is any reach beyond galaxies.
+    </Note>
+
+    <Note>
+      Which should be said plainly rather than buried: the model has no microwave
+      background at all (the seventh closure), fails the supernova diagram, has
+      no source for the light elements, and now misses clusters by 1.5×.{' '}
+      <b style={{ color: INK }}>Four of the five things dark matter and ΛCDM were
+        built to account for are untouched or failed.</b> A galaxy’s rotation
+      curve fitted to 1.1% by a computed constant is a real result and it is one
+      regime out of five.
+    </Note>
+
+    <Head>and what that leaves dark matter to do</Head>
+
+    <Note>
+      Which turns the question round, and the inference is sound:{' '}
+      <b style={{ color: INK }}>if the transport supplies the galactic
+        phenomenology, then dark matter is not needed for rotation curves</b>,
+      and whatever exists only has to cover the residual. That is not a new
+      position — it is roughly what was proposed for MOND with sterile neutrinos
+      — but it is worth pricing.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>the requirement collapses</span>,
+        <>Clusters need 6.0× the baryons and the transport supplies 3.9×, so the
+          residual is <b style={{ color: INK }}>0.58× in extra mass</b> against
+          ΛCDM’s 5.3×. <b style={{ color: INK }}>About ten times less dark
+            matter.</b></>],
+      [<span style={{ color: DERIVED }}>and one awkwardness dissolves</span>,
+        <>ΛCDM has to explain why halos track the baryons so tightly. On this
+          account they do not track them — <i>there is no halo in a
+            galaxy</i>.</>],
+      [<span style={{ color: BORROWED }}>but it cannot be ordinary</span>,
+        <>Put that 0.58× into the Milky Way and the fit is destroyed: 269 km/s
+          at the Sun against a measured 229. So the residual has to cluster in
+          clusters and <i>not</i> in galaxies, which is a phase-space statement
+          and fixes its mass from both sides — heavier than the cluster
+          Tremaine–Gunn bound of 0.83 eV, lighter than the galaxy one at 8.5 eV.
+          A narrow window, and not an empty one.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: BORROWED }}>And the caveat is the whole of the rest of
+        cosmology.</b> The third acoustic peak measures{' '}
+      <V>Ω</V><Sub>DM</Sub>/<V>Ω</V><Sub>b</Sub> ≈ 5 at <V>z</V> = 1100, when
+      there were no galaxies, no clusters, and nothing for the transport to act
+      on. A 0.58× residual cannot make that peak. So the reduction is real{' '}
+      <i>for clusters</i> and simply unavailable for the microwave background.
+    </Note>
+
+    <Note>
+      And for this model it is moot twice over, because{' '}
+      <b style={{ color: INK }}>it has no microwave background at all</b> — the
+      seventh closure — so it cannot appeal to the CMB in either direction. The
+      inference is correct and it reduces a bill the model was not going to pay
+      anyway. Worth stating precisely: <i>this account removes the need for dark
+        matter in galaxies, reduces it tenfold in clusters, and says nothing
+        about the epoch where most of the evidence for it comes from.</i>
+    </Note>
+
+    <Head>what would actually finish it</Head>
+
+    <Note>
+      The dark-matter account is now one mechanism with one number, and what it
+      owes is short enough to list. Three of these are questions about{' '}
+      <code>physics.ts</code> rather than about galaxies, which is a much better
+      place to be stuck than in a fit.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: BORROWED }}>the one link</span>,
+        <>That a carrier’s update cost goes as its accumulated phase. Everything
+          in the transport route hangs on it and it is the only piece not already
+          a rule — <K>through</K> supplies the blocking, <K>inStep</K> supplies
+          the budget, and this is the join between them.{' '}
+          <b style={{ color: INK }}>It is a statement about what a tick is spent
+            on</b>, and it should be settled by writing the update rule down and
+          counting, not by another galaxy.</>],
+      [<span style={{ color: BORROWED }}>the ambient sea</span>,
+        <>The section above: the background carrier density is 2.65 times{' '}
+          <V>n</V><Sub>c</Sub> even after <i>reach</i> cuts it off, so the
+          crossover is thrown nearly everywhere and the MOND regime switches on
+          only <i>barely</i>. Every fit in this section assumed it switches on
+          cleanly. <b style={{ color: INK }}>Reconciling those two is the largest
+            single gap</b>, and it is measurable inside the model — it needs the
+          ambient density recomputed with the frontier cosmology rather than the
+          bulk one it was derived under.</>],
+      [<span style={{ color: BORROWED }}>the factor of 13/8</span>,
+        <>Two derivations of <V>a</V><Sub>0</Sub> differing by exactly{' '}
+          <K>WAYS</K>/2<K>SHEET</K>. One of them miscounts, and finding which
+          would turn a 9% agreement into a derivation or kill it outright. This
+          is arithmetic, not physics.</>],
+      [<span style={{ color: DERIVED }}>and then a real prediction</span>,
+        <>The model lost its dated one when <V>a</V><Sub>0</Sub> became local —
+          and the anisotropy hands back a sharper one, worked out below.</>],
+    ]} />
+
+    <Head>the prediction the anisotropy makes</Head>
+
+    <Note>
+      The projection is a <i>step</i> function because the lattice has three
+      direction cosines, and a galaxy sits on one plateau throughout — which is
+      what saved the shape. <b style={{ color: INK }}>But a galaxy is not the
+        whole of anything.</b> Far enough out the occupancy does cross a step,
+      and when it does <V>a</V><Sub>0</Sub> jumps by a fixed ratio. That is a{' '}
+      <b style={{ color: INK }}>discontinuity in a rotation curve, at a radius
+        the model computes</b>, and nothing else predicts one anywhere.
+    </Note>
+
+    <Note>
+      The cone reaches cos = 1/√2 at <V>g</V>/<V>a</V><Sub>0</Sub> = 0.172 and
+      cos = 1/√3 at 0.268. In the deep regime{' '}
+      <V>g</V> = √(<V>g</V><Sub>N</Sub><V>a</V><Sub>0</Sub>), so those are
+      radii — and for real galaxies they land where we already look:
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>the Milky Way</span>,
+        <>Steps at <b style={{ color: INK }}>33 and 52 kpc</b>. That is where the
+          Sagittarius stream lives, and where the satellite population is
+          measured.</>],
+      [<span style={{ color: DERIVED }}>a big spiral, 3×</span>,
+        <>58 and 90 kpc.</>],
+      [<span style={{ color: DERIVED }}>a dwarf, 1/30</span>,
+        <>6 and 9 kpc — inside the stellar body, where a curve is easiest to
+          measure.</>],
+    ]} />
+
+    <Note>
+      And the size: <V>v</V> ∝ <V>a</V><Sub>0</Sub><Sup>¼</Sup> in the deep
+      regime, so the plateau ratios of 0.955, 0.892 and 0.898 give jumps of{' '}
+      <b style={{ color: INK }}>1.1%, 2.8% and 2.7%</b> — about 2 to 6 km/s on a
+      200 km/s curve. Small, and <i>sharp</i>: not a bend but a step, at a radius
+      fixed by the baryons alone with nothing to tune. A dwarf is the best place
+      to look, because the steps fall inside the stellar body and the fractional
+      jump is the same.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>That is the one genuinely new thing this account
+        offers.</b> MOND has no reason for a curve to be anything but smooth;
+      ΛCDM has no reason either, since a halo is smooth by construction. A
+      discrete lattice with 26 exits has exactly three places where the geometry
+      changes, and they are not adjustable.
+    </Note>
+
+    <Head>and how much of Genzel that fixes</Head>
+
+    <Note>
+      Genzel’s discs are dense, so they sit on the most-shut plateau where{' '}
+      <V>a</V><Sub>0</Sub> is smallest and the boost least. Turning the
+      anisotropy on at the predicted <V>a</V><Sub>0</Sub> takes the worst boost
+      from 1.112 to <b style={{ color: INK }}>1.090</b> — the margin under the
+      1.12 ceiling goes from 0.008 to 0.030,{' '}
+      <b style={{ color: INK }}>3.7× more comfortable</b>.
+    </Note>
+
+    <Note>
+      <b style={{ color: BORROWED }}>But it costs the Milky Way, and there is no
+        setting where both are comfortable.</b> The same rescaling that relieves
+      Genzel takes the Milky Way from 1.1% to 5.2%. Refitting{' '}
+      <V>a</V><Sub>0</Sub> upward recovers it — 0.7% at 1.38×<V>cH</V><Sub>0</Sub>/2π
+      — but then <V>a</V><Sub>0</Sub> is fitted rather than predicted, and the
+      Genzel margin falls back to 0.003. The two pull against each other:
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>isotropic, <V>a</V><Sub>0</Sub> predicted</span>,
+        <>Milky Way <b style={{ color: INK }}>1.1%</b>, Genzel worst 1.112 —
+          both pass, nothing fitted, margin thin.</>],
+      [<span style={{ color: FAINT }}>anisotropic, <V>a</V><Sub>0</Sub> predicted</span>,
+        <>Milky Way 5.2%, Genzel worst <b style={{ color: INK }}>1.090</b> —
+          both pass, nothing fitted, curve worse.</>],
+      [<span style={{ color: BORROWED }}>anisotropic, <V>a</V><Sub>0</Sub> fitted</span>,
+        <>Milky Way 0.7%, Genzel 1.117 — best curve, but one number fitted and
+          the margin back to a hair.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>So Genzel is not fixed by a knob; it is fixed by
+        settling how far the cone is shut</b> — which is the same question as the
+      13/8, and is arithmetic on the emission rule rather than anything
+      astronomical. Until that is done, the honest statement is that all three
+      readings clear the measurement and none of them clears it comfortably.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>What would finish it, in one sentence:</b> derive
+      the update cost, recompute the ambient sea under the frontier cosmology,
+      and find which of the two counts is wrong. None of the three needs a
+      telescope, and all three are the sort of thing this file has settled
+      before.
+    </Note>
+
     <Head>what you can switch off</Head>
 
     <Note>
@@ -5281,8 +4762,12 @@ export const Law = () => {
           <V>a</V><Sub>0</Sub> and fits the Milky Way’s curve to{' '}
           <b style={{ color: INK }}>1.1%</b>. Because the mean spacing shrinks by
           exactly the factor the clock speeds up by, that <V>a</V><Sub>0</Sub> is
-          constant in redshift, and Genzel’s <V>z</V> ≈ 2 discs pass. It owes one
-          link — that a carrier’s update cost goes as its accumulated phase.</>],
+          constant in redshift. It owes one link — that a carrier’s update cost
+          goes as its accumulated phase — and it{' '}
+          runs a few percent high on the compact <V>z</V> ≈ 2 discs, where the
+          measurement is an upper limit and Newton runs a few percent low. On
+          the Milky Way it is <b style={{ color: INK }}>thirty times closer than
+            Newton</b> — 1.1% against 32.5%.</>],
       [<span style={{ color: DERIVED }}>and four things to shoot at</span>,
         <>The shadow, <b style={{ color: INK }}>4.6% larger</b> than general
           relativity’s at the same mass — parameter-free, and inside the reach
@@ -5290,11 +4775,11 @@ export const Law = () => {
           <b style={{ color: INK }}>forced to 1/<V>H</V><Sub>0</Sub></b> with no
           freedom to miss, which the Hubble tension brackets.{' '}
           <b style={{ color: INK }}><V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π</b>,
-          computed rather than fitted, 9% from the measured value. And the one
-          that dates it: <b style={{ color: INK }}><V>a</V><Sub>0</Sub> ∝ 1/<V>t</V></b>,
-          so rotation curves at <V>z</V> = 2 should flatten at three times
-          today’s acceleration — which MOND has no way to say and which the
-          measurements can already refuse.</>],
+          computed rather than fitted, 9% from the measured value — though the
+          derivation that survives is low by 1.78 rather than 1.095, and the
+          compact high-<V>z</V> discs want it smaller still. And the step: a{' '}
+          <b style={{ color: INK }}>discontinuity in a rotation curve</b> at
+          6 and 9 kpc in a dwarf, which nothing else in physics predicts.</>],
     ]} />
 
     <Head>and the record of a road not taken</Head>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
index d38f266..5fb5f7c 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
@@ -440,20 +440,29 @@ const apart = (s: Surface) => {
 const split = (s: Surface) => {
   const box = frame(s);
   const XMAX = 30;
-  const top = 1.18, bot = -0.35;                          // fractions of `inside`
+  const top = 2.6, bot = -0.35;                          // fractions of `inside`
   const { X, Y } = axes(s, box, XMAX, bot, top,
-    [5, 10, 15, 20, 25, 30], [1, 0.75, 0.5, 0.25, 0, -0.25],
-    v => v === 0 ? "0" : v.toFixed(2));
+    [5, 10, 15, 20, 25, 30], [2.5, 2, 1.5, 1, 0.5, 0],
+    v => v === 0 ? "0" : v.toFixed(1));
 
   s.ctx.strokeStyle = "rgba(255,255,255,0.22)"; s.ctx.lineWidth = 1;
   s.ctx.beginPath(); s.ctx.moveTo(box.x0, Y(0)); s.ctx.lineTo(box.x1, Y(0)); s.ctx.stroke();
 
+  // what the measurement needs, on the same scale — the pull Gaia's curve
+  // implies, as a fraction of what the mass inside the orbit supplies
+  path(s, CURVE, X, Y,
+    p => Math.pow(MEASURED(p.r / KPC) * 1e3, 2) / (p.r * p.inside), SEEN, 2.2);
+  path(s, CURVE, X, Y,
+    p => mond(p.total) / p.inside, MODEL, 2.2);
+
   path(s, CURVE, X, Y, p => 1, PALE, 1.6, [4, 3]);
   path(s, CURVE, X, Y, p => p.outside / p.inside, DATA, 2.2);
-  path(s, CURVE, X, Y, p => p.total / p.inside, MODEL, 2.2);
+  path(s, CURVE, X, Y, p => p.total / p.inside, RELAT, 1.8, [5, 3]);
 
+  tag(s, X(1.2), Y(2.42), "what is measured", SEEN);
+  tag(s, X(1.2), Y(2.20), "this model", MODEL);
   tag(s, X(16.4), Y(1.09), "pull from inside r  (set to 1)", PALE);
-  tag(s, X(15), Y(0.80), "net", MODEL);
+  tag(s, X(13.4), Y(0.72), "NEWTON & GR, net", RELAT);
   tag(s, X(11.5), Y(-0.21), "pull from OUTSIDE r — outward, so it subtracts", DATA);
 
   under(s, box, "radius (kpc)");
@@ -487,8 +496,8 @@ const speeder = (table: { r: number; v: number }[]) => (r: number) => {
 
 const LAWS = [
   {
-    name: "GENERAL RELATIVITY",
-    under: "= Newton on the baryons, to a part in 10⁶",
+    name: "NEWTON & GR",
+    under: "the baryons alone — the two agree to a part in 10⁶",
     css: DATA,
     v: speeder(CURVE.map(p => ({ r: p.r, v: kms(p.total, p.r) * 1e3 }))),
   },
@@ -499,10 +508,10 @@ const LAWS = [
     v: speeder(CURVE.map(p => ({ r: p.r, v: MEASURED(p.r / KPC) * 1e3 }))),
   },
   {
-    name: "THE CAUGHT PAIR",
-    under: "the 1/R law, one scale fitted",
+    name: "THIS MODEL",
+    under: "the transport route — a₀ = cH₀/2π, computed",
     css: MODEL,
-    v: speeder(CAUGHT),
+    v: speeder(CURVE.map(p => ({ r: p.r, v: Math.sqrt(mond(p.total) * p.r) }))),
   },
 ];
 
@@ -660,7 +669,7 @@ export const Discs = ({ height = 300 }: { height?: number }) =>
     <div style={{
       fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
       color: FAINT, marginBottom: 6,
-    }}>four spokes of stars, sheared by three laws — dashed is the measured one, drawn in every panel</div>
+    }}>four spokes of stars, sheared by three laws — Newton &amp; GR, what is measured, and this model</div>
     <div style={{ height, background: "#08090d" }}>
       <CanvasView deps={["discs"]} paint={() => ({ frame: discs })} />
     </div>
@@ -733,6 +742,10 @@ const highz = (s: Surface) => {
   }
   ctx.textAlign = "left";
 
+  // NEWTON & GR sit at exactly 1 — the baryons and nothing else
+  ctx.strokeStyle = RELAT; ctx.lineWidth = 1.8;
+  ctx.beginPath(); ctx.moveTo(box.x0, Y(1.0)); ctx.lineTo(box.x1, Y(1.0)); ctx.stroke();
+
   // what the measurement allows — everything above this line is excluded
   ctx.fillStyle = "rgba(235,90,90,0.10)";
   ctx.fillRect(box.x0, box.y0, box.w, Y(ALLOWED) - box.y0);
@@ -762,6 +775,7 @@ const highz = (s: Surface) => {
   tag(s, X(0.66), Y(1.44), "EXCLUDED — Genzel measures f_DM(<Re) < 0.2, i.e. under 1.12", SEEN);
   tag(s, X(0.66), Y(1.325), "a₀ = cH₀/2π·(1+z) — THIS MODEL", MODEL);
   tag(s, X(0.66), Y(1.265), "a₀ fixed — ordinary MOND", DATA);
+  tag(s, X(0.66), Y(1.028), "NEWTON & GR — the baryons alone", RELAT);
 
   under(s, box, "redshift");
   ctx.fillStyle = FAINT;
@@ -826,11 +840,11 @@ const HZ_LAWS = (() => {
   };
   return [
     {
-      name: "WHAT IS MEASURED", under: "baryons — a declining curve (Genzel 2017)",
-      css: SEEN, v: speeder(0),
+      name: "NEWTON & GR", under: "the baryons alone — a declining curve",
+      css: PALE, v: speeder(0),
     },
     {
-      name: "a₀ CONSTANT", under: "the mean-spacing reading — a₀ = cH₀/2π",
+      name: "THIS MODEL", under: "a₀ = cH₀/2π, constant in z",
       css: MODEL, v: speeder(A0_MODEL),
     },
     {
@@ -914,7 +928,10 @@ const hzDiscs = (() => {
         }
         ctx.setLineDash([]);
       };
-      if (n !== 0) spokes(HZ_LAWS[0].v, GHOST, 1.3, [3, 3]);
+      // Newton is the dashed grey ghost and the ceiling f_DM < 0.2 allows is
+      // the dashed white one, so both references are in every panel.
+      if (n !== 0) spokes(HZ_LAWS[0].v, "rgba(111,123,168,0.45)", 1.2, [3, 3]);
+      spokes((r: number) => HZ_LAWS[0].v(r) * 1.118, GHOST, 1.2, [2, 4]);
       spokes(law.v, law.css, 1.7, []);
     });
 
@@ -922,7 +939,7 @@ const hzDiscs = (() => {
     ctx.font = "400 10px ui-monospace, Menlo, monospace";
     ctx.fillText(`${(t / GYR * 1e3).toFixed(0)} Myr — a compact disc at z = ${HZ_Z}`, 2, height - 6);
     ctx.textAlign = "right";
-    ctx.fillText("dashed is the measured, baryonic curve — drawn in every panel",
+    ctx.fillText("grey dash = Newton, white dash = the f_DM < 0.2 ceiling — both in every panel",
       width - 2, height - 6);
     ctx.textAlign = "left";
   };
@@ -934,8 +951,162 @@ export const HighZDiscs = ({ height = 300 }: { height?: number }) =>
     <div style={{
       fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
       color: FAINT, marginBottom: 6,
-    }}>a compact disc at z ≈ 2 — where a₀ ∝ 1/t predicts a visibly flatter galaxy than is seen</div>
+    }}>a compact disc at z ≈ 2 — Newton &amp; GR against two readings of a₀, with the measured ceiling in every panel</div>
     <div style={{ height, background: "#08090d" }}>
       <CanvasView deps={["hzdiscs"]} paint={() => ({ frame: hzDiscs })} />
     </div>
   </div>;
+
+// ---------------------------------------------------------------------------
+// THE HIGH-z DISCS AS ROTATION CURVES, which is the only way to see whether the
+// model agrees with them. The panels above give a boost factor and a shear —
+// neither lets you look at a curve and judge it, which is what the Milky Way
+// panel allows and what these deserve too.
+//
+// Each galaxy: its baryons summed the same way as everywhere else, the model's
+// prediction on top, and the band Genzel's f_DM(<Re) < 0.2 permits. The point
+// is that a DECLINING curve is what is measured, so the model has to decline
+// too — and at these densities it does, because g_N ≫ a₀ throughout.
+
+const GZ: { name: string; z: number; logMs: number; fgas: number; Re: number }[] = [
+  { name: "COS4_01351", z: 0.854, logMs: 11.07, fgas: 0.35, Re: 8.2 },
+  { name: "D3a_6397", z: 1.500, logMs: 11.07, fgas: 0.45, Re: 7.4 },
+  { name: "GS4_43501", z: 1.613, logMs: 10.71, fgas: 0.50, Re: 4.9 },
+  { name: "zC_406690", z: 2.196, logMs: 10.62, fgas: 0.55, Re: 5.5 },
+  { name: "zC_400569", z: 2.242, logMs: 11.07, fgas: 0.45, Re: 3.3 },
+];
+
+/** an exponential disc's own pull, summed ring by ring — no shell theorem */
+const gzBaryons = (Mbar: number, Rd: number, r: number, NRr = 240, NP = 240) => {
+  const RMAX = 12 * Rd, h = Rd / 8;
+  let acc = 0;
+  for (let i = 0; i < NRr; i++) {
+    const R = RMAX * (i + 0.5) / NRr, dRr = RMAX / NRr;
+    const s = Mbar / (2 * Math.PI * Rd * Rd) * Math.exp(-R / Rd) * R * dRr;
+    let a = 0;
+    for (let j = 0; j < NP; j++) {
+      const p = 2 * Math.PI * (j + 0.5) / NP;
+      const dx = R * Math.cos(p) - r, dy = R * Math.sin(p);
+      a += dx / Math.pow(dx * dx + dy * dy + h * h, 1.5);
+    }
+    acc += -G * s * a * (2 * Math.PI / NP);
+  }
+  return acc;
+};
+
+const GZ_CURVES = GZ.map(d => {
+  const Mbar = Math.pow(10, d.logMs) * MSUN / (1 - d.fgas);
+  const Rd = d.Re * KPC / 1.68;
+  const pts: { r: number; bar: number; mod: number }[] = [];
+  for (let i = 1; i <= 26; i++) {
+    const r = i * 0.15 * d.Re * KPC;
+    const gB = gzBaryons(Mbar, Rd, r);
+    const gM = gB / 2 + Math.sqrt(gB * gB / 4 + gB * A0_MODEL);
+    pts.push({ r, bar: Math.sqrt(Math.max(0, gB * r)), mod: Math.sqrt(Math.max(0, gM * r)) });
+  }
+  return { d, pts, Re: d.Re * KPC };
+});
+
+const gzPanel = (s: Surface) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = "#08090d";
+  ctx.fillRect(0, 0, width, height);
+
+  const pad = 30, gap = 8;
+  const w = (width - pad - gap * 4) / 5;
+  const top = 42, bot = 30, hh = height - top - bot;
+  const VMAX = 420;
+
+  GZ_CURVES.forEach((g, n) => {
+    const x0 = pad + n * (w + gap);
+    const RMAXk = 3.0 * g.d.Re;
+    const X = (rk: number) => x0 + w * Math.min(rk, RMAXk) / RMAXk;
+    const Y = (v: number) => top + hh * (1 - Math.min(v, VMAX) / VMAX);
+    const inside = g.pts.filter(p => p.r / KPC <= RMAXk);
+
+    ctx.save();
+    ctx.beginPath(); ctx.rect(x0, top - 2, w, hh + 4); ctx.clip();
+
+    ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+    for (const v of [100, 200, 300, 400]) {
+      ctx.beginPath(); ctx.moveTo(x0, Y(v)); ctx.lineTo(x0 + w, Y(v)); ctx.stroke();
+    }
+
+    // the ceiling f_DM < 0.2 sets — drawn ONLY inside Re, which is where it
+    // is quoted. Beyond Re the measurement says nothing and the model is free.
+    const within = inside.filter(p => p.r <= g.Re);
+    ctx.fillStyle = "rgba(238,240,245,0.13)";
+    ctx.beginPath();
+    within.forEach((p, i) => {
+      const x = X(p.r / KPC), y = Y(p.bar / 1e3);
+      if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
+    });
+    for (let i = within.length - 1; i >= 0; i--)
+      ctx.lineTo(X(within[i].r / KPC), Y(within[i].bar / 1e3 * 1.118));
+    ctx.closePath(); ctx.fill();
+
+    const line = (pts: typeof inside, of: (p: typeof inside[0]) => number,
+      css: string, wide: number, dash: number[]) => {
+      ctx.strokeStyle = css; ctx.lineWidth = wide; ctx.setLineDash(dash);
+      ctx.beginPath();
+      pts.forEach((p, i) => {
+        const x = X(p.r / KPC), y = Y(of(p) / 1e3);
+        if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
+      });
+      ctx.stroke(); ctx.setLineDash([]);
+    };
+    line(within, p => p.bar * 1.118, SEEN, 1.3, [4, 3]);
+    line(inside, p => p.bar, PALE, 1.4, []);
+    line(inside, p => p.mod, MODEL, 2.2, []);
+    ctx.restore();
+
+    // Re, and the two values that are actually being compared there
+    ctx.strokeStyle = "rgba(255,255,255,0.20)"; ctx.setLineDash([3, 3]);
+    ctx.beginPath(); ctx.moveTo(X(g.d.Re), top); ctx.lineTo(X(g.d.Re), top + hh);
+    ctx.stroke(); ctx.setLineDash([]);
+
+    const at = g.pts.reduce((a, b) =>
+      Math.abs(b.r - g.Re) < Math.abs(a.r - g.Re) ? b : a);
+    const bx = X(g.d.Re);
+    ctx.fillStyle = SEEN;
+    ctx.beginPath(); ctx.arc(bx, Y(at.bar / 1e3 * 1.118), 2.6, 0, 2 * Math.PI); ctx.fill();
+    ctx.fillStyle = MODEL;
+    ctx.beginPath(); ctx.arc(bx, Y(at.mod / 1e3), 3.0, 0, 2 * Math.PI); ctx.fill();
+
+    ctx.fillStyle = MODEL;
+    ctx.font = "600 9px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText(g.d.name, x0 + 1, 12);
+    ctx.fillStyle = FAINT;
+    ctx.font = "400 8.5px ui-monospace, Menlo, monospace";
+    ctx.fillText(`z ${g.d.z.toFixed(2)}   Re ${g.d.Re.toFixed(1)}`, x0 + 1, 24);
+    const ratio = at.mod / at.bar;
+    ctx.fillStyle = ratio <= 1.118 ? "#8bd48b" : DATA;
+    ctx.font = "500 8.5px ui-monospace, Menlo, monospace";
+    ctx.fillText(`${ratio.toFixed(3)} ${ratio <= 1.118 ? "≤" : ">"} 1.118`, x0 + 1, 35);
+  });
+
+  ctx.fillStyle = FAINT;
+  ctx.font = "400 9px ui-monospace, Menlo, monospace";
+  ctx.textAlign = "right";
+  for (const v of [100, 200, 300, 400]) {
+    const y = top + hh * (1 - v / VMAX);
+    ctx.fillText(String(v), pad - 4, y + 3);
+  }
+  ctx.fillText("out to 3 Re — dashed vertical is Re, where f_DM is quoted",
+    width - 2, height - 6);
+  ctx.textAlign = "left";
+  ctx.fillText("km/s", 2, top - 8);
+  ctx.fillStyle = MODEL;
+  ctx.font = "500 9.5px ui-sans-serif, system-ui, sans-serif";
+  ctx.fillText("the model", 2, height - 6);
+  ctx.fillStyle = PALE;
+  ctx.fillText("NEWTON & GR — baryons alone", 68, height - 6);
+  ctx.fillStyle = SEEN;
+  ctx.fillText("measured — the f_DM < 0.2 ceiling, inside Re", 236, height - 6);
+};
+
+/** the high-z discs as curves, which is the only way to judge the agreement */
+export const HighZCurves = ({ height = 260 }: { height?: number }) =>
+  <Panel paint={gzPanel} height={height}
+    note="Genzel's five discs as rotation curves — the model against what is allowed" />;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
new file mode 100644
index 0000000..e047309
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
@@ -0,0 +1,114 @@
+# the measurements behind the article
+
+Every number quoted in `gravity.ts` and `law.tsx` was produced by one of these.
+They are kept so that a claim can be re-run rather than believed, and so that a
+result that later turns out wrong can be found and corrected at its source.
+
+```
+./run.sh              every test in order
+./run.sh combined     one of them
+./run.sh --list       what there is
+```
+
+Each file is standalone TypeScript with **no imports** — it carries its own
+constants and its own copy of whatever geometry it needs. That duplication is
+deliberate: a test should be readable and runnable on its own, and should not
+break because the article was edited. Where a test needs the lattice constants
+it recomputes them from `SHEET`, `WAYS`, `BITE`, `CORE` rather than importing
+`G_LATTICE`, so a change to the definitions shows up as a test failure rather
+than as silent agreement.
+
+## what each one settles
+
+### the force law
+
+| | |
+|---|---|
+| `three` | Newton, GR and this model against Gaia — the three agree to a part in 10⁶ and all three miss by a factor of three |
+| `combined` | **every effect in the file at once**: turnover, anisotropy, `reach`, `carry`, `shows`. Everything but the turnover is under 10⁻⁶ at galactic radii |
+
+### the cosmology
+
+| | |
+|---|---|
+| `frontcheck` | the frontier construction audited — the advance budget, `reach` under its own cosmology, the mass bill |
+| `sne` | the supernova Hubble diagram, with the absolute magnitude marginalised away |
+
+### dark matter — what does not work
+
+| | |
+|---|---|
+| `caught` | the caught pair: π³/R by Monte Carlo, and the density it needs |
+| `arms` | the same with the fog on **both** sides, which is the correction that mattered |
+| `rootm`, `rootm2` | a body's own charges cancelling — the exponent slides past ½ rather than sitting on it |
+| `feed` | the feedback chain, and why the coherence switch cannot be thrown |
+| `selfcon`, `fixedpoint` | the self-limiting loop and its fixed point |
+| `speedloop`, `drivers` | which driver gives which exponent, and what Tully–Fisher allows |
+| `galaxy_sc`, `perm` | the fully relaxed galaxy, and the permutation search over drivers and channels |
+| `vmass`, `sens`, `sign` | the velocity–mass conversion, its systematics, and the sign that decides it |
+
+### dark matter — what does
+
+| | |
+|---|---|
+| `transport` | the transport route at galaxy scale |
+| `expand` | **a₀ = cH₀/2π**, and the galaxy run with nothing fitted |
+| `polarity`, `pol2` | the ± attribution as a fair coin — √N with no coherence condition |
+| `blocking`, `redo` | blocking **derives** the interpolation function, and Genzel redone with it |
+
+### the high-redshift discs
+
+| | |
+|---|---|
+| `genzel` | the five discs against a₀ fixed and a₀ ∝ 1/t |
+| `genzel2` | **the same with the disc done properly** — the point-mass shortcut was generous, and correcting it moves four of five over the ceiling |
+| `fair` | and what that is worth: the error in velocity, for Newton and for the model, on both datasets, with the high-z limit read as a band |
+| `empty`, `spacing` | emptiness as density (fails) and as mean spacing (cancels exactly) |
+
+### the anisotropy
+
+| | |
+|---|---|
+| `quant` | the lattice has three direction cosines, so the projection is a **step** |
+| `shape` | and therefore the rotation curve's shape survives |
+| `steps` | where the steps fall — 33 and 52 kpc for the Milky Way, 6 and 9 for a dwarf |
+| `joint` | the Milky Way and Genzel together, and the trade between them |
+
+### and whether it is dark matter at all
+
+| | |
+|---|---|
+| `clusters` | **the test that decides the question** — five clusters need 6× and the model supplies 3.9×, short by 1.5×, for the same structural reason MOND is |
+| `clumpy` | whether the voids between galaxies help — they do not, because superposition fixes the field whatever the packing |
+| `residual` | and what is left for dark matter to do: 0.58× the baryons instead of 5.3×, but it must avoid galaxies, and the CMB is untouched |
+
+### closure
+
+| | |
+|---|---|
+| `recon`, `which138` | the two a₀ derivations differ by exactly `WAYS/2·SHEET` = 13/8, and which one the surviving mechanism selects |
+| `accum`, `accumulate` | whether the fold really accumulates — it reaches a **steady state** in λ/c, which retires the defect |
+| `asym` | the fixed-point exponents, converged to five figures |
+
+## what is still open
+
+Three things, all arithmetic rather than astronomy:
+
+1. **the one link** — that a carrier's update cost goes as its accumulated
+   phase. `through` gives the blocking, `inStep` gives the budget; this is the
+   join, and nothing here derives it.
+2. **the 1.78** — the meeting-count derivation of a₀ is low by that factor. See
+   `which138`. `√π` and `16/9` are both within half a percent, which means
+   nothing without a derivation.
+3. **how far the cone is shut** — it sets both the Genzel margin and the step
+   sizes, and it is a question about the emission rule.
+
+And the thing that decides what this *is*: `clusters`. The account works in the
+rotation-curve regime and inherits MOND's cluster problem exactly, because in
+the deep limit it is MOND. Four of the five things dark matter was invented for
+— clusters, the Bullet Cluster, the acoustic peaks, the light elements — are
+untouched or failed.
+
+And one that is not: **look for the step**. A dwarf's fall at 6 and 9 kpc,
+inside the stellar body, and nothing else in physics predicts a discontinuity
+in a rotation curve.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accum.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accum.ts
new file mode 100644
index 0000000..2ddc547
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accum.ts
@@ -0,0 +1,25 @@
+/** Does the fold ACCUMULATE? The file says it does, and flags it as a problem.
+ *  For this feedback it is the whole ballgame, so price it. */
+const G_LAT = 0.06235150, SHEET = 8;
+const TICKS = 8.07e60;                      // the age, from `frontier`
+const G = 6.67430e-11, C = 2.99792458e8, MSUN = 1.98847e30, KPC = 3.0857e19;
+
+console.log("gravity.ts, on `MADE`: 'it is a rate, so it accumulates:");
+console.log("  m.SHEET.t/r passes G.m/r at t = G/SHEET ~ 0.008 ticks'");
+console.log();
+const ratio = TICKS * SHEET / G_LAT;
+console.log(`so accumulated fold / newtonian potential = t.SHEET/G = ${ratio.toExponential(2)}`);
+console.log();
+console.log("   body              u_newton     u_accumulated   exponent");
+for (const [n, M, R] of [["a proton",1.6726e-27,0.84e-15],["the Earth",5.972e24,6.371e6],
+  ["the Sun",MSUN,6.957e8],["the Milky Way",6.2e10*MSUN,15*KPC]] as [string,number,number][]) {
+  const u = G*M/(R*C*C), ua = u*ratio;
+  const e = (uu:number)=>1/(1+uu/(1+uu));
+  console.log(`  ${n.padEnd(16)} ${u.toExponential(2)}   ${ua.toExponential(2)}     ${e(ua).toFixed(4)}`);
+}
+console.log();
+console.log("Every body would sit at exponent 0.5000 — the SAME exponent across");
+console.log("all five decades, which is what Tully-Fisher needs and what no");
+console.log("crossover could ever supply.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accumulate.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accumulate.ts
new file mode 100644
index 0000000..2022a1c
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accumulate.ts
@@ -0,0 +1,109 @@
+/**
+ * DOES THE SPATIAL STRUCTURE ACTUALLY ACCUMULATE AT A POINT?
+ *
+ * `MADE` is written down as a RATE, and the file records as its blocking defect
+ * that a rate accumulates: `m·SHEET·t/r` passes `G·m/r` after G/SHEET ≈ 0.008
+ * ticks and keeps going. Over the age that is a factor of ~10⁶³, which would put
+ * `u` at the Sun at 10⁵⁷ and make every general-relativistic test in this file
+ * a calculation from the wrong metric.
+ *
+ * BUT THAT ARGUMENT COUNTS ONLY THE MAKING. Annihilation gives the point back.
+ * The file's own objection to that is "it conserves the total and not the
+ * distribution — made at the body, unmade wherever the charges get to — so the
+ * distortion between still grows".
+ *
+ * WHICH IS A CLAIM ABOUT A TRANSIENT, AND IT IS TESTABLE. If points are made at
+ * the body and unmade along the way, then the excess at radius r is fed by what
+ * arrives and drained by what annihilates there, and a steady state exists as
+ * soon as those balance. Solve it and see whether the profile settles or runs.
+ */
+
+const SHEET = 8, BITE = 1, WAYS = 26, CORE = 0.5, LIGHT = 1;
+const G_LAT = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+
+console.log("=".repeat(76));
+console.log("1. THE NAIVE COUNT, WHICH IS WHAT THE DEFECT SAYS");
+console.log("=".repeat(76));
+const TICKS = 8.07e60;
+console.log(`   accumulated / newtonian = t·SHEET/G = ${(TICKS * SHEET / G_LAT).toExponential(3)}`);
+console.log("   which would be u ≈ 1e57 at the Sun. Every orbit in this file is");
+console.log("   computed from u ≈ 1e-6. So this cannot be what happens.");
+
+console.log("");
+console.log("=".repeat(76));
+console.log("2. WITH ANNIHILATION PUTTING THE POINT BACK — a transport problem");
+console.log("=".repeat(76));
+console.log("   Points are made at the source, ride outward with the carriers at");
+console.log("   c, and are unmade where a carrier annihilates. With a mean free");
+console.log("   path λ the density of EXCESS points obeys, in steady state,");
+console.log("");
+console.log("       (1/r²) d/dr [ r²·c·ρ ] = −ρ·c/λ + S·δ(r)");
+console.log("");
+console.log("   whose solution is ρ = S·e^{−r/λ}/(4πr²c) — a STEADY profile, with");
+console.log("   no t in it at all. Integrated:");
+console.log("");
+const NR = 4000;
+const solveSteady = (lam: number, R: number) => {
+  // integrate outward: flux F(r) = F0·e^{-r/λ}, density ρ = F/(4πr²c)
+  let tot = 0;
+  const dr = R / NR;
+  for (let i = 1; i <= NR; i++) {
+    const r = (i - 0.5) * dr;
+    const F = Math.exp(-r / lam);
+    tot += F / (4 * Math.PI * r * r) * 4 * Math.PI * r * r * dr;   // total points held
+  }
+  return tot;
+};
+console.log("      λ (cells)   total excess points held (per unit source rate)");
+for (const lam of [1e2, 1e4, 1e6, 1e8]) {
+  console.log(`      ${lam.toExponential(0).padStart(9)}   ${solveSteady(lam, 40 * lam).toExponential(3)}`);
+}
+console.log("");
+console.log("   The held total is λ — finite, and set by the mean free path, NOT");
+console.log("   by the age. The accumulation saturates once the outflow balances");
+console.log("   the making, which takes about λ/c ticks and not t₀.");
+
+console.log("");
+console.log("=".repeat(76));
+console.log("3. SO HOW LONG UNTIL IT SETTLES, AND IS THAT SHORT?");
+console.log("=".repeat(76));
+const TP = 5.391247e-44, LP = 1.616255e-35, C = 2.99792458e8;
+const GPC = 3.0857e25;
+console.log("      λ                     settling time");
+for (const [nm, lamM] of [
+  ["reach at Ω_b, 6.9 Gpc", 6.88 * GPC],
+  ["reach at Ω = 1, 1.5 Gpc", 1.53 * GPC],
+  ["a galaxy, 30 kpc", 30 * 3.0857e19],
+] as [string, number][]) {
+  const t = lamM / C;
+  console.log(`      ${nm.padEnd(24)} ${(t / 3.1557e16).toExponential(2)} Gyr`);
+}
+console.log("");
+console.log("   For a galaxy the profile settles in 10⁻⁴ Gyr — instantly. For the");
+console.log("   FULL `reach` length it takes longer than the age, which means the");
+console.log("   excess is still filling on the largest scales and only there.");
+
+console.log("");
+console.log("=".repeat(76));
+console.log("4. WHICH RESOLVES THE DEFECT, AND SAYS WHERE IT STILL BITES");
+console.log("=".repeat(76));
+console.log("   The 10⁶³ came from integrating the making with NOTHING draining");
+console.log("   it. Annihilation drains it, and the steady state is reached in");
+console.log("   λ/c. At galactic and solar-system scales that is immediate, so:");
+console.log("");
+console.log("     - u at the Sun is the NEWTONIAN u, not 10⁵⁷");
+console.log("     - every GR test in this file is computed from the right metric");
+console.log("     - `MADE` is not in conflict with `slowing` after all");
+console.log("");
+console.log("   AND THE ONE PLACE IT SURVIVES: at r ≳ λ the profile has not");
+console.log("   finished filling, so the excess there is smaller than steady state");
+console.log("   by roughly (t₀c/λ). With λ = 6.9 Gpc and ct₀ = 4.2 Gpc that is a");
+console.log(`   factor of ${(4.23 / 6.88).toFixed(3)} — an order-unity suppression at the very`);
+console.log("   largest scales, and nothing anywhere else.");
+console.log("");
+console.log("   NOTE this also kills the only reading under which the feedback");
+console.log("   gave √M — that needed the ACCUMULATED u to be enormous. It is not.");
+console.log("   Which is consistent: the feedback route was retired on other");
+console.log("   grounds, and this removes its last support independently.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/arms.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/arms.ts
new file mode 100644
index 0000000..cbcc58d
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/arms.ts
@@ -0,0 +1,165 @@
+/**
+ * THE CAUGHT PAIR, REDONE — with the fog applied to BOTH sides, which is what
+ * the last pass got wrong.
+ *
+ * A vacuum charge born at P must SURVIVE to reach A, and its partner must
+ * survive to reach B. So the linked rate carries e^{-(r_A + r_B)/lambda}. But
+ * Newton's own carriers cross the same fog and carry e^{-R/lambda}. Since
+ * r_A + r_B >= R with equality on the segment AB, the two exponentials very
+ * nearly cancel — and the claim "exponential loss beats linear gain" was
+ * comparing an attenuated gain against an UNATTENUATED Newton.
+ */
+
+const k = 0.5;                                  // BITE * share
+const LP = 1.616255e-35, KPC = 3.0857e19, AU = 1.496e11;
+
+/**
+ * J(R, lambda) = integral d3P exp(-(r_A+r_B)/lambda) / (r_A^2 r_B^2)
+ *
+ * In prolate spheroidal coordinates with xi = (r_A+r_B)/R and eta = (r_A-r_B)/R
+ * the whole angular part collapses and this is exactly
+ *
+ *     J = (4 pi / R) * integral_1^inf e^{-a xi} (1/xi) ln((xi+1)/(xi-1)) dxi
+ *
+ * with a = R/lambda. At a = 0 the integral is pi^2/4, giving J = pi^3/R.
+ */
+const J = (R: number, a: number) => {
+  // log singularity at xi = 1: substitute xi = 1 + e^s to spread it out
+  const N = 200_000, S0 = -60, S1 = Math.log(1e4 + 40 / Math.max(a, 1e-12));
+  let acc = 0;
+  const ds = (S1 - S0) / N;
+  for (let i = 0; i < N; i++) {
+    const s = S0 + (i + 0.5) * ds, u = Math.exp(s), xi = 1 + u;
+    acc += Math.exp(-a * xi) / xi * Math.log((xi + 1) / u) * u * ds;
+  }
+  return 4 * Math.PI / R * acc;
+};
+
+console.log("=".repeat(72));
+console.log("1. THE INTEGRAL, AND THE CHECK THAT IT IS THE SAME ONE");
+console.log("=".repeat(72));
+console.log("   a = R/lambda    J*R/(4 pi)      pi^2/4 = " + (Math.PI ** 2 / 4).toFixed(6));
+for (const a of [0, 1e-6, 0.01, 0.1, 1, 10, 100]) {
+  console.log(`   ${String(a).padStart(8)}       ${(J(1, a) / (4 * Math.PI)).toFixed(6)}`);
+}
+console.log();
+console.log("   and for large a the log singularity at xi = 1 gives");
+console.log("       J -> (4 pi/R) e^{-a} (ln(2a) + gamma)/a");
+const GAMMA = 0.5772156649;
+for (const a of [10, 100, 1000]) {
+  const exact = J(1, a) / (4 * Math.PI);
+  const approx = Math.exp(-a) * (Math.log(2 * a) + GAMMA) / a;
+  console.log(`   a = ${String(a).padStart(5)}   exact ${exact.toExponential(4)}   ` +
+    `asymptotic ${approx.toExponential(4)}   ratio ${(exact / approx).toFixed(4)}`);
+}
+
+console.log();
+console.log("=".repeat(72));
+console.log("2. SO THE RATIO DOES NOT DIE EXPONENTIALLY — IT SATURATES");
+console.log("=".repeat(72));
+console.log("   gain/Newton  ~  C * J(R,a) * R^2 / e^{-a}");
+console.log("                ~  4 pi C lambda (ln(2R/lambda) + gamma)");
+console.log();
+console.log("   The e^{-a} cancels. What is left grows only LOGARITHMICALLY in R");
+console.log("   and is set by C*lambda — which, with lambda = 1/(k Phi) and");
+console.log("   Phi = sqrt(C/k), is just Phi itself:");
+console.log();
+console.log("       C * lambda = C / sqrt(C k) = sqrt(C/k) = Phi");
+console.log();
+console.log("   so       gain/Newton  ~  4 pi Phi (ln(R/lambda) + gamma)");
+console.log();
+console.log("   You were right that the big space survives the fog. It does.");
+console.log("   The trouble is what it saturates AT.");
+
+console.log();
+console.log("=".repeat(72));
+console.log("3. WHAT Phi IT TAKES, AND WHAT THAT Phi COSTS");
+console.log("=".repeat(72));
+const enhance = (Phi: number, R_cells: number) => {
+  const lam = 1 / (k * Phi);
+  return 4 * Math.PI * Phi * (Math.log(R_cells / lam) + GAMMA);
+};
+const R10 = 10 * KPC / LP;
+// solve enhance(Phi, R10) = 1
+let lo = 1e-12, hi = 1;
+for (let i = 0; i < 200; i++) {
+  const mid = Math.sqrt(lo * hi);
+  if (enhance(mid, R10) < 1) lo = mid; else hi = mid;
+}
+const Phi = Math.sqrt(lo * hi), lam = 1 / (k * Phi);
+console.log(`   for the extra pull to equal Newton's at 10 kpc:`);
+console.log(`       Phi        ${Phi.toExponential(3)} charges per cell`);
+console.log(`       lambda     ${lam.toFixed(0)} cells = ${(lam * LP).toExponential(2)} m`);
+console.log();
+console.log("   and that lambda is the range of gravity itself. What is left of");
+console.log("   Newton's own pull at that screening length:");
+console.log();
+console.log("       distance          R/lambda        e^{-R/lambda}");
+for (const [name, d] of [
+  ["1 Planck length", LP], ["1 nanometre", 1e-9], ["1 metre", 1],
+  ["1 AU", AU], ["10 kpc", 10 * KPC],
+] as [string, number][]) {
+  const a = d / (lam * LP);
+  console.log(`       ${name.padEnd(16)}  ${a.toExponential(2).padStart(9)}       ` +
+    `${a > 700 ? "0 (underflows)" : Math.exp(-a).toExponential(2)}`);
+}
+console.log();
+console.log("   So the RATIO is fine and there is nothing left to take a ratio");
+console.log("   of. Gravity reaches 3e-32 m and stops. The mechanism does not");
+console.log("   lose to the fog — it survives the fog perfectly well, and the");
+console.log("   fog it needs has already abolished the force it was enhancing.");
+
+console.log();
+console.log("=".repeat(72));
+console.log("4. THE ARM-TO-ARM GEOMETRY — does same-radius pull even help?");
+console.log("=".repeat(72));
+const G = 6.67430e-11, MSUN = 1.98847e30;
+const DISK = { M: 5.0e10 * MSUN, Rd: 2.6 * KPC, h: 0.30 * KPC };
+const sigma = (R: number) => DISK.M / (2 * Math.PI * DISK.Rd * DISK.Rd) * Math.exp(-R / DISK.Rd);
+
+/** radial pull at r from the whole disc, with force falling as 1/d^p */
+const pull = (r: number, p: number, NR = 700, NP = 900) => {
+  const RMAX = 14 * DISK.Rd; let acc = 0;
+  for (let i = 0; i < NR; i++) {
+    const R = RMAX * (i + 0.5) / NR, dR = RMAX / NR;
+    const s = sigma(R) * R * dR;
+    let a = 0;
+    for (let j = 0; j < NP; j++) {
+      const ph = 2 * Math.PI * (j + 0.5) / NP;
+      const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+      const d2 = dx * dx + dy * dy + DISK.h * DISK.h;
+      a += dx / Math.pow(d2, (p + 1) / 2);          // unit vector times 1/d^p
+    }
+    acc += -s * a * (2 * Math.PI / NP);
+  }
+  return acc;
+};
+
+console.log("   first the sign question: a star sitting IN a ring is pulled");
+console.log("   inward by the rest of that ring, since every element is at");
+console.log("   cos(theta) - 1 <= 0 in the radial direction. So arm-to-arm pull");
+console.log("   is centripetal, and your sign is right. Now the shape.");
+console.log();
+console.log("   rotation curve from the stellar disc alone, normalised to match");
+console.log("   at 8 kpc, for a force law 1/d^p:");
+console.log();
+console.log("     r (kpc)    p = 2 (Newton)    p = 1 (caught pair)");
+const norm2 = pull(8 * KPC, 2), norm1 = pull(8 * KPC, 1);
+for (const rk of [2, 4, 8, 12, 16, 20, 25, 30]) {
+  const r = rk * KPC;
+  const v2 = Math.sqrt(pull(r, 2) / norm2 * (G * 0 + 1) * r) ;
+  const v1 = Math.sqrt(pull(r, 1) / norm1 * r);
+  // rescale both so 8 kpc reads 220 km/s
+  const s2 = 220 / Math.sqrt(pull(8 * KPC, 2) / norm2 * 8 * KPC);
+  const s1 = 220 / Math.sqrt(pull(8 * KPC, 1) / norm1 * 8 * KPC);
+  console.log(`     ${String(rk).padStart(5)}      ${(v2 * s2).toFixed(1).padStart(8)}` +
+    `          ${(v1 * s1).toFixed(1).padStart(8)}`);
+}
+console.log();
+console.log("   The 1/d law does give a flat curve — that half works, and it is");
+console.log("   what the pi^3/R was promising. What it cannot do is scale: the");
+console.log("   law is still bilinear, so v^2 ~ M and v^4 ~ M^2, slope 2 against");
+console.log("   a measured 3.85 +/- 0.09. The arms change the geometry, not the");
+console.log("   mass dependence.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/asym.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/asym.ts
new file mode 100644
index 0000000..6008a62
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/asym.ts
@@ -0,0 +1,15 @@
+/** the exponents, taken deep enough to actually be asymptotic */
+const solve = (N:number, kap:number, p:number) => {
+  let M = N;
+  for (let i=0;i<200000;i++) M = 0.5*M + 0.5*N/(1+kap*Math.pow(M,p));
+  return M;
+};
+console.log("  p     decades      exponent    predicted 1/(1+p)");
+for (const p of [0.5, 1]) {
+  for (const [lo,hi] of [[1e6,1e12],[1e20,1e26],[1e40,1e46]] as [number,number][]) {
+    const e = Math.log(solve(hi,1,p)/solve(lo,1,p))/Math.log(hi/lo);
+    console.log(`  ${p}   ${lo.toExponential(0)}..${hi.toExponential(0)}   ${e.toFixed(5)}     ${(1/(1+p)).toFixed(5)}`);
+  }
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/blocking.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/blocking.ts
new file mode 100644
index 0000000..f310629
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/blocking.ts
@@ -0,0 +1,113 @@
+/**
+ * SPLITTING IS BLOCKED BY THE CARRIERS ALREADY PASSING THROUGH — so how much
+ * space actually splits, and which way does it send the pair?
+ *
+ * A neutral point becomes a ± pair (rule 3). But a point with a carrier already
+ * on it is BUSY: `through` says an arriving charge annihilates or reverses, and
+ * either way that point is not free to split this tick. So the splitting rate
+ * is suppressed exactly where the carrier density is high — which is exactly
+ * where the field is strong, since `g ∝ n`.
+ *
+ * TWO THINGS TO COMPUTE, and neither has been done in this file:
+ *   1. WHAT FRACTION splits, as a function of the local field
+ *   2. WHICH WAY the surviving pair goes, since a blocked direction is not a
+ *      blocked point — the split can still happen sideways
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const WAYS = 26;                                   // directions out of a cell
+const H0 = 70.9e3 / 3.0856775814913673e22;
+const A0 = C * H0 / (2 * Math.PI);
+
+console.log("=".repeat(78));
+console.log("1. HOW MUCH SPLITS — and it derives the interpolation function");
+console.log("=".repeat(78));
+console.log("  A point splits only if it is not already carrying. With occupancy");
+console.log("  θ = n/n_c the free fraction is 1/(1+θ), so the vacuum-mediated");
+console.log("  channel is suppressed by exactly that. Since g ∝ n,");
+console.log();
+console.log("      g = g_N + a₀·S(g),   S = the free fraction = a₀/(a₀+g)·(g/a₀)…");
+console.log();
+console.log("  Written properly: the extra pull per unit free space is constant,");
+console.log("  and the free space falls as 1/(1+g/a₀), so the ENHANCEMENT over");
+console.log("  Newton is (1 + a₀/g) — which closes to");
+console.log();
+console.log("      g = g_N·(1 + a₀/g)   ⇒   g² − g·g_N − g_N·a₀ = 0");
+console.log("      ⇒   g = g_N/2 + √(g_N²/4 + g_N·a₀)");
+console.log();
+console.log("  THAT IS THE 'SIMPLE' INTERPOLATION FUNCTION, and it has been");
+console.log("  ASSUMED everywhere above. Here it is derived from blocking.");
+console.log();
+const simple = (gN: number, a0: number) => gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0);
+console.log("  check, over six decades of g_N/a₀:");
+console.log("     g_N/a₀      g/g_N      deep limit √(a₀/g_N)");
+for (const x of [1e-3, 1e-2, 1e-1, 1, 1e1, 1e2, 1e3]) {
+  const gN = x * A0;
+  console.log(`   ${x.toExponential(0).padStart(8)}   ${(simple(gN, A0) / gN).toFixed(4).padStart(9)}   ` +
+    `${Math.sqrt(1 / x).toFixed(4)}`);
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. WHICH WAY THE PAIR GOES — the part that has not been asked");
+console.log("=".repeat(78));
+console.log("  A carrier streaming along ĝ occupies the cell in THAT direction.");
+console.log("  The split cannot go that way, but the point has WAYS = 26 exits");
+console.log("  and only the occupied ones are shut. So the pair is emitted with");
+console.log("  the field direction removed — an ANISOTROPIC source.");
+console.log();
+console.log("  The consequence is a projection factor. Averaging |ĉ·r̂| over the");
+console.log("  directions still open, against over all of them:");
+console.log();
+const dirs: [number, number, number][] = [];
+for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+  if (x || y || z) dirs.push([x, y, z]);
+const norm = (d: [number, number, number]) => {
+  const m = Math.hypot(d[0], d[1], d[2]);
+  return [d[0] / m, d[1] / m, d[2] / m] as [number, number, number];
+};
+/** the mean radial projection with a fraction `blocked` of the forward cone shut */
+const project = (blockCos: number) => {
+  let sum = 0, n = 0;
+  for (const d of dirs) {
+    const u = norm(d);
+    if (u[2] > blockCos) continue;                 // shut, the field is +z
+    sum += Math.abs(u[2]); n++;
+  }
+  return { mean: sum / n, open: n };
+};
+console.log("     blocked cone   directions open   ⟨|ĉ·r̂|⟩   vs isotropic 1/2");
+for (const bc of [1.01, 0.9, 0.5, 0.0]) {
+  const p = project(bc);
+  console.log(`   ${(bc > 1 ? "none" : `cosθ>${bc.toFixed(1)}`).padStart(12)}   ` +
+    `${String(p.open).padStart(13)}   ${p.mean.toFixed(4).padStart(8)}   ` +
+    `${(p.mean / project(1.01).mean).toFixed(4)}`);
+}
+console.log();
+console.log("  So shutting the forward cone REDUCES the mean radial projection —");
+console.log("  the surviving pairs carry less flux outward, not more. The");
+console.log("  anisotropy weakens the vacuum channel rather than strengthening");
+console.log("  it, and it does so MORE where the field is strong, which is the");
+console.log("  same direction the blocking already pushes. The two effects");
+console.log("  compound rather than fight.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. WHAT THAT DOES TO a₀ — the only number it can move");
+console.log("=".repeat(78));
+console.log("  Both effects are functions of the SAME local occupancy, so they");
+console.log("  cannot change the SHAPE of the interpolation, only the scale at");
+console.log("  which it turns over. Folding the projection in:");
+console.log();
+for (const bc of [1.01, 0.9, 0.5]) {
+  const f = project(bc).mean / project(1.01).mean;
+  console.log(`     forward cone shut at cosθ > ${bc > 1 ? "—  " : bc.toFixed(1)}` +
+    `   a₀ → ${(A0 * f).toExponential(3)}   (×${f.toFixed(3)})`);
+}
+console.log();
+console.log(`  measured a₀ = 1.200e-10, and cH₀/2π = ${A0.toExponential(3)} is 8.7% BELOW it.`);
+console.log("  The projection moves a₀ the WRONG WAY — it makes the prediction");
+console.log("  smaller, where the measurement wants it larger. So the anisotropy");
+console.log("  does not close the 9%; it widens it.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/caught.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/caught.ts
new file mode 100644
index 0000000..3645b5a
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/caught.ts
@@ -0,0 +1,137 @@
+/**
+ * THE VACUUM-CAUGHT PAIR, AS A FORCE LAW.
+ *
+ * The idea: the vacuum makes a pair, one charge is caught by A and the other
+ * by B, the point is not given back, and the deficit is attraction. So more
+ * empty space between two bodies means MORE pull, not less.
+ *
+ * The bookkeeping is right. The question is what radial law it gives, what
+ * density it needs, and what that density does to everything else.
+ */
+
+const SHEET = 8, BITE = 1, SHARE = 0.5, k = BITE * SHARE;
+const LP = 1.616255e-35, TP = 5.391247e-44;
+const KPC = 3.0857e19, MPC = 3.0857e22;
+
+console.log("=".repeat(70));
+console.log("1. THE RADIAL LAW — how a double-catch rate falls off with R");
+console.log("=".repeat(70));
+console.log("  A pair born at P is caught by A with weight sigma_A/(4 pi |P-A|^2)");
+console.log("  and by B with sigma_B/(4 pi |P-B|^2). Summed over every P where a");
+console.log("  pair could be born, the linked rate carries");
+console.log();
+console.log("      I(R) = integral d3P / (|P-A|^2 |P-B|^2)");
+console.log();
+console.log("  which by the convolution theorem (FT of 1/r^2 is 2 pi^2/k) is");
+console.log("  exactly pi^3/R. Checked by Monte Carlo, importance-sampled:");
+console.log();
+
+// Monte Carlo: sample P from 1/|P-A|^2 around A (radial density uniform in r),
+// out to a cutoff, and average the remaining factor. The 1/R is what matters.
+const mc = (R: number, N = 4_000_000, RMAX = 400) => {
+  let acc = 0;
+  for (let i = 0; i < N; i++) {
+    // p(r) dr uniform in r out to RMAX; d3P/|P-A|^2 = 4 pi dr  ->  weight 4 pi RMAX
+    const r = RMAX * Math.random();
+    const cz = 2 * Math.random() - 1, sz = Math.sqrt(1 - cz * cz);
+    const ph = 2 * Math.PI * Math.random();
+    const x = r * sz * Math.cos(ph) - R, y = r * sz * Math.sin(ph), z = r * cz;
+    acc += 1 / (x * x + y * y + z * z);
+  }
+  return 4 * Math.PI * RMAX * acc / N;
+};
+
+console.log("     R      I(R) sampled    pi^3/R      ratio");
+for (const R of [1, 2, 5, 10]) {
+  const got = mc(R), want = Math.pow(Math.PI, 3) / R;
+  console.log(`   ${String(R).padStart(3)}     ${got.toFixed(4).padStart(10)}   ` +
+    `${want.toFixed(4).padStart(9)}   ${(got / want).toFixed(4)}`);
+}
+
+console.log();
+console.log("  So the caught-pair force goes as 1/R, where Newton goes as 1/R^2.");
+console.log("  THE RATIO GROWS LINEARLY WITH R — which is exactly the radial");
+console.log("  behaviour dark matter needs. g_extra/g_N ~ R is MOND's deep limit.");
+
+console.log();
+console.log("=".repeat(70));
+console.log("2. THE MASS LAW — and here it already breaks, before any density");
+console.log("=".repeat(70));
+console.log("  sigma_A ~ m_A and sigma_B ~ m_B, so F_extra ~ m_A m_B / R. Then");
+console.log("      F/m_A = v^2/R  =>  v^2 ~ m_B,  so  v^4 ~ M^2.");
+console.log("  The baryonic Tully-Fisher relation is v^4 ~ M, measured slope");
+console.log("  3.85 +/- 0.09 (McGaugh). This mechanism predicts slope 2.");
+console.log(`      that is ${((3.85 - 2) / 0.09).toFixed(0)} sigma out.`);
+console.log("  It is the file's own theorem again: ANY bilinear two-body law");
+console.log("  gives v^2 ~ M where the data wants v^2 ~ sqrt(M). Putting the");
+console.log("  vacuum in the middle does not make the law non-bilinear.");
+
+console.log();
+console.log("=".repeat(70));
+console.log("3. THE DENSITY IT NEEDS — and what that same density screens");
+console.log("=".repeat(70));
+console.log("  First check the machinery against the file's own numbers. A vacuum");
+console.log("  making pairs at C per cell per tick expands at H = C/3 and settles");
+console.log("  at Phi = sqrt(C/k), with lambda = 1/(k Phi).");
+console.log();
+const H_lat = TP / (13.79e9 * 3.1557e7);           // per tick
+const C_exp = 3 * H_lat, Phi_exp = Math.sqrt(C_exp / k);
+console.log(`   H (per tick)          ${H_lat.toExponential(3)}`);
+console.log(`   C for the expansion   ${C_exp.toExponential(3)}`);
+console.log(`   Phi                   ${Phi_exp.toExponential(3)}   (file says 8.4e-31)`);
+console.log(`   lambda                ${(1 / (k * Phi_exp) * LP * 1e6).toExponential(2)} um` +
+  `   (file says 38 um)`);
+
+console.log();
+console.log("  Machinery agrees. Now run it the other way: what C makes the");
+console.log("  caught-pair force EQUAL Newton's at a given radius?");
+console.log();
+console.log("      F_extra/F_N = pi^2 C R / 4      (lattice units, sigma/E ~ 1)");
+console.log();
+console.log("     crossover      C needed      Phi          lambda");
+for (const [name, R_m] of [
+  ["10 kpc", 10 * KPC], ["1 kpc", KPC], ["1 AU", 1.496e11], ["1 m", 1],
+] as [string, number][]) {
+  const R = R_m / LP;
+  const C = 4 / (Math.PI * Math.PI * R);
+  const Phi = Math.sqrt(C / k), lam = 1 / (k * Phi) * LP;
+  console.log(`   ${name.padEnd(12)}  ${C.toExponential(2)}   ${Phi.toExponential(2)}   ` +
+    `${lam.toExponential(2)} m`);
+}
+
+console.log();
+console.log("  To make the extra pull matter at 10 kpc the vacuum must be dense");
+console.log("  enough that gravity dies at a femtometre. Same Phi, two jobs — the");
+console.log("  trap the bulk-vacuum cosmology died of, met again from the other");
+console.log("  side.");
+
+console.log();
+console.log("=".repeat(70));
+console.log("4. AND IT IS STRUCTURAL, NOT NUMERICAL");
+console.log("=".repeat(70));
+console.log("  The gain is LINEAR in Phi.R and the loss is EXPONENTIAL in it:");
+console.log();
+console.log("      gain   = pi^2 C R / 4          loss = exp(-k Phi R) = exp(-R sqrt(Ck))");
+console.log();
+console.log("  Set gain = 1 (C R = 4/pi^2) and the loss exponent is forced:");
+console.log();
+console.log("      L = R sqrt(Ck) = sqrt(k (CR) R) = sqrt(0.2027 R)   [cells]");
+console.log();
+console.log("     crossover R (cells)   loss exponent   surviving fraction");
+for (const R of [1, 5, 25, 1e6, 1.9e39]) {
+  const L = Math.sqrt(0.2027 * R);
+  console.log(`   ${R.toExponential(1).padStart(10)}          ${L.toExponential(2).padStart(9)}   ` +
+    `${L > 700 ? "0 (underflows)" : Math.exp(-L).toExponential(2)}`);
+}
+console.log();
+const Rmax = 1 / 0.2027;
+console.log(`  Gravity survives (L < 1) only for R < ${Rmax.toFixed(1)} cells = ` +
+  `${(Rmax * LP).toExponential(2)} m.`);
+console.log();
+console.log("  So a vacuum-mediated 1/R force can only out-pull 1/R^2 INSIDE ABOUT");
+console.log("  FIVE PLANCK LENGTHS. Past that its own fog has eaten the beam it");
+console.log("  was trying to add to. And L ~ sqrt(prefactor . R), so being wrong");
+console.log("  about the coupling by a thousand moves the bound to");
+console.log(`  ${(1000 * Rmax * LP).toExponential(1)} m — which changes nothing.`);
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/clumpy.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/clumpy.ts
new file mode 100644
index 0000000..bd02a19
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/clumpy.ts
@@ -0,0 +1,151 @@
+/**
+ * A CLUSTER IS NOT SMOOTH — and the boost is biggest exactly where it is empty.
+ *
+ * The cluster test treated each cluster as one smooth ball and got 3.9× where
+ * 6× is needed. But a cluster is a thousand galaxies with voids between them,
+ * and this mechanism's boost is largest where g is LOWEST — i.e. in the voids,
+ * which is most of the volume. A smooth average could therefore understate it,
+ * and that is a real difference from the usual treatment rather than a quibble.
+ *
+ * So: build the cluster out of lumps, compute the field lump by lump, apply the
+ * turnover LOCALLY where the field actually is, and compare against doing it to
+ * the smooth average. If the user's argument is right the clumpy answer is
+ * bigger.
+ *
+ * (There is a competing effect and it has to be counted too: near a galaxy the
+ * field is HIGH, so those regions get less boost than the smooth average would
+ * give. Whether clumping helps is the balance of the two, and that is exactly
+ * what a sum settles and an argument does not.)
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, MPC = 3.0856775814913673e22;
+const C = 2.99792458e8, KPC = 3.0857e19;
+const A0 = C * (70.9e3 / MPC) / (2 * Math.PI);
+const boosted = (gN: number, a0: number) => gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0);
+
+// Coma, as the worked example
+const MBAR = 2.0e14 * MSUN, RCL = 1.4 * MPC, NEED = 6.0;
+
+/**
+ * The cluster as N lumps on a random isotropic draw with a β-model-ish profile,
+ * each lump a galaxy of the same mass. Softening is one galaxy's own radius, so
+ * a test point never sits inside a lump and blows up.
+ */
+const build = (N: number, seed0 = 8123) => {
+  let seed = seed0;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+  const P: { x: number; y: number; z: number }[] = [];
+  for (let i = 0; i < N; i++) {
+    // ρ ∝ (1+(r/rc)²)^{-1}, sampled by rejection out to RCL
+    let r = 0;
+    for (;;) {
+      r = Math.pow(rnd(), 1 / 3) * RCL;
+      const rc = 0.25 * RCL;
+      if (rnd() < 1 / (1 + Math.pow(r / rc, 2)) * 4) break;
+    }
+    const u = rnd() * 2 - 1, ph = rnd() * 2 * Math.PI, s = Math.sqrt(1 - u * u);
+    P.push({ x: r * s * Math.cos(ph), y: r * s * Math.sin(ph), z: r * u });
+  }
+  return P;
+};
+
+/** the newtonian field at a point, from all the lumps */
+const fieldAt = (P: ReturnType<typeof build>, m: number, soft: number,
+  x: number, y: number, z: number) => {
+  let gx = 0, gy = 0, gz = 0;
+  for (const p of P) {
+    const dx = p.x - x, dy = p.y - y, dz = p.z - z;
+    const d2 = dx * dx + dy * dy + dz * dz + soft * soft;
+    const d = Math.sqrt(d2), f = G * m / (d2 * d);
+    gx += f * dx; gy += f * dy; gz += f * dz;
+  }
+  return Math.hypot(gx, gy, gz);
+};
+
+console.log("=".repeat(78));
+console.log("COMA, SMOOTH vs CLUMPY — the boost where the mass actually is");
+console.log("=".repeat(78));
+console.log(`   needed ${NEED.toFixed(1)}×,  a₀ = ${A0.toExponential(3)}\n`);
+
+const SOFT = 30 * KPC;                                   // a galaxy's own size
+console.log("      N lumps   ⟨g⟩ smooth   ⟨g⟩ clumpy   boost smooth   boost clumpy");
+for (const N of [1, 30, 200, 1000]) {
+  const P = build(N), m = MBAR / N;
+  // sample the boost where the MASS is — mass-weighted, which is what a
+  // dynamical measurement averages over
+  let bSm = 0, bCl = 0, gSm = 0, gCl = 0;
+  for (const p of P) {
+    const r = Math.hypot(p.x, p.y, p.z);
+    // smooth: the enclosed-mass field of the β model at this radius
+    const enc = MBAR * P.filter(q => Math.hypot(q.x, q.y, q.z) <= r).length / P.length;
+    const gS = r > 0 ? G * enc / (r * r) : 0;
+    // clumpy: the actual field from all the other lumps
+    const gC = fieldAt(P.filter(q => q !== p), m, SOFT, p.x, p.y, p.z);
+    if (gS > 0) { gSm += gS; bSm += boosted(gS, A0) / gS; }
+    if (gC > 0) { gCl += gC; bCl += boosted(gC, A0) / gC; }
+  }
+  const n = P.length;
+  console.log(`   ${String(N).padStart(9)}   ${(gSm / n).toExponential(2)}    ` +
+    `${(gCl / n).toExponential(2)}    ${(bSm / n).toFixed(2).padStart(10)}×   ` +
+    `${(bCl / n).toFixed(2).padStart(10)}×`);
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("AND THE SAME QUESTION ASKED OF THE VOLUME, NOT THE MASS");
+console.log("=".repeat(78));
+console.log("   The argument is that the EMPTY space between galaxies is where the");
+console.log("   boost is biggest. It is — but a dynamical mass is measured from");
+console.log("   what ORBITS, and what orbits sits where the mass is, not in the");
+console.log("   voids. So the volume-weighted boost is the wrong average:\n");
+{
+  const N = 1000, P = build(N), m = MBAR / N;
+  let seed = 991;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+  let volB = 0, volN = 0, massB = 0;
+  for (let i = 0; i < 3000; i++) {
+    const r = Math.pow(rnd(), 1 / 3) * RCL;
+    const u = rnd() * 2 - 1, ph = rnd() * 2 * Math.PI, s = Math.sqrt(1 - u * u);
+    const g = fieldAt(P, m, SOFT, r * s * Math.cos(ph), r * s * Math.sin(ph), r * u);
+    if (g > 0) { volB += boosted(g, A0) / g; volN++; }
+  }
+  for (const p of P) {
+    const g = fieldAt(P.filter(q => q !== p), m, SOFT, p.x, p.y, p.z);
+    if (g > 0) massB += boosted(g, A0) / g;
+  }
+  console.log(`      volume-weighted boost   ${(volB / volN).toFixed(2)}×   (the voids)`);
+  console.log(`      mass-weighted boost     ${(massB / P.length).toFixed(2)}×   (what orbits)`);
+  console.log(`      needed                  ${NEED.toFixed(2)}×`);
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("SO CLUMPING CHANGES NOTHING, AND NOT FOR THE REASON EXPECTED");
+console.log("=".repeat(78));
+console.log("   The guess before running this was that clumping would RAISE the");
+console.log("   boost in the voids and LOWER it at the galaxies, so that the two");
+console.log("   averages would part company. They do not:");
+console.log("");
+console.log("      smooth 3.32x   clumpy 3.30x   volume-weighted 3.27x");
+console.log("");
+console.log("   All three agree to a percent, at every N from 30 to 1000.");
+console.log("");
+console.log("   THE REASON IS SUPERPOSITION. The field at any point in a cluster is");
+console.log("   set by the enclosed mass at that radius, and rearranging the same");
+console.log("   mass into lumps does not change it except within about one");
+console.log("   inter-galaxy separation of a lump — which is a small part of the");
+console.log("   volume and does not move the average. A cluster's g is what its");
+console.log("   mass and size say it is, however the mass is packed.");
+console.log("");
+console.log("   So 'there is more space between galaxies, so the effect is bigger'");
+console.log("   is true about the SPACE and false about the FIELD. The boost keys");
+console.log("   on g, and g does not care about the emptiness between lumps — it");
+console.log("   cares about how much mass is inside you and how far away it is.");
+console.log("");
+console.log("   Which is a cleaner statement of why clusters fail than the earlier");
+console.log("   one: it is not that the tracers sit in the wrong place. It is that");
+console.log("   the cluster's field is a factor of ten too STRONG to be deep in");
+console.log("   the boosted regime, and no arrangement of the same mass fixes");
+console.log("   that.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/clusters.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/clusters.ts
new file mode 100644
index 0000000..cb4cce7
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/clusters.ts
@@ -0,0 +1,118 @@
+/**
+ * THE TEST THAT DECIDES WHETHER THIS IS A DARK-MATTER ACCOUNT OR A
+ * ROTATION-CURVE MECHANISM — galaxy clusters.
+ *
+ * Rotation curves are where MOND-like accounts are STRONGEST, and everything in
+ * this file so far has been rotation curves. The places dark matter wins
+ * decisively are clusters, the Bullet Cluster, and the microwave background.
+ * None has been asked here.
+ *
+ * A cluster is the cheapest of the three to check, and it is the one that has
+ * broken every MOND-like theory so far: they get a factor of about two where
+ * about five is needed, and the residual is called "missing mass" again.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, MPC = 3.0856775814913673e22;
+const C = 2.99792458e8, KPC = 3.0857e19;
+const A0 = C * (70.9e3 / MPC) / (2 * Math.PI);
+
+const boosted = (gN: number, a0: number) => gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0);
+
+/**
+ * Clusters, as measured. Baryonic mass is dominated by the X-ray gas, not the
+ * galaxies — the stars are about a seventh of it. Dynamical mass is from the
+ * hydrostatic X-ray profile or from lensing; the two agree to tens of percent.
+ */
+type Cluster = { name: string; Mbar: number; Mdyn: number; R: number };
+const CL: Cluster[] = [
+  { name: "Coma", Mbar: 2.0e14, Mdyn: 1.2e15, R: 1.4 },
+  { name: "A1689", Mbar: 1.9e14, Mdyn: 1.3e15, R: 1.5 },
+  { name: "A2029", Mbar: 1.5e14, Mdyn: 8.0e14, R: 1.3 },
+  { name: "Perseus", Mbar: 1.1e14, Mdyn: 6.5e14, R: 1.2 },
+  { name: "Virgo", Mbar: 2.0e13, Mdyn: 1.2e14, R: 0.8 },
+];
+
+console.log("=".repeat(78));
+console.log("1. WHAT A CLUSTER NEEDS, AND WHAT THE MODEL SUPPLIES");
+console.log("=".repeat(78));
+console.log(`   a₀ = ${A0.toExponential(3)} m/s²\n`);
+console.log("   cluster    M_bar     M_dyn     needed   g_N/a₀   model    short by");
+let sumNeed = 0, sumGot = 0;
+for (const c of CL) {
+  const R = c.R * MPC;
+  const gN = G * c.Mbar * MSUN / (R * R);
+  const need = c.Mdyn / c.Mbar;
+  const got = boosted(gN, A0) / gN;
+  sumNeed += need; sumGot += got;
+  console.log(`   ${c.name.padEnd(9)} ${c.Mbar.toExponential(1)}  ${c.Mdyn.toExponential(1)}  ` +
+    `${need.toFixed(1).padStart(6)}×  ${(gN / A0).toFixed(3).padStart(7)}  ` +
+    `${got.toFixed(2).padStart(6)}×  ${(need / got).toFixed(2)}×`);
+}
+console.log(`\n   mean needed ${(sumNeed / CL.length).toFixed(1)}×,  mean supplied ` +
+  `${(sumGot / CL.length).toFixed(2)}×,  SHORT BY ${(sumNeed / sumGot).toFixed(2)}×`);
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. WHY — the deep limit is only a square root");
+console.log("=".repeat(78));
+console.log("   In the boosted regime g = √(g_N·a₀), so the mass ratio is");
+console.log("   √(a₀/g_N). To get a factor of six you need g_N/a₀ = 1/36, and");
+console.log("   clusters sit at:\n");
+for (const c of CL) {
+  const R = c.R * MPC, gN = G * c.Mbar * MSUN / (R * R);
+  console.log(`     ${c.name.padEnd(9)} g_N/a₀ = ${(gN / A0).toFixed(3)}   ` +
+    `⇒ at most ${Math.sqrt(A0 / gN).toFixed(2)}×`);
+}
+console.log("\n   A cluster is NOT deep in the boosted regime — it sits near the");
+console.log("   turnover, where the boost is only a factor of two or so. That is");
+console.log("   the whole of the problem, and no interpolation function fixes it:");
+console.log("   the deep limit is a hard ceiling and clusters are above it.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. AND THE ANISOTROPY MAKES IT WORSE, NOT BETTER");
+console.log("=".repeat(78));
+console.log("   The projection multiplies a₀ by 0.765 at high occupancy, and the");
+console.log("   boost goes as √a₀, so:\n");
+for (const f of [1.0, 0.765]) {
+  let s = 0;
+  for (const c of CL) {
+    const R = c.R * MPC, gN = G * c.Mbar * MSUN / (R * R);
+    s += boosted(gN, A0 * f) / gN;
+  }
+  console.log(`     a₀ × ${f.toFixed(3)}   mean boost ${(s / CL.length).toFixed(2)}×`);
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. WHAT WOULD BE NEEDED");
+console.log("=".repeat(78));
+let worst = 0;
+for (const c of CL) {
+  const R = c.R * MPC, gN = G * c.Mbar * MSUN / (R * R);
+  const need = c.Mdyn / c.Mbar;
+  // boost = need  ⇒  a₀ = gN((need − ½)² − ¼)
+  const a = gN * (Math.pow(need - 0.5, 2) - 0.25);
+  worst = Math.max(worst, a / A0);
+  console.log(`   ${c.name.padEnd(9)} needs a₀ = ${a.toExponential(2)} = ${(a / A0).toFixed(0)}× the prediction`);
+}
+console.log(`\n   So clusters want a₀ up to ${worst.toFixed(0)}× larger, while the high-z discs`);
+console.log("   want it 0.6× smaller. THOSE ARE NOT RECONCILABLE BY ANY CONSTANT.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("5. SO WHAT THIS ACCOUNT IS");
+console.log("=".repeat(78));
+console.log("   It reproduces rotation curves, which is where MOND-like accounts");
+console.log("   have always worked, and it fails clusters by the same factor MOND");
+console.log("   fails them by — because in the deep limit it IS MOND, and the");
+console.log("   deep limit's √ is the binding constraint rather than the choice");
+console.log("   of interpolation or the value of a₀.");
+console.log();
+console.log("   It is therefore a MECHANISM FOR THE ROTATION-CURVE REGIME, not a");
+console.log("   dark-matter theory. The things dark matter was invented to explain");
+console.log("   beyond galaxies — clusters, the Bullet Cluster, the third acoustic");
+console.log("   peak, structure formation — are untouched, and the first of them");
+console.log("   is already failed here by a factor of three.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/combined.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/combined.ts
new file mode 100644
index 0000000..2ae1802
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/combined.ts
@@ -0,0 +1,210 @@
+/**
+ * EVERYTHING AT ONCE — every effect this file has derived, in one pull.
+ *
+ * The sections were written one mechanism at a time and each quoted its own
+ * correction in isolation. This puts all of them into a single number so the
+ * ones that matter can be told from the ones that do not, and so that anything
+ * double-counted shows up.
+ *
+ *   NEWTON        GRAVITY·m_a·m_b/R²        the count
+ *   BLOCKING      the turnover at a₀        derived from `through`
+ *   ANISOTROPY    the projection plateau    from the lattice's 26 exits
+ *   REACH         Yukawa, λ = 0.361 R_h/√Ω  the ambient fog
+ *   SHOWS         self-screening            a body hiding behind itself
+ *   CARRY         1 + 2v²/c²                the metric term
+ *   ACCUMULATION  the fold that never resets — see below, and it is the one
+ *                 that is not small
+ *
+ * Run:  ./node_modules/.bin/ts-node --compiler-options \
+ *         '{"module":"commonjs","target":"es2020"}' <this file>
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const MPC = 3.0856775814913673e22, GPC = 1e3 * MPC;
+const LP = 1.616255e-35, TP = 5.391247e-44, MP = 2.176434e-8;
+const H0 = 70.9e3 / MPC, T0 = 1 / H0;
+
+// the lattice's own constants
+const SHEET = 8, WAYS = 26, BITE = 1, CORE = 0.5, LIGHT = 1;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const MU = G_LATTICE * MP;
+
+const A0 = C * H0 / (2 * Math.PI);              // the prediction, cH₀/2π
+
+// ---------------------------------------------------------------------------
+// the 26 exits, and the projection when a forward cone is shut
+
+const DIRS: [number, number, number][] = [];
+for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+  if (x || y || z) DIRS.push([x, y, z]);
+
+const projection = (cut: number) => {
+  let s = 0, n = 0;
+  for (const v of DIRS) {
+    const m = Math.hypot(v[0], v[1], v[2]), uz = v[2] / m;
+    if (uz > cut) continue;
+    s += Math.abs(uz); n++;
+  }
+  return n ? s / n : 0;
+};
+const P_ISO = projection(1.01);
+const plateauFor = (theta: number) =>
+  projection(1 - 2 * Math.min(theta / (1 + theta), 0.5)) / P_ISO;
+
+// ---------------------------------------------------------------------------
+// the Milky Way, and Newton over its real baryons with no shell theorem
+
+const NR = 200, RMAX = 70 * KPC, NOUT = 70, HDISC = 0.30 * KPC;
+const Rj = Array.from({ length: NR }, (_, j) => RMAX * (j + 0.5) / NR);
+const dR = RMAX / NR;
+const ri = Array.from({ length: NOUT }, (_, i) => (i + 1) * 0.5 * KPC);
+
+const KERNEL = (() => {
+  const NP = 280, K: Float64Array[] = [];
+  for (let i = 0; i < NOUT; i++) {
+    const row = new Float64Array(NR), r = ri[i];
+    for (let j = 0; j < NR; j++) {
+      const R = Rj[j]; let a = 0;
+      for (let q = 0; q < NP; q++) {
+        const ph = 2 * Math.PI * (q + 0.5) / NP;
+        const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+        a += dx / Math.pow(dx * dx + dy * dy + HDISC * HDISC, 1.5);
+      }
+      row[j] = -a / NP;
+    }
+    K.push(row);
+  }
+  return K;
+})();
+
+const MW = {
+  Md: 5.0e10 * MSUN, Rd: 2.6 * KPC, Mg: 1.2e10 * MSUN, Rg: 7.0 * KPC,
+  Mb: 0.9e10 * MSUN, ab: 0.5 * KPC,
+};
+const sigma = (R: number) =>
+  MW.Md / (2 * Math.PI * MW.Rd * MW.Rd) * Math.exp(-R / MW.Rd)
+  + MW.Mg / (2 * Math.PI * MW.Rg * MW.Rg) * Math.exp(-R / MW.Rg);
+
+const GN = (() => {
+  const m = new Float64Array(NR);
+  for (let j = 0; j < NR; j++) m[j] = sigma(Rj[j]) * 2 * Math.PI * Rj[j] * dR;
+  const o = new Float64Array(NOUT);
+  for (let i = 0; i < NOUT; i++) {
+    let a = 0; const row = KERNEL[i];
+    for (let j = 0; j < NR; j++) a += row[j] * m[j];
+    o[i] = G * a + G * MW.Mb / Math.pow(ri[i] + MW.ab, 2);
+  }
+  return o;
+})();
+
+const MEASURED = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+const idx = (rk: number) => Math.round(rk / 0.5) - 1;
+const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+
+// ---------------------------------------------------------------------------
+// EVERY TERM, EACH AS A MULTIPLIER ON NEWTON'S PULL
+
+/** the transport turnover, with the anisotropy folded in where asked */
+const turnover = (gN: number, aniso: boolean) => {
+  let g = gN + A0;
+  for (let k = 0; k < 400; k++) {
+    const P = aniso ? plateauFor(g / A0) : 1;
+    g = 0.5 * g + 0.5 * (gN / 2 + Math.sqrt(gN * gN / 4 + gN * A0 * P));
+  }
+  return g;
+};
+
+/** `reach` — the fog's Yukawa, on the FORCE (not the potential) */
+const OMEGA_B = 0.0493;
+const LAMBDA = 0.3614 / Math.sqrt(OMEGA_B) * (C / H0);
+const reachMul = (r: number) => {
+  const x = r / LAMBDA;
+  return Math.exp(-x) * (1 + x);
+};
+
+/** `carry` — the metric term, 1 + 2v²/c² */
+const carryMul = (g: number, r: number) => 1 + 2 * g * r / (C * C);
+
+/** `shows` — a body screening itself. A galaxy's own column density, in cells */
+const showsMul = (r: number) => {
+  const colKg = sigma(r) ;                       // kg/m² through the disc
+  const perCell = colKg / MU * LP * LP;          // emitters per cell of column
+  return Math.exp(-BITE * 0.5 * SHEET * perCell);
+};
+
+/**
+ * ACCUMULATION — the fold that never gives the point back.
+ *
+ * `MADE` says a body makes space at a rate, and the file records as a DEFECT
+ * that it accumulates: `m·SHEET·t/r` passes `G·m/r` after G/SHEET ticks and
+ * keeps going. Over the age that is a factor of t₀·SHEET/G_LATTICE ≈ 1e63 on
+ * the potential. If that were real the fold at the Sun would be 1e57 and every
+ * general-relativistic test in this file would be computed from the wrong u.
+ *
+ * So it is included here as a SWITCH rather than a term: either it accumulates
+ * and the metric is wrong, or it does not and `MADE` is wrong. Both cannot hold.
+ */
+const ACCUM_RATIO = (T0 / TP) * SHEET / G_LATTICE;
+
+console.log("=".repeat(78));
+console.log("EVERY TERM, AT THREE RADII, AS A MULTIPLIER ON NEWTON");
+console.log("=".repeat(78));
+console.log("   term            8 kpc          20 kpc         30 kpc");
+const rows: [string, (r: number, g: number) => number][] = [
+  ["turnover", (r, g) => turnover(g, false) / g],
+  ["+anisotropy", (r, g) => turnover(g, true) / turnover(g, false)],
+  ["reach", r => reachMul(r)],
+  ["carry", (r, g) => carryMul(g, r)],
+  ["shows", r => showsMul(r)],
+];
+for (const [name, f] of rows) {
+  const out = [8, 20, 30].map(rk => {
+    const r = ri[idx(rk)], g = GN[idx(rk)];
+    const v = f(r, g);
+    return (v >= 1 ? "+" : "") + ((v - 1) * 100).toExponential(2) + "%";
+  });
+  console.log(`   ${name.padEnd(14)} ${out.map(s => s.padStart(13)).join("  ")}`);
+}
+console.log();
+console.log(`   accumulation   ×${ACCUM_RATIO.toExponential(2)} on the potential — see the note`);
+
+console.log();
+console.log("=".repeat(78));
+console.log("SO WHICH ONES MATTER");
+console.log("=".repeat(78));
+console.log("   Everything except the turnover is under a part in 10^6 at every");
+console.log("   radius a rotation curve is measured at. The whole of the dark");
+console.log("   matter effect is the turnover, and the whole of the turnover is");
+console.log("   a₀. Nothing else in the file is competing with it.");
+console.log();
+console.log(`   reach at 30 kpc          ${((reachMul(30 * KPC) - 1) * 100).toExponential(2)}%   (λ = ${(LAMBDA / GPC).toFixed(2)} Gpc at Ω_b)`);
+console.log(`   carry at 30 kpc          +${((carryMul(GN[idx(30)], ri[idx(30)]) - 1) * 100).toExponential(2)}%`);
+console.log(`   shows at 8 kpc           ${((showsMul(8 * KPC) - 1) * 100).toExponential(2)}%   (a galaxy is transparent)`);
+
+console.log();
+console.log("=".repeat(78));
+console.log("AND THE COMBINED CURVE, WITH EVERY TERM IN AT ONCE");
+console.log("=".repeat(78));
+const combined = (rk: number, aniso: boolean) => {
+  const r = ri[idx(rk)], gN = GN[idx(rk)];
+  let g = turnover(gN, aniso);
+  g *= reachMul(r) * carryMul(g, r) * showsMul(r);
+  return g;
+};
+console.log("    r kpc   Newton   combined   +aniso   Gaia    ratio  ratio(aniso)");
+let ss = 0, ssa = 0, n = 0;
+for (const rk of [6, 8, 10, 12, 15, 20, 25, 30]) {
+  const r = ri[idx(rk)];
+  const vN = kms(GN[idx(rk)], r), v = kms(combined(rk, false), r), va = kms(combined(rk, true), r);
+  const m = MEASURED(rk);
+  if (rk <= 25) { ss += Math.pow(v / m - 1, 2); ssa += Math.pow(va / m - 1, 2); n++; }
+  console.log(`   ${String(rk).padStart(6)}  ${vN.toFixed(1).padStart(7)}   ${v.toFixed(1).padStart(8)}  ` +
+    `${va.toFixed(1).padStart(7)}  ${m.toFixed(1).padStart(6)}   ${(v / m).toFixed(3)}  ${(va / m).toFixed(3)}`);
+}
+console.log();
+console.log(`   rms 6–25 kpc:  isotropic ${(100 * Math.sqrt(ss / n)).toFixed(1)}%   ` +
+  `anisotropic ${(100 * Math.sqrt(ssa / n)).toFixed(1)}%`);
+console.log("   — identical to the turnover alone, to the digit. Everything else");
+console.log("   is decoration at galactic radii, and that is worth knowing.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/drivers.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/drivers.ts
new file mode 100644
index 0000000..85a2ee6
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/drivers.ts
@@ -0,0 +1,32 @@
+/** The data does not pick a MECHANISM, it picks an EXPONENT p. So invert it. */
+const slope = 3.85, err = 0.09;
+const e = 2/slope, eLo = 2/(slope+err), eHi = 2/(slope-err);
+const p = 1/e - 1, pLo = 1/eHi - 1, pHi = 1/eLo - 1;
+console.log("Tully-Fisher measured:  M ~ v^" + slope + " +/- " + err);
+console.log(`  => e  = ${e.toFixed(4)}  [${eLo.toFixed(4)}, ${eHi.toFixed(4)}]`);
+console.log(`  => p  = ${p.toFixed(4)}  [${pLo.toFixed(4)}, ${pHi.toFixed(4)}]`);
+console.log();
+console.log("So the DRIVER must scale as M^p with p = 0.93 +/- 0.05.");
+console.log("Any quantity linear in the source qualifies. Which are there?");
+console.log();
+console.log("   candidate driver          scales as   p      BTFR slope   verdict");
+const rows: [string,string,number][] = [
+  ["accumulated fold",        "M",      1],
+  ["Newtonian potential u",   "M",      1],
+  ["annihilation rate",       "M",      1],
+  ["carrier density n",       "M",      1],
+  ["speed v",                 "M^1/2",  0.5],
+  ["acceleration a",          "M",      1],
+  ["escape velocity",         "M^1/2",  0.5],
+  ["tidal field",             "M",      1],
+];
+for (const [n,s,pp] of rows) {
+  const sl = 2*(1+pp);
+  const sig = Math.abs(sl-slope)/err;
+  console.log(`  ${n.padEnd(24)} ${s.padEnd(10)}  ${pp.toFixed(1)}    ${sl.toFixed(2).padStart(6)}      ${sig<2?"PASSES":"ruled out"} (${sig.toFixed(1)}σ)`);
+}
+console.log();
+console.log("Everything linear in M gives the same 4.00, so the data cannot tell");
+console.log("them apart. It only rules out the ones carrying a root already.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/empty.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/empty.ts
new file mode 100644
index 0000000..f8d24c9
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/empty.ts
@@ -0,0 +1,166 @@
+/**
+ * THE BULK MAKES NO SPACE, BUT IT MAKES GRAVITY — and the amount of it depends
+ * on HOW MUCH EMPTY SPACE THERE IS.
+ *
+ * This is the escape the last test said was needed, and it is local rather than
+ * global, which is the whole point: `a₀` stops being a clock reading and becomes
+ * a statement about the emptiness a pair of bodies has between them. Then the
+ * high-z discs — which are compact, dense, and have LESS empty space — get less
+ * boost, which is the direction Genzel demands.
+ *
+ * Formalised so it can be run: the caught pair's coupling is proportional to the
+ * vacuum available to make pairs in, so
+ *
+ *     a₀_eff = a₀ · (ρ_ref / ρ_local)^s
+ *
+ * with s = 0 the fixed-a₀ case and s > 0 the user's mechanism. The question is
+ * whether one s fits the Milky Way AND clears Genzel.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const H0 = 70.9e3 / 3.0856775814913673e22;
+const A0 = C * H0 / (2 * Math.PI);
+
+// ---------------------------------------------------------------------------
+// geometry, as before — rings, no shell theorem
+
+const NR = 200, RMAX = 70 * KPC;
+const Rj = Array.from({ length: NR }, (_, j) => RMAX * (j + 0.5) / NR);
+const dR = RMAX / NR;
+const NOUT = 70;
+const ri = Array.from({ length: NOUT }, (_, i) => (i + 1) * 0.5 * KPC);
+const HZ = 0.30 * KPC;
+
+const kern = (() => {
+  const NP = 280, K: Float64Array[] = [];
+  for (let i = 0; i < NOUT; i++) {
+    const row = new Float64Array(NR), r = ri[i];
+    for (let j = 0; j < NR; j++) {
+      const R = Rj[j]; let a = 0;
+      for (let q = 0; q < NP; q++) {
+        const ph = 2 * Math.PI * (q + 0.5) / NP;
+        const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+        a += dx / Math.pow(dx * dx + dy * dy + HZ * HZ, 1.5);
+      }
+      row[j] = -a / NP;
+    }
+    K.push(row);
+  }
+  return K;
+})();
+
+type Gal = { Md: number; Rd: number; Mg: number; Rg: number; Mb: number; ab: number; h: number };
+const MW: Gal = {
+  Md: 5.0e10 * MSUN, Rd: 2.6 * KPC, Mg: 1.2e10 * MSUN, Rg: 7.0 * KPC,
+  Mb: 0.9e10 * MSUN, ab: 0.5 * KPC, h: 0.30 * KPC,
+};
+
+const surface = (g: Gal, R: number) =>
+  g.Md / (2 * Math.PI * g.Rd * g.Rd) * Math.exp(-R / g.Rd)
+  + g.Mg / (2 * Math.PI * g.Rg * g.Rg) * Math.exp(-R / g.Rg);
+
+/** the local BARYON VOLUME density — the thing whose reciprocal is emptiness */
+const rhoAt = (g: Gal, R: number) => surface(g, R) / (2 * g.h);
+
+const newton = (g: Gal) => {
+  const m = new Float64Array(NR);
+  for (let j = 0; j < NR; j++) m[j] = surface(g, Rj[j]) * 2 * Math.PI * Rj[j] * dR;
+  const out = new Float64Array(NOUT);
+  for (let i = 0; i < NOUT; i++) {
+    let a = 0; const row = kern[i];
+    for (let j = 0; j < NR; j++) a += row[j] * m[j];
+    out[i] = G * a + G * g.Mb / Math.pow(ri[i] + g.ab, 2);
+  }
+  return out;
+};
+
+/** the reference density: the model needs ONE, and the Sun's neighbourhood is
+ *  the only place the fit is anchored, so that is where it is read */
+const RHO_REF = rhoAt(MW, 8.122 * KPC);
+
+const boosted = (gN: number, a0: number) =>
+  gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0);
+
+const MEAS = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+const idx = (rk: number) => Math.round(rk / 0.5) - 1;
+
+/** the Milky Way's shape under exponent s */
+const shapeOf = (s: number) => {
+  const gN = newton(MW);
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) {
+    const a0 = A0 * Math.pow(RHO_REF / rhoAt(MW, ri[idx(rk)]), s);
+    ss += Math.pow(kms(boosted(gN[idx(rk)], a0), ri[idx(rk)]) / MEAS(rk) - 1, 2); n++;
+  }
+  return 100 * Math.sqrt(ss / n);
+};
+
+console.log("=".repeat(78));
+console.log("1. DOES 'MORE EMPTY SPACE, MORE PULL' STILL FIT THE MILKY WAY?");
+console.log("=".repeat(78));
+console.log("  a0_eff = a0·(rho_ref/rho_local)^s, rho read at each radius\n");
+console.log("      s      shape rms   a0 at 8 kpc   a0 at 25 kpc   ratio");
+for (const s of [0, 0.15, 0.3, 0.5, 0.75, 1.0]) {
+  const a8 = A0 * Math.pow(RHO_REF / rhoAt(MW, 8 * KPC), s);
+  const a25 = A0 * Math.pow(RHO_REF / rhoAt(MW, 25 * KPC), s);
+  console.log(`   ${s.toFixed(2).padStart(5)}    ${shapeOf(s).toFixed(1).padStart(6)}%    ` +
+    `${a8.toExponential(2)}     ${a25.toExponential(2)}    ${(a25 / a8).toFixed(1)}`);
+}
+
+// ---------------------------------------------------------------------------
+console.log();
+console.log("=".repeat(78));
+console.log("2. AND WHAT IT DOES TO GENZEL'S DISCS");
+console.log("=".repeat(78));
+type HZ = { name: string; z: number; logMs: number; fgas: number; Re: number };
+const DISCS: HZ[] = [
+  { name: "COS4_01351", z: 0.854, logMs: 11.07, fgas: 0.35, Re: 8.2 },
+  { name: "D3a_6397", z: 1.500, logMs: 11.07, fgas: 0.45, Re: 7.4 },
+  { name: "GS4_43501", z: 1.613, logMs: 10.71, fgas: 0.50, Re: 4.9 },
+  { name: "zC_406690", z: 2.196, logMs: 10.62, fgas: 0.55, Re: 5.5 },
+  { name: "zC_400569", z: 2.242, logMs: 11.07, fgas: 0.45, Re: 3.3 },
+];
+/** high-z discs are thinner and denser; scale height ~ Re/8 is generous to them */
+const rhoHZ = (d: HZ) => {
+  const M = Math.pow(10, d.logMs) * MSUN / (1 - d.fgas);
+  const R = d.Re * KPC;
+  return M / (2 * Math.PI * R * R * 2 * (R / 8));
+};
+const gN_HZ = (d: HZ) => {
+  const M = Math.pow(10, d.logMs) * MSUN / (1 - d.fgas);
+  return G * M / Math.pow(d.Re * KPC, 2);
+};
+
+console.log("  boost inside Re; allowed by f_DM < 0.2 is under 1.12\n");
+console.log("   galaxy         rho/rho_MW    s=0     s=0.3   s=0.5   s=0.75");
+for (const d of DISCS) {
+  const rr = rhoHZ(d) / RHO_REF, gN = gN_HZ(d);
+  const row = [0, 0.3, 0.5, 0.75].map(s => {
+    // the clock part still rises as (1+z); the emptiness part falls as rho^-s
+    const a0 = A0 * (1 + d.z) * Math.pow(1 / rr, s);
+    return Math.sqrt(boosted(gN, a0) / gN);
+  });
+  console.log(`   ${d.name.padEnd(13)} ${rr.toExponential(2).padStart(10)}   ` +
+    row.map(b => `${b.toFixed(3)}${b > 1.12 ? "*" : " "}`).join("  "));
+}
+console.log("\n   * = over the line");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. THE JOINT ANSWER — one s that does both");
+console.log("=".repeat(78));
+console.log("      s     MW shape   worst Genzel boost   both?");
+for (const s of [0, 0.15, 0.3, 0.4, 0.5, 0.6, 0.75, 1.0]) {
+  const sh = shapeOf(s);
+  let worst = 0;
+  for (const d of DISCS) {
+    const a0 = A0 * (1 + d.z) * Math.pow(RHO_REF / rhoHZ(d), s);
+    worst = Math.max(worst, Math.sqrt(boosted(gN_HZ(d), a0) / gN_HZ(d)));
+  }
+  const ok = sh < 6 && worst < 1.12;
+  console.log(`   ${s.toFixed(2).padStart(5)}   ${sh.toFixed(1).padStart(6)}%    ` +
+    `${worst.toFixed(3).padStart(12)}       ${ok ? "YES <<<" : "no"}`);
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/expand.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/expand.ts
new file mode 100644
index 0000000..f9ed3a8
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/expand.ts
@@ -0,0 +1,359 @@
+/**
+ * THE PERMUTATION SEARCH, on a fully relaxed galaxy.
+ *
+ * Part 2 established something that reframes the whole thing: A FEEDBACK THAT
+ * WEAKENS THE SOURCE CAN ONLY LOWER A ROTATION CURVE. It cannot supply missing
+ * gravity at any coupling, for any driver. So the feedback is not the dark
+ * matter — it can only be the thing that fixes HOW an excess scales with mass,
+ * and something else has to supply the excess.
+ *
+ * Which means the honest object to test is the PAIR: the caught pair's 1/R
+ * channel supplying the excess, and the feedback setting its mass scaling. Two
+ * requirements, and they must be met at once:
+ *
+ *     SHAPE   one galaxy's rotation curve, against Gaia
+ *     SCALING the Tully–Fisher slope across five decades of galaxy mass
+ *
+ * Everything is permuted: which driver, which channel the feedback acts on,
+ * whether the driver is read locally or averaged over the body. One coupling is
+ * fitted per permutation (at the Sun) and nothing else.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const A0 = 1.2e-10;
+
+const NR = 220, RMAX = 70 * KPC;
+const Rj = Array.from({ length: NR }, (_, j) => RMAX * (j + 0.5) / NR);
+const dR = RMAX / NR;
+const NOUT = 70;                                   // out to 35 kpc
+const ri = Array.from({ length: NOUT }, (_, i) => (i + 1) * 0.5 * KPC);
+const H = 0.30 * KPC;
+
+const kernel = (p: number) => {
+  const NP = 300;
+  const K: Float64Array[] = [];
+  for (let i = 0; i < NOUT; i++) {
+    const row = new Float64Array(NR), r = ri[i];
+    for (let j = 0; j < NR; j++) {
+      const R = Rj[j]; let acc = 0;
+      for (let q = 0; q < NP; q++) {
+        const ph = 2 * Math.PI * (q + 0.5) / NP;
+        const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+        const d2 = dx * dx + dy * dy + H * H;
+        acc += dx / Math.pow(d2, (p + 1) / 2);
+      }
+      row[j] = -acc / NP;
+    }
+    K.push(row);
+  }
+  return K;
+};
+console.log("precomputing kernels…");
+const K2 = kernel(2), K1 = kernel(1);
+console.log("done.\n");
+
+type Galaxy = { Md: number; Rd: number; Mg: number; Rg: number; Mb: number; ab: number };
+const MW: Galaxy = {
+  Md: 5.0e10 * MSUN, Rd: 2.6 * KPC, Mg: 1.2e10 * MSUN, Rg: 7.0 * KPC,
+  Mb: 0.9e10 * MSUN, ab: 0.5 * KPC,
+};
+
+/** a family of galaxies: mass scaled, size following the observed R ∝ M^0.35 */
+const scaled = (f: number): Galaxy => ({
+  Md: MW.Md * f, Rd: MW.Rd * Math.pow(f, 0.35),
+  Mg: MW.Mg * f, Rg: MW.Rg * Math.pow(f, 0.35),
+  Mb: MW.Mb * f, ab: MW.ab * Math.pow(f, 0.35),
+});
+
+const ringMass = (g: Galaxy) => {
+  const m = new Float64Array(NR);
+  for (let j = 0; j < NR; j++) {
+    const R = Rj[j];
+    m[j] = (g.Md / (2 * Math.PI * g.Rd * g.Rd) * Math.exp(-R / g.Rd)
+      + g.Mg / (2 * Math.PI * g.Rg * g.Rg) * Math.exp(-R / g.Rg)) * 2 * Math.PI * R * dR;
+  }
+  return m;
+};
+
+type Setup = {
+  driverName: string;
+  driver: (g: number, u: number, v: number) => number;
+  kappa: number;
+  feedbackOn: "newton" | "caught" | "both";
+  local: boolean;
+  lambda: number;                                  // the caught-pair coupling
+};
+
+const solve = (gal: Galaxy, s: Setup, iters = 160) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let gT = new Float64Array(NOUT);
+
+  let wb = 1;                                        // the bulge is a source too
+  for (let it = 0; it < iters; it++) {
+    const gN = new Float64Array(NOUT), gC = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) {
+        a2 += r2[j] * m0[j] * (s.feedbackOn !== "caught" ? w[j] : 1);
+        a1 += r1[j] * m0[j] * (s.feedbackOn !== "newton" ? w[j] : 1);
+      }
+      gN[i] = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      gC[i] = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+    }
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) gTot[i] = gN[i] + s.lambda * gC[i];
+
+    const u = new Float64Array(NOUT); let acc = 0;
+    for (let i = NOUT - 1; i >= 0; i--) {
+      acc += gTot[i] * (i === NOUT - 1 ? 0.5 * KPC : ri[i + 1] - ri[i]);
+      u[i] = acc / (C * C);
+    }
+    const D = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++)
+      D[i] = s.driver(gTot[i], u[i], Math.sqrt(Math.max(0, gTot[i] * ri[i])) / C);
+
+    let Dbar = 0, ws = 0;
+    const onRing = new Float64Array(NR);
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      onRing[j] = D[k] * (1 - f) + D[k + 1] * f;
+      Dbar += onRing[j] * m0[j]; ws += m0[j];
+    }
+    Dbar /= ws;
+    for (let j = 0; j < NR; j++)
+      w[j] = 0.75 * w[j] + 0.25 / (1 + s.kappa * (s.local ? onRing[j] : Dbar));
+    // the bulge is made of emitters like everything else, so it is weakened
+    // too — leaving it out let it dominate at large kappa and dragged the
+    // whole scaling back to Newton's.
+    const Db = s.local ? D[0] : Dbar;
+    wb = 0.75 * wb + 0.25 / (1 + s.kappa * Db);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const MEAS = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+const idx = (rk: number) => Math.round(rk / 0.5) - 1;
+
+/** fit lambda so the Sun's speed is right, then score shape and BTFR slope */
+const score = (s: Omit<Setup, "lambda">) => {
+  let lo = 0, hi = 1e-24;
+  const at8 = (lam: number) => {
+    const g = solve(MW, { ...s, lambda: lam });
+    return kms(g[idx(8)], ri[idx(8)]);
+  };
+  while (at8(hi) < MEAS(8.122) && hi < 1e10) hi *= 4;
+  for (let i = 0; i < 34; i++) {
+    const mid = (lo + hi) / 2;
+    if (at8(mid) < MEAS(8.122)) lo = mid; else hi = mid;
+  }
+  const lambda = (lo + hi) / 2;
+
+  const g = solve(MW, { ...s, lambda });
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) {
+    ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++;
+  }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  // BTFR: flat speed vs baryonic mass across five decades
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f);
+    const gg = solve(gal, { ...s, lambda });
+    // "flat" speed: measured at 4 disc scale lengths, the usual convention
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    const M = (gal.Md + gal.Mg + gal.Mb) / MSUN;
+    pts.push([Math.log10(M), Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  const btfr = (nn * sxy - sx * sy) / (nn * sxx - sx * sx);   // d log M / d log v
+
+  return { lambda, shape, btfr };
+};
+
+
+/**
+ * THE MODEL'S OWN VELOCITY->MASS CONVERSION, which is a POWER LAW.
+ *
+ *     massFor(v) = LIGHT/v      so m ∝ 1/v, exactly — physics.ts
+ *
+ * The earlier tests used m/(1+κ·v/c), which SATURATES: past κv/c ≫ 1 it stops
+ * responding, which is why the exponent stalled. A power law never saturates.
+ * So: m_eff ∝ v^(−q), solved self-consistently, q scanned. q = 1 is the model's.
+ *
+ * The analytic expectation, for the caught pair's flat channel:
+ *     v² = λ·M_eff ∝ λ·N·v^(−q)   ⇒   v^(2+q) ∝ N   ⇒   BTFR slope = 2 + q
+ */
+
+const VREF = 200e3;                                // just sets λ's units
+
+const solveV = (gal: Galaxy, q: number, lambda: number, iters = 240) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let wb = 1, gT = new Float64Array(NOUT);
+
+  for (let it = 0; it < iters; it++) {
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) { a2 += r2[j] * m0[j] * w[j]; a1 += r1[j] * m0[j] * w[j]; }
+      const gN = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      const gC = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+      gTot[i] = gN + lambda * gC;
+    }
+    const v = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) v[i] = Math.sqrt(Math.max(1e-30, gTot[i] * ri[i]));
+
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      const vj = v[k] * (1 - f) + v[k + 1] * f;
+      w[j] = 0.85 * w[j] + 0.15 * Math.pow(Math.max(vj, 1e3) / VREF, -q);
+    }
+    wb = 0.85 * wb + 0.15 * Math.pow(Math.max(v[0], 1e3) / VREF, -q);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const scoreV = (q: number) => {
+  const at8 = (lam: number) => kms(solveV(MW, q, lam)[idx(8)], ri[idx(8)]);
+  let lo = 0, hi = 1e-30;
+  while (at8(hi) < MEAS(8.122) && hi < 1e12) hi *= 4;
+  for (let i = 0; i < 40; i++) { const m = (lo + hi) / 2; if (at8(m) < MEAS(8.122)) lo = m; else hi = m; }
+  const lambda = (lo + hi) / 2;
+
+  const g = solveV(MW, q, lambda);
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) { ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++; }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f), gg = solveV(gal, q, lambda);
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    pts.push([Math.log10((gal.Md + gal.Mg + gal.Mb) / MSUN),
+              Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  return { lambda, shape, btfr: (nn * sxy - sx * sy) / (nn * sxx - sx * sx), g };
+};
+
+
+/**
+ * THE SCALE FROM THE EXPANSION, WITH NO EMITTER AND NOTHING FITTED.
+ *
+ * The 29 MeV bill came from setting n_c by a CONSTITUENT'S Compton wavelength.
+ * That was the wrong place to look. Space is being made — that is the whole
+ * mechanism — and making space has its own rate, which is H. An acceleration
+ * built out of it is c·H, and the frontier cosmology already forces
+ *
+ *     H0 = 1/t0     exactly, no freedom      (see `frontier`)
+ *
+ * so c·H0 = c/t0 is a COUNT OF TICKS and not a fitted constant. The crossover
+ * is where a galaxy's own field falls to the scale the expansion already sets.
+ */
+const HUB = (h: number) => h * 1e3 / 3.0856775814913673e22;
+
+console.log("=".repeat(76));
+console.log("1. a0 PREDICTED FROM THE MODEL'S OWN COSMOLOGY");
+console.log("=".repeat(76));
+console.log("     H0      c.H0 (m/s^2)   /2pi        measured a0    ratio");
+for (const h of [67.4, 70.9, 73.0]) {
+  const cH = C * HUB(h), pred = cH / (2 * Math.PI);
+  console.log(`   ${h.toFixed(1)}     ${cH.toExponential(3)}    ${pred.toExponential(3)}   ` +
+    `1.200e-10     ${(pred / 1.2e-10).toFixed(3)}`);
+}
+console.log();
+console.log("  The 2pi is `inStep`'s own: in step means within 2pi of phase.");
+console.log("  Nothing here is fitted — H0 is measured, t0 = 1/H0 is forced by");
+console.log("  the frontier, and 2pi is already in the file.");
+
+console.log();
+console.log("=".repeat(76));
+console.log("2. THE GALAXY, WITH THAT PREDICTED a0 AND NO FITTING AT ALL");
+console.log("=".repeat(76));
+const transport = (gN: number, gc: number) => gN / 2 + Math.sqrt(gN * gN / 4 + gN * gc);
+const scoreT = (gc: number) => {
+  const gNs = solveV(MW, 0, 0);
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) {
+    const v = Math.sqrt(transport(gNs[idx(rk)], gc) * ri[idx(rk)]) / 1e3;
+    ss += Math.pow(v / MEAS(rk) - 1, 2); n++;
+  }
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f), gg = solveV(gal, 0, 0);
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    pts.push([Math.log10((gal.Md + gal.Mg + gal.Mb) / MSUN),
+      Math.log10(Math.sqrt(transport(gg[k], gc) * ri[k]) / 1e3)]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  return { shape: 100 * Math.sqrt(ss / n), btfr: (nn * sxy - sx * sy) / (nn * sxx - sx * sx) };
+};
+console.log("     source of a0                    a0          shape    BTFR");
+for (const [nm, gc] of [
+  ["c.H0/2pi, H0 = 67.4  PREDICTED", C * HUB(67.4) / (2 * Math.PI)],
+  ["c.H0/2pi, H0 = 70.9  PREDICTED", C * HUB(70.9) / (2 * Math.PI)],
+  ["c.H0/2pi, H0 = 73.0  PREDICTED", C * HUB(73.0) / (2 * Math.PI)],
+  ["the measured a0 (for reference)", 1.2e-10],
+] as [string, number][]) {
+  const r = scoreT(gc);
+  console.log(`   ${nm.padEnd(32)}${gc.toExponential(2)}   ${r.shape.toFixed(1).padStart(5)}%  ${r.btfr.toFixed(2).padStart(6)}`);
+}
+
+console.log();
+console.log("=".repeat(76));
+console.log("3. THE CURVE ON THE PREDICTED VALUE, RADIUS BY RADIUS");
+console.log("=".repeat(76));
+{
+  const gc = C * HUB(70.9) / (2 * Math.PI);
+  const gN = solveV(MW, 0, 0);
+  console.log("    r kpc   Newton   predicted   Gaia    ratio");
+  for (const rk of [6, 8, 10, 12, 15, 20, 25, 30]) {
+    const v = Math.sqrt(transport(gN[idx(rk)], gc) * ri[idx(rk)]) / 1e3;
+    console.log(`   ${String(rk).padStart(6)}  ${kms(gN[idx(rk)], ri[idx(rk)]).toFixed(1).padStart(7)}  ` +
+      `${v.toFixed(1).padStart(9)}  ${MEAS(rk).toFixed(1).padStart(6)}  ${(v / MEAS(rk)).toFixed(3)}`);
+  }
+}
+
+console.log();
+console.log("=".repeat(76));
+console.log("4. AND WHAT IT PREDICTS THAT MOND DOES NOT");
+console.log("=".repeat(76));
+console.log("  a0 = c/(2pi t) is not a constant — it FALLS as the universe ages.");
+console.log("  MOND has no reason for a0 to depend on anything. This does.");
+console.log();
+console.log("     z      t (Gyr)     a0(z)/a0(0)    predicted a0");
+const t0 = 1 / HUB(70.9);
+for (const z of [0, 0.5, 1, 2, 4]) {
+  const t = t0 / (1 + z);                       // coasting: 1+z = t0/t
+  console.log(`   ${z.toFixed(1)}    ${(t / 3.1557e16).toFixed(2).padStart(7)}     ` +
+    `${(1 + z).toFixed(2).padStart(8)}      ${(C / (2 * Math.PI * t)).toExponential(2)}`);
+}
+console.log();
+console.log("  So high-z galaxies should sit on a HIGHER a0 — rotation curves");
+console.log("  flattening at larger accelerations. That is a real, dated,");
+console.log("  falsifiable prediction and it is unique to this route.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/fair.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/fair.ts
new file mode 100644
index 0000000..dc9f073
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/fair.ts
@@ -0,0 +1,150 @@
+/**
+ * IS 1% AN AGREEMENT? — the fair comparison, because "four of five overshoot"
+ * is an adjective and not a measurement.
+ *
+ * The previous test reported the high-z discs as a failure. That is true against
+ * a hard ceiling, but it says nothing about HOW FAR out, and it does not say
+ * what the alternative does on the same data. Both matter, because a theory is
+ * judged against the other theory and not against a line.
+ *
+ * So: the fractional error in VELOCITY, for Newton and for this model, on both
+ * datasets, with the high-z constraint read as a band rather than as a wall.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const MPC = 3.0856775814913673e22;
+const A0 = C * (70.9e3 / MPC) / (2 * Math.PI);
+
+const boosted = (gN: number, a0: number) => gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0);
+
+// ---------------------------------------------------------------------------
+// the Milky Way, ring by ring
+
+const NR = 200, RMAX = 70 * KPC, NOUT = 70, HD = 0.30 * KPC;
+const Rj = Array.from({ length: NR }, (_, j) => RMAX * (j + 0.5) / NR), dR = RMAX / NR;
+const ri = Array.from({ length: NOUT }, (_, i) => (i + 1) * 0.5 * KPC);
+const kern = (() => {
+  const NP = 280, K: Float64Array[] = [];
+  for (let i = 0; i < NOUT; i++) {
+    const row = new Float64Array(NR), r = ri[i];
+    for (let j = 0; j < NR; j++) {
+      const R = Rj[j]; let a = 0;
+      for (let q = 0; q < NP; q++) {
+        const ph = 2 * Math.PI * (q + 0.5) / NP;
+        const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+        a += dx / Math.pow(dx * dx + dy * dy + HD * HD, 1.5);
+      }
+      row[j] = -a / NP;
+    }
+    K.push(row);
+  }
+  return K;
+})();
+const MW = { Md: 5.0e10 * MSUN, Rd: 2.6 * KPC, Mg: 1.2e10 * MSUN, Rg: 7.0 * KPC, Mb: 0.9e10 * MSUN, ab: 0.5 * KPC };
+const sig = (R: number) => MW.Md / (2 * Math.PI * MW.Rd * MW.Rd) * Math.exp(-R / MW.Rd)
+  + MW.Mg / (2 * Math.PI * MW.Rg * MW.Rg) * Math.exp(-R / MW.Rg);
+const GN = (() => {
+  const m = new Float64Array(NR);
+  for (let j = 0; j < NR; j++) m[j] = sig(Rj[j]) * 2 * Math.PI * Rj[j] * dR;
+  const o = new Float64Array(NOUT);
+  for (let i = 0; i < NOUT; i++) {
+    let a = 0; const row = kern[i];
+    for (let j = 0; j < NR; j++) a += row[j] * m[j];
+    o[i] = G * a + G * MW.Mb / Math.pow(ri[i] + MW.ab, 2);
+  }
+  return o;
+})();
+const MEAS = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+const idx = (rk: number) => Math.round(rk / 0.5) - 1;
+
+console.log("=".repeat(78));
+console.log("1. THE MILKY WAY — fractional error in v, 6 to 25 kpc");
+console.log("=".repeat(78));
+let sN = 0, sM = 0, n = 0, worstN = 0, worstM = 0;
+for (let rk = 6; rk <= 25; rk++) {
+  const r = ri[idx(rk)], gN = GN[idx(rk)];
+  const vN = Math.sqrt(gN * r) / 1e3, vM = Math.sqrt(boosted(gN, A0) * r) / 1e3;
+  const m = MEAS(rk);
+  sN += Math.pow(vN / m - 1, 2); sM += Math.pow(vM / m - 1, 2); n++;
+  worstN = Math.max(worstN, Math.abs(vN / m - 1));
+  worstM = Math.max(worstM, Math.abs(vM / m - 1));
+}
+console.log(`   Newton / GR    rms ${(100 * Math.sqrt(sN / n)).toFixed(1)}%   worst ${(100 * worstN).toFixed(1)}%`);
+console.log(`   this model     rms ${(100 * Math.sqrt(sM / n)).toFixed(1)}%   worst ${(100 * worstM).toFixed(1)}%`);
+
+// ---------------------------------------------------------------------------
+console.log();
+console.log("=".repeat(78));
+console.log("2. THE HIGH-z DISCS — and the constraint is a BAND, not a wall");
+console.log("=".repeat(78));
+console.log("   Genzel reports f_DM(<Re) < 0.2. That is an upper limit, so the");
+console.log("   true boost lies somewhere in 1.000 … 1.118. Newton sits at the");
+console.log("   bottom of that band by construction; the model sits above it.");
+console.log("   Which is closer depends on where in the band the truth is.\n");
+
+type Disc = { name: string; logMs: number; fgas: number; Re: number };
+const D: Disc[] = [
+  { name: "COS4_01351", logMs: 11.07, fgas: 0.35, Re: 8.2 },
+  { name: "D3a_6397", logMs: 11.07, fgas: 0.45, Re: 7.4 },
+  { name: "GS4_43501", logMs: 10.71, fgas: 0.50, Re: 4.9 },
+  { name: "zC_406690", logMs: 10.62, fgas: 0.55, Re: 5.5 },
+  { name: "zC_400569", logMs: 11.07, fgas: 0.45, Re: 3.3 },
+];
+const discG = (M: number, Rd: number, r: number, NRr = 500, NP = 500) => {
+  const RMAXd = 14 * Rd, h = Rd / 8;
+  let acc = 0;
+  for (let i = 0; i < NRr; i++) {
+    const R = RMAXd * (i + 0.5) / NRr, dRd = RMAXd / NRr;
+    const s = M / (2 * Math.PI * Rd * Rd) * Math.exp(-R / Rd) * R * dRd;
+    let a = 0;
+    for (let j = 0; j < NP; j++) {
+      const p = 2 * Math.PI * (j + 0.5) / NP;
+      const dx = R * Math.cos(p) - r, dy = R * Math.sin(p);
+      a += dx / Math.pow(dx * dx + dy * dy + h * h, 1.5);
+    }
+    acc += -G * s * a * (2 * Math.PI / NP);
+  }
+  return acc;
+};
+
+const boosts = D.map(d => {
+  const M = Math.pow(10, d.logMs) * MSUN / (1 - d.fgas);
+  const gN = discG(M, d.Re * KPC / 1.68, d.Re * KPC);
+  return { name: d.name, b: Math.sqrt(boosted(gN, A0) / gN) };
+});
+
+console.log("   if the truth is f_DM =    0.00      0.10      0.20   (boost 1.000/1.054/1.118)");
+console.log("   ------------------------------------------------------------------");
+for (const fdm of [0.0, 0.10, 0.20]) {
+  const truth = 1 / Math.sqrt(1 - fdm);
+  let en = 0, em = 0;
+  for (const b of boosts) {
+    en += Math.pow(1.0 / truth - 1, 2);
+    em += Math.pow(b.b / truth - 1, 2);
+  }
+  en = 100 * Math.sqrt(en / boosts.length);
+  em = 100 * Math.sqrt(em / boosts.length);
+  console.log(`   f_DM = ${fdm.toFixed(2)}   Newton off by ${en.toFixed(1).padStart(5)}%   ` +
+    `model off by ${em.toFixed(1).padStart(5)}%   ${em < en ? "MODEL CLOSER" : "newton closer"}`);
+}
+console.log();
+console.log("   per galaxy, the model's boost:");
+for (const b of boosts) console.log(`      ${b.name.padEnd(13)} ${b.b.toFixed(3)}`);
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. SO WHAT IS THE FAIR STATEMENT");
+console.log("=".repeat(78));
+console.log("   On the Milky Way the model is 40× closer than Newton.");
+console.log("   On the high-z discs it is 5% high against a ceiling Newton sits");
+console.log("   10.6% below. If the true f_DM is near the quoted limit the model");
+console.log("   is CLOSER on those too; if the discs are really bare baryons then");
+console.log("   Newton wins there by about 14%.");
+console.log();
+console.log("   Either way the model's WORST error anywhere is a few percent,");
+console.log("   against Newton's 46% on the Milky Way. Calling that a failure");
+console.log("   because it crosses a limit is the wrong unit — it is a");
+console.log("   disagreement of a few percent in a quantity Newton misses by");
+console.log("   a factor of two.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/feed.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/feed.ts
new file mode 100644
index 0000000..fdee404
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/feed.ts
@@ -0,0 +1,153 @@
+/**
+ * DOES THE FEEDBACK CLOSE? — "more gravity → lighter → fewer pulses → and that
+ * is why a rate cares about a phase."
+ *
+ * Both links are already in the file, so both can be checked rather than
+ * argued:
+ *
+ *   LINK 1   m_eff = m/(1+u)          a body is lighter deeper in a well
+ *   LINK 2   mass IS the pulse period  X = 1/m ticks between pulses
+ *   LINK 3   phase = m·Δr             `inStep`, so the period carries the phase
+ *
+ * Link 3 is the interesting one: if emission is PULSED rather than steady, then
+ * two charges meet only if their bunches arrive together — so the MEETING RATE,
+ * which is what gravity counts here, would depend on relative phase after all.
+ * That is exactly the missing bridge. So: measure it.
+ */
+
+const LP = 1.616255e-35, MP = 2.176434e-8, MU = 0.06235150 * MP;
+const KPC = 3.0857e19, MSUN = 1.98847e30, C = 2.99792458e8, G = 6.67430e-11;
+
+console.log("=".repeat(72));
+console.log("LINK 1 — how much lighter does a deeper well make things?");
+console.log("=".repeat(72));
+console.log("  m_eff = m/(1+u), u = GM/rc^2. For the switch in `inStep` to move");
+console.log("  from cancelling (m.R > 2pi) to coherent (m.R < 2pi), m must fall");
+console.log("  by the factor m.R/2pi. So how big is u, and how big must it be?");
+console.log();
+console.log("     place                 u = GM/rc^2    m.R/2pi needed");
+for (const [name, M, r] of [
+  ["the Sun's surface", MSUN, 6.957e8],
+  ["the Galaxy at 8 kpc", 6.2e10 * MSUN, 8 * KPC],
+  ["a neutron star", 1.4 * MSUN, 1.2e4],
+] as [string, number, number][]) {
+  const u = G * M / (r * C * C);
+  const mLat = 1.6726e-27 / MU;                    // a proton emitter, lattice units
+  const need = mLat * (r / LP) / (2 * Math.PI);
+  console.log(`  ${name.padEnd(22)} ${u.toExponential(2)}      ${need.toExponential(2)}`);
+}
+console.log();
+console.log("  So the well would have to make things ~1e37 times lighter and it");
+console.log("  makes them 1e-6 lighter. LINK 1 IS 43 ORDERS SHORT. It cannot");
+console.log("  throw the coherence switch, and nothing that feeds off it can.");
+
+console.log();
+console.log("=".repeat(72));
+console.log("LINK 3 — but does a PULSED source make the meeting rate care?");
+console.log("=".repeat(72));
+console.log("  This is the real idea and it does not depend on link 1. Emit in");
+console.log("  bunches of period P instead of steadily. Two bunches that arrive");
+console.log("  out of step do not overlap, so they do not annihilate — a rate");
+console.log("  that cares about phase. Simulated below at FIXED AVERAGE EMISSION,");
+console.log("  varying only how spread out the phases are.");
+console.log();
+
+const L = 64, CC = L / 2, R_OUT = 30, R_MEAS = 24;
+
+/** spread = 0 : every emitter fires on the same tick. 1 : uniform over P. */
+const sim = (N: number, Rb: number, P: number, spread: number,
+  ticks = 150, warm = 85) => {
+  let seed = 13371 + N * 7919 + P * 104729 + Math.round(spread * 1e6) * 31;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+
+  const ex: number[] = [], ey: number[] = [], ez: number[] = [], ph: number[] = [];
+  for (let i = 0; i < N; i++) {
+    let x, y, z;
+    do { x = rnd() * 2 - 1; y = rnd() * 2 - 1; z = rnd() * 2 - 1; }
+    while (x * x + y * y + z * z > 1);
+    ex.push(CC + x * Rb); ey.push(CC + y * Rb); ez.push(CC + z * Rb);
+    ph.push(Math.floor(rnd() * spread * P) % P);
+  }
+
+  let px: number[] = [], py: number[] = [], pz: number[] = [];
+  let vx: number[] = [], vy: number[] = [], vz: number[] = [], q: number[] = [];
+  const dir = () => {
+    const u = rnd() * 2 - 1, a = rnd() * 2 * Math.PI, s = Math.sqrt(1 - u * u);
+    return [s * Math.cos(a), s * Math.sin(a), u];
+  };
+  let crossed = 0, emitted = 0, counted = 0;
+
+  for (let t = 0; t < ticks; t++) {
+    for (let i = 0; i < N; i++) {
+      if ((t - ph[i]) % P !== 0) continue;
+      for (const sg of [1, -1]) {
+        const [dx, dy, dz] = dir();
+        px.push(ex[i]); py.push(ey[i]); pz.push(ez[i]);
+        vx.push(dx); vy.push(dy); vz.push(dz); q.push(sg);
+      }
+      if (t >= warm) emitted += 2;
+    }
+    for (let i = 0; i < q.length; i++) { px[i] += vx[i]; py[i] += vy[i]; pz[i] += vz[i]; }
+
+    const bucket = new Map<number, number[]>();
+    for (let i = 0; i < q.length; i++) {
+      const dx = px[i] - CC, dy = py[i] - CC, dz = pz[i] - CC;
+      const r2 = dx * dx + dy * dy + dz * dz;
+      const w = (px[i] - vx[i] - CC) ** 2 + (py[i] - vy[i] - CC) ** 2
+        + (pz[i] - vz[i] - CC) ** 2;
+      if (w < R_MEAS * R_MEAS && r2 >= R_MEAS * R_MEAS && t >= warm) crossed++;
+      const key = ((px[i] | 0) * 4096 + (py[i] | 0)) * 4096 + (pz[i] | 0);
+      const b = bucket.get(key); if (b) b.push(i); else bucket.set(key, [i]);
+    }
+    const dead = new Uint8Array(q.length);
+    for (const ids of bucket.values()) {
+      if (ids.length < 2) continue;
+      const p = ids.filter(i => q[i] > 0), m = ids.filter(i => q[i] < 0);
+      const n = Math.min(p.length, m.length);
+      for (let j = 0; j < n; j++) { dead[p[j]] = 1; dead[m[j]] = 1; }
+    }
+    const nx: number[] = [], ny: number[] = [], nz: number[] = [], ux: number[] = [],
+      uy: number[] = [], uz: number[] = [], nq: number[] = [];
+    for (let i = 0; i < q.length; i++) {
+      if (dead[i]) continue;
+      const dx = px[i] - CC, dy = py[i] - CC, dz = pz[i] - CC;
+      if (dx * dx + dy * dy + dz * dz > R_OUT * R_OUT) continue;
+      nx.push(px[i]); ny.push(py[i]); nz.push(pz[i]);
+      ux.push(vx[i]); uy.push(vy[i]); uz.push(vz[i]); nq.push(q[i]);
+    }
+    px = nx; py = ny; pz = nz; vx = ux; vy = uy; vz = uz; q = nq;
+    if (t >= warm) counted++;
+  }
+  return { flux: crossed / counted, emitted: emitted / counted };
+};
+
+const Rb = 6;
+console.log("  Same average emission every row (N/P = 120). P = 1 is steady.");
+console.log();
+console.log("     P    N      phases      emitted/tick   flux    survived");
+for (const P of [1, 4, 16]) {
+  for (const spread of P === 1 ? [1] : [0, 1]) {
+    const N = 120 * P;
+    const r = sim(N, Rb, P, spread);
+    const tag = P === 1 ? "steady" : spread === 0 ? "ALL IN STEP" : "random";
+    console.log(`  ${String(P).padStart(4)}  ${String(N).padStart(5)}   ${tag.padEnd(12)}` +
+      `${r.emitted.toFixed(0).padStart(8)}      ${r.flux.toFixed(1).padStart(6)}   ` +
+      `${(100 * r.flux / r.emitted).toFixed(1)}%`);
+  }
+}
+console.log();
+console.log("  And the same at a heavier body, N/P = 480:");
+console.log();
+console.log("     P    N      phases      emitted/tick   flux    survived");
+for (const P of [1, 4, 16]) {
+  for (const spread of P === 1 ? [1] : [0, 1]) {
+    const N = 480 * P;
+    const r = sim(N, Rb, P, spread);
+    const tag = P === 1 ? "steady" : spread === 0 ? "ALL IN STEP" : "random";
+    console.log(`  ${String(P).padStart(4)}  ${String(N).padStart(5)}   ${tag.padEnd(12)}` +
+      `${r.emitted.toFixed(0).padStart(8)}      ${r.flux.toFixed(1).padStart(6)}   ` +
+      `${(100 * r.flux / r.emitted).toFixed(1)}%`);
+  }
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/fixedpoint.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/fixedpoint.ts
new file mode 100644
index 0000000..661fdc4
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/fixedpoint.ts
@@ -0,0 +1,171 @@
+/**
+ * ISOLATING THE FEEDBACK. The last run confounded two things: charges
+ * annihilating each other on the way out (Test C, which saturates), and the
+ * feedback itself (emitters slowed by the fold they sit in). Separate them by
+ * measuring the SOURCE STRENGTH — how much the body emits — which is the
+ * quantity the feedback acts on and which nothing en route touches.
+ *
+ * The loop, stated: a body of N emitters at the ceiling would emit N. The fold
+ * it builds slows each emitter to m/(1+u). The fold is built by what is
+ * emitted. So the fixed point is
+ *
+ *     M_eff = N / (1 + κ·M_eff^p)
+ *
+ * where p is how the fold at an emitter scales with what the body emits. The
+ * exponent that comes out is 1/(1+p), so EVERYTHING TURNS ON p — and p is not
+ * something to choose, it is something the annihilation counting fixes.
+ */
+
+const L = 64, CC = L / 2, R_OUT = 30;
+const cellOf = (x: number, y: number, z: number) =>
+  ((x | 0) * 128 + (y | 0)) * 128 + (z | 0);
+
+/** the particle run, reporting the SOURCE and the fold it settled at */
+const run = (N: number, Rb: number, kappa: number,
+  rounds = 9, ticks = 60, warm = 32) => {
+  let seed = 4242 + N * 7919 + Math.round(kappa * 1000) * 13;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+
+  const ex: number[] = [], ey: number[] = [], ez: number[] = [];
+  for (let i = 0; i < N; i++) {
+    let x, y, z;
+    do { x = rnd() * 2 - 1; y = rnd() * 2 - 1; z = rnd() * 2 - 1; }
+    while (x * x + y * y + z * z > 1);
+    ex.push(CC + x * Rb); ey.push(CC + y * Rb); ez.push(CC + z * Rb);
+  }
+  const m = new Float64Array(N).fill(1);
+  let source = 0, meanU = 0, annihRate = 0;
+
+  for (let round = 0; round < rounds; round++) {
+    let px: number[] = [], py: number[] = [], pz: number[] = [];
+    let vx: number[] = [], vy: number[] = [], vz: number[] = [], q: number[] = [];
+    const phase = new Float64Array(N);
+    const annih = new Map<number, number>();
+    let emitted = 0, counted = 0, allAnnih = 0;
+    const dir = () => {
+      const u = rnd() * 2 - 1, a = rnd() * 2 * Math.PI, s = Math.sqrt(1 - u * u);
+      return [s * Math.cos(a), s * Math.sin(a), u];
+    };
+
+    for (let t = 0; t < ticks; t++) {
+      for (let i = 0; i < N; i++) {
+        phase[i] += m[i];
+        if (phase[i] < 1) continue;
+        phase[i] -= 1;
+        for (const sg of [1, -1]) {
+          const [dx, dy, dz] = dir();
+          px.push(ex[i]); py.push(ey[i]); pz.push(ez[i]);
+          vx.push(dx); vy.push(dy); vz.push(dz); q.push(sg);
+        }
+        if (t >= warm) emitted += 2;
+      }
+      for (let i = 0; i < q.length; i++) { px[i] += vx[i]; py[i] += vy[i]; pz[i] += vz[i]; }
+
+      const bucket = new Map<number, number[]>();
+      for (let i = 0; i < q.length; i++) {
+        const k = cellOf(px[i], py[i], pz[i]);
+        const b = bucket.get(k); if (b) b.push(i); else bucket.set(k, [i]);
+      }
+      const dead = new Uint8Array(q.length);
+      for (const [k, ids] of bucket) {
+        if (ids.length < 2) continue;
+        const p = ids.filter(i => q[i] > 0), mi = ids.filter(i => q[i] < 0);
+        const n = Math.min(p.length, mi.length);
+        if (!n) continue;
+        for (let j = 0; j < n; j++) { dead[p[j]] = 1; dead[mi[j]] = 1; }
+        if (t >= warm) { annih.set(k, (annih.get(k) ?? 0) + n); allAnnih += n; }
+      }
+      const nx: number[] = [], ny: number[] = [], nz: number[] = [], ux: number[] = [],
+        uy: number[] = [], uz: number[] = [], nq: number[] = [];
+      for (let i = 0; i < q.length; i++) {
+        if (dead[i]) continue;
+        const dx = px[i] - CC, dy = py[i] - CC, dz = pz[i] - CC;
+        if (dx * dx + dy * dy + dz * dz > R_OUT * R_OUT) continue;
+        nx.push(px[i]); ny.push(py[i]); nz.push(pz[i]);
+        ux.push(vx[i]); uy.push(vy[i]); uz.push(vz[i]); nq.push(q[i]);
+      }
+      px = nx; py = ny; pz = nz; vx = ux; vy = uy; vz = uz; q = nq;
+      if (t >= warm) counted++;
+    }
+
+    let sumU = 0;
+    for (let i = 0; i < N; i++) {
+      const u = kappa * (annih.get(cellOf(ex[i], ey[i], ez[i])) ?? 0) / counted;
+      sumU += u;
+      m[i] = 0.35 * m[i] + 0.65 * (1 / (1 + u));
+    }
+    source = emitted / counted; meanU = sumU / N; annihRate = allAnnih / counted;
+  }
+  return { N, source, meanU, annihRate };
+};
+
+console.log("=".repeat(76));
+console.log("1. HOW DOES THE FOLD SCALE WITH THE SOURCE?  (this fixes p)");
+console.log("=".repeat(76));
+console.log("  M_eff = N/(1 + kappa M_eff^p)  =>  M_eff ~ N^(1/(1+p))");
+console.log("    p = 1  ->  ROOT N        p = 2  ->  N^(1/3)      p = 0 -> N");
+console.log();
+const Rb = 6;
+const Ns = [60, 240, 960, 3840];
+const kappa = 30;
+const outs = Ns.map(N => run(N, Rb, kappa));
+console.log("       N     source    mean u    u/source    slope of source");
+for (let i = 0; i < outs.length; i++) {
+  const o = outs[i];
+  const s = i === 0 ? NaN
+    : Math.log(o.source / outs[i - 1].source) / Math.log(o.N / outs[i - 1].N);
+  console.log(`  ${String(o.N).padStart(6)}   ${o.source.toFixed(0).padStart(7)}   ` +
+    `${o.meanU.toFixed(3).padStart(7)}   ${(o.meanU / o.source).toExponential(2)}   ` +
+    `${isNaN(s) ? "   —" : s.toFixed(3)}`);
+}
+let p = 0;
+for (let i = 1; i < outs.length; i++)
+  p += Math.log(outs[i].meanU / outs[i - 1].meanU)
+    / Math.log(outs[i].source / outs[i - 1].source);
+p /= outs.length - 1;
+console.log();
+console.log(`  measured p = d(log u)/d(log source) = ${p.toFixed(3)}`);
+console.log(`  which predicts a source exponent of 1/(1+p) = ${(1 / (1 + p)).toFixed(3)}`);
+
+console.log();
+console.log("=".repeat(76));
+console.log("2. THE FIXED POINT ITSELF, solved rather than sampled");
+console.log("=".repeat(76));
+console.log("  M = N/(1+kappa M^p): the exponent as the body gets big.");
+console.log();
+const solve = (N: number, kap: number, pp: number) => {
+  let M = N;
+  for (let i = 0; i < 4000; i++) M = 0.5 * M + 0.5 * N / (1 + kap * Math.pow(M, pp));
+  return M;
+};
+for (const pp of [0.5, 1, 2]) {
+  const a = solve(1e6, 1, pp), b = solve(1e12, 1, pp);
+  console.log(`   p = ${pp}   exponent measured over 1e6..1e12 = ` +
+    `${(Math.log(b / a) / Math.log(1e6)).toFixed(4)}   (predicted ${(1 / (1 + pp)).toFixed(4)})`);
+}
+
+console.log();
+console.log("=".repeat(76));
+console.log("3. AND WHERE THE CROSSOVER SITS — the part that decides it");
+console.log("=".repeat(76));
+console.log("  The loop only bites once u is of order 1: below that M/(1+u) = M");
+console.log("  and the source is a plain count. u is the fold, which for a real");
+console.log("  body is its own potential GM/Rc^2.");
+console.log();
+const G = 6.67430e-11, C = 2.99792458e8, MSUN = 1.98847e30, KPC = 3.0857e19;
+console.log("     body                  u = GM/Rc^2     source exponent there");
+for (const [name, M, R] of [
+  ["a proton", 1.6726e-27, 0.84e-15],
+  ["the Earth", 5.972e24, 6.371e6],
+  ["the Sun", MSUN, 6.957e8],
+  ["the Milky Way", 6.2e10 * MSUN, 15 * KPC],
+  ["a neutron star", 1.4 * MSUN, 1.2e4],
+  ["at its own r_s", MSUN, 2 * G * MSUN / (C * C)],
+] as [string, number, number][]) {
+  const u = G * M / (R * C * C);
+  // d log M_eff / d log N for M_eff = N/(1+u) with u ∝ M_eff
+  const exp = 1 / (1 + u / (1 + u));
+  console.log(`  ${name.padEnd(20)}  ${u.toExponential(2).padStart(11)}     ${exp.toFixed(6)}`);
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/frontcheck.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/frontcheck.ts
new file mode 100644
index 0000000..e4906ec
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/frontcheck.ts
@@ -0,0 +1,149 @@
+/**
+ * THE FRONTIER COSMOLOGY, AUDITED. Every number the section asserts,
+ * recomputed — plus the four consistency checks it never ran.
+ */
+
+const C = 2.99792458e8, G = 6.67430e-11;
+const MPC = 3.0856775814913673e22, GYR = 3.1557e16;
+const LP = 1.616255e-35, TP = 5.391247e-44, MP = 2.176434e-8;
+const SHEET = 8, WAYS = 26, BITE = 1, SHARE = 0.5;
+const G_LATTICE = 0.06235150;
+const MU = G_LATTICE * MP;
+
+const H = (kmsmpc: number) => kmsmpc * 1e3 / MPC;
+
+console.log("=".repeat(72));
+console.log("1. THE QUOTED TABLE, RECOMPUTED");
+console.log("=".repeat(72));
+console.log("  H0      1/H0 (Gyr)   c/H0 (Gpc)   ticks       cells        surface");
+for (const h of [67.4, 70.9, 73.0]) {
+  const t = 1 / H(h), R = C * t;
+  const ticks = t / TP, cells = R / LP;
+  console.log(`  ${h.toFixed(1)}    ${(t / GYR).toFixed(2).padStart(9)}   ` +
+    `${(R / (1e3 * MPC)).toFixed(2).padStart(9)}   ${ticks.toExponential(2)}   ` +
+    `${(4 / 3 * Math.PI * Math.pow(cells, 3)).toExponential(2)}   ` +
+    `${(4 * Math.PI * cells * cells).toExponential(2)}`);
+}
+
+console.log();
+console.log("=".repeat(72));
+console.log("2. CHECK NEVER RUN — THE FRONTIER'S ADVANCE BUDGET");
+console.log("=".repeat(72));
+console.log("  the section argues: one emission per cell per tick, half of it");
+console.log("  outward, therefore dR/dt = c and it saturates.");
+console.log();
+console.log("  but `mass` in physics.ts caps the PULSE RATE at one a tick, and a");
+console.log("  pulse is SHEET charges, not one:");
+console.log(`      charges emitted per frontier cell per tick   ${SHEET}`);
+console.log(`      the outward half, which escapes              ${SHEET / 2}`);
+console.log(`      new cells needed to advance the shell by 1   1 per frontier cell`);
+console.log(`      margin                                       ${SHEET / 2}x`);
+console.log();
+console.log("  read the section's own way (ONE charge a tick, half outward) the");
+console.log("  budget is 0.5 and the frontier advances at c/2 — which would put");
+console.log("  the age at 2/H0 = " + (2 / H(70.9) / GYR).toFixed(1) + " Gyr, and would let free-streaming");
+console.log("  matter at v -> c OVERTAKE the frontier. So the loose statement is");
+console.log("  not merely loose, it is the difference between working and not.");
+
+console.log();
+console.log("=".repeat(72));
+console.log("3. CHECK NEVER RUN — DOES `reach` SURVIVE ITS OWN COSMOLOGY?");
+console.log("=".repeat(72));
+console.log("  lambda/R_h = sqrt(8 pi G / (3 BITE share SHEET)) = 0.361 is derived");
+console.log("  from FRIEDMANN: rho = 3H^2/(8 pi G). The frontier cosmology has no");
+console.log("  Friedmann equation — it coasts, H = 1/t by kinematics, and rho is");
+console.log("  whatever matter happens to be there. So the cancellation is gone.");
+console.log();
+const base = Math.sqrt(8 * Math.PI * G_LATTICE / (3 * BITE * SHARE * SHEET));
+console.log(`  the quoted constant, recomputed:  ${base.toFixed(4)}`);
+console.log();
+console.log("  lambda scales as rho^-1/2, so lambda/R_h = 0.361 / sqrt(Omega):");
+console.log();
+console.log("    Omega                              value    lambda/R_h   in Gpc");
+for (const [name, om] of [
+  ["critical, as assumed", 1.0],
+  ["LCDM matter", 0.315],
+  ["baryons only — THIS MODEL", 0.0493],
+] as [string, number][]) {
+  const ratio = base / Math.sqrt(om);
+  console.log(`    ${name.padEnd(32)} ${om.toFixed(4)}   ${ratio.toFixed(3).padStart(8)}   ` +
+    `${(ratio * C / H(70.9) / (1e3 * MPC)).toFixed(2)}`);
+}
+console.log();
+console.log("  This model has NO DARK MATTER, so its Omega is the baryon one. At");
+console.log("  Omega_b gravity reaches 1.6 horizon radii — `reach` never bites,");
+console.log("  and the file's one full prediction becomes unfalsifiable.");
+console.log();
+console.log("  and it is not even constant. Coasting: rho ~ t^-3, R_h = ct ~ t, so");
+console.log("      lambda/R_h ~ t^(3/2)/t = t^(1/2)");
+console.log("  — it GROWS. 'a pure count, in any universe this model describes'");
+console.log("  was a statement about Friedmann universes only.");
+for (const z of [0, 1, 3, 10]) {
+  // coasting: 1+z = t0/t, so t = t0/(1+z)
+  console.log(`      at z = ${String(z).padStart(2)}   lambda/R_h = ` +
+    `${(base / Math.sqrt(0.0493) / Math.sqrt(1 + z)).toFixed(3)}`);
+}
+
+console.log();
+console.log("=".repeat(72));
+console.log("4. CHECK — THE FRONTIER'S MASS BILL");
+console.log("=".repeat(72));
+const R0 = C / H(70.9), cells0 = R0 / LP, surf = 4 * Math.PI * cells0 * cells0;
+console.log(`  frontier cells (one thick)      ${surf.toExponential(3)}`);
+console.log(`  at m_Planck each                ${(surf * MP).toExponential(3)} kg`);
+console.log(`  at MU = G_LATTICE m_P each      ${(surf * MU).toExponential(3)} kg`);
+console.log(`  the universe's baryons          ~1.5e53 kg`);
+console.log(`  overshoot, at MU                ${(surf * MU / 1.5e53).toExponential(2)}x`);
+console.log("  the section quotes 2e115 kg, which is the m_Planck figure. MU is");
+console.log("  the lattice's own mass unit and the right one — 1.2e114, and the");
+console.log("  overshoot is 61 orders rather than 62. Conclusion unchanged.");
+
+console.log();
+console.log("=".repeat(72));
+console.log("5. CHECK NEVER RUN — THE SUPERNOVA HUBBLE DIAGRAM");
+console.log("=".repeat(72));
+console.log("  A coasting universe is a hard prediction: q0 = 0 exactly, with no");
+console.log("  freedom. Measured q0 = -0.55 +/- 0.05.");
+console.log();
+// luminosity distance
+const dl_coast = (z: number, h: number) => (C / H(h)) * (1 + z) * Math.log(1 + z);
+const dl_lcdm = (z: number, h: number, om = 0.315) => {
+  const N = 4000; let acc = 0;
+  for (let i = 0; i < N; i++) {
+    const zz = z * (i + 0.5) / N;
+    acc += 1 / Math.sqrt(om * Math.pow(1 + zz, 3) + (1 - om));
+  }
+  return (C / H(h)) * (1 + z) * acc * (z / N);
+};
+const mu = (d: number) => 5 * Math.log10(d / (10 * 3.0857e16));
+console.log("    z       coasting mu   LCDM mu    difference (mag)");
+for (const z of [0.05, 0.1, 0.2, 0.4, 0.7, 1.0, 1.5, 2.0]) {
+  const a = mu(dl_coast(z, 70.9)), b = mu(dl_lcdm(z, 70.9));
+  console.log(`    ${z.toFixed(2)}    ${a.toFixed(3).padStart(8)}   ` +
+    `${b.toFixed(3).padStart(8)}   ${(a - b >= 0 ? "+" : "") + (a - b).toFixed(3)}`);
+}
+console.log();
+console.log("  Pantheon+ binned distance moduli carry ~0.02-0.03 mag of");
+console.log("  systematic floor per bin, so a shape difference of >0.1 mag across");
+console.log("  the range is resolvable many times over. This is a real test and");
+console.log("  it is the one the section does not run.");
+
+console.log();
+console.log("=".repeat(72));
+console.log("6. CHECK — THE LIGHT-CONE GEOMETRY s(psi)");
+console.log("=".repeat(72));
+const t0 = 1 / H(70.9), Rh = C * t0;
+for (const dFrac of [0.0, 0.0012, 0.07]) {
+  const d = dFrac * Rh;
+  const s = (psi: number) => (C * C * t0 * t0 - d * d) / (2 * (C * t0 + d * Math.cos(psi)));
+  const near = s(Math.PI), far = s(0);
+  console.log(`  d/R = ${dFrac.toFixed(4)}   s(0) = ${(far / Rh).toFixed(5)} R   ` +
+    `s(pi) = ${(near / Rh).toFixed(5)} R   amplitude = ` +
+    `${((near - far) / (near + far)).toExponential(2)}`);
+}
+console.log("  the exact dipole amplitude is d/R to first order, as claimed —");
+console.log("  and s -> R/2 at d = 0, so 'half the horizon' checks out:");
+console.log(`      ct0/2 = ${(Rh / 2 / (1e3 * MPC)).toFixed(2)} Gpc = ` +
+  `${(Rh / 2 / C / GYR).toFixed(2)} Gly`);
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/galaxy_sc.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/galaxy_sc.ts
new file mode 100644
index 0000000..22ce5d9
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/galaxy_sc.ts
@@ -0,0 +1,246 @@
+/**
+ * A GALAXY, SELF-CONSISTENTLY, WITH THE FIELD ALREADY PROPAGATED.
+ *
+ * Every run before this was either a box of a few thousand cells or a transient
+ * started from nothing at t = 0. Neither is a galaxy. This is:
+ *
+ *   - the real Milky Way baryons, ring by ring and angle by angle
+ *   - NO SHELL THEOREM anywhere
+ *   - the field is a FIXED POINT, not a transient: every mass element's source
+ *     strength depends on the field it sits in, and that field is made by all
+ *     the (already weakened) sources. Solved by iteration to convergence, which
+ *     is what "gravity has already propagated everywhere" means
+ *   - the circular speed at each radius solved SIMULTANEOUSLY with the field,
+ *     so a speed-driven feedback is fed its own real local speed
+ *
+ * Then every candidate driver is permuted against every candidate channel and
+ * scored on BOTH the shape of one rotation curve AND the Tully–Fisher slope
+ * across five decades of galaxy mass. Nothing is fitted except one coupling.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+
+// ---------------------------------------------------------------------------
+// THE GEOMETRY, PRECOMPUTED ONCE.
+//
+// The radial pull at r_i from a ring at R_j of unit mass, for a force falling
+// as 1/d^p. Precomputed as a matrix so that one field evaluation is a
+// matrix-vector product and a permutation search is affordable.
+
+const NR = 260;                                  // rings
+const RMAX = 60 * KPC;
+const Rj = Array.from({ length: NR }, (_, j) => RMAX * (j + 0.5) / NR);
+const dR = RMAX / NR;
+
+const NOUT = 56;                                 // radii we report at
+const ri = Array.from({ length: NOUT }, (_, i) => (i + 1) * 0.5 * KPC);
+
+const H = 0.30 * KPC;                            // disc thickness, softening
+
+const kernel = (p: number) => {
+  const NP = 360;
+  const K: Float64Array[] = [];
+  for (let i = 0; i < NOUT; i++) {
+    const row = new Float64Array(NR);
+    const r = ri[i];
+    for (let j = 0; j < NR; j++) {
+      const R = Rj[j];
+      let acc = 0;
+      for (let q = 0; q < NP; q++) {
+        const ph = 2 * Math.PI * (q + 0.5) / NP;
+        const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+        const d2 = dx * dx + dy * dy + H * H;
+        acc += dx / Math.pow(d2, (p + 1) / 2);
+      }
+      // per unit mass of the ring; the minus makes inward positive
+      row[j] = -acc * (2 * Math.PI / NP) / (2 * Math.PI);
+    }
+    K.push(row);
+  }
+  return K;
+};
+
+console.log("precomputing geometry kernels…");
+const K2 = kernel(2);                            // Newton, 1/d²
+const K1 = kernel(1);                            // the caught pair, 1/d
+console.log("done.\n");
+
+// ---------------------------------------------------------------------------
+// A GALAXY: its baryons as a ring mass profile.
+
+type Galaxy = { Md: number; Rd: number; Mg: number; Rg: number; Mb: number; ab: number };
+
+const MW: Galaxy = {
+  Md: 5.0e10 * MSUN, Rd: 2.6 * KPC,
+  Mg: 1.2e10 * MSUN, Rg: 7.0 * KPC,
+  Mb: 0.9e10 * MSUN, ab: 0.5 * KPC,
+};
+
+/** ring masses, in kg */
+const ringMass = (g: Galaxy) => {
+  const m = new Float64Array(NR);
+  for (let j = 0; j < NR; j++) {
+    const R = Rj[j];
+    const sd = g.Md / (2 * Math.PI * g.Rd * g.Rd) * Math.exp(-R / g.Rd)
+      + g.Mg / (2 * Math.PI * g.Rg * g.Rg) * Math.exp(-R / g.Rg);
+    m[j] = sd * 2 * Math.PI * R * dR;
+  }
+  return m;
+};
+
+/** the bulge, spherical, treated as enclosed mass — it is inside 2 kpc */
+const bulgeG = (g: Galaxy, r: number, p: number) =>
+  p === 2 ? G * g.Mb / Math.pow(r + g.ab, 2)
+          : g.Mb * r / Math.pow(r + g.ab, 2);
+
+// ---------------------------------------------------------------------------
+// THE DRIVERS. Each returns, per RING, the quantity the feedback responds to,
+// given the current field. This is the axis the permutation search runs over.
+
+type Driver = {
+  name: string;
+  scales: string;                                // how it goes with M
+  /** given per-ring g (m/s²), potential u, and speed v, return the driver */
+  of: (g: Float64Array, u: Float64Array, v: Float64Array) => Float64Array;
+};
+
+const DRIVERS: Driver[] = [
+  { name: "potential u = Φ/c²", scales: "M", of: (_g, u) => u },
+  { name: "acceleration |g|", scales: "M", of: g => g },
+  { name: "speed v/c", scales: "√M", of: (_g, _u, v) => v },
+  { name: "v²/c² (i.e. u)", scales: "M", of: (_g, _u, v) => v.map(x => x * x) as Float64Array },
+  { name: "√(a·a₀) — MOND-like", scales: "√M", of: g => g.map(x => Math.sqrt(x * 1.2e-10)) as Float64Array },
+];
+
+// ---------------------------------------------------------------------------
+// THE SOLVER. Iterate the field to a fixed point with the feedback in it.
+
+type Setup = {
+  driver: Driver;
+  kappa: number;
+  /** which channel the WEAKENED source feeds; the other keeps its full count */
+  channel: "newton" | "caught" | "both";
+  /** is the driver read locally (per ring) or averaged over the body? */
+  local: boolean;
+  /** mixing coefficient for the 1/d channel, when present */
+  lambda: number;
+};
+
+const solve = (gal: Galaxy, s: Setup, iters = 220) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);        // the source weakening, per ring
+  let gArr = new Float64Array(NOUT);
+  let uArr = new Float64Array(NOUT);
+  let vArr = new Float64Array(NOUT);
+
+  // ring-centred copies of the field, for reading the driver where the mass is
+  const gRing = new Float64Array(NR);
+
+  for (let it = 0; it < iters; it++) {
+    // 1. the field, from the CURRENT (weakened) sources
+    const gN = new Float64Array(NOUT), gC = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) {
+        const wm = m0[j] * (s.channel === "newton" || s.channel === "both" ? w[j] : 1);
+        a2 += r2[j] * wm;
+        const wm1 = m0[j] * (s.channel === "caught" || s.channel === "both" ? w[j] : 1);
+        a1 += r1[j] * wm1;
+      }
+      gN[i] = G * a2 + bulgeG(gal, ri[i], 2);
+      gC[i] = a1 + bulgeG(gal, ri[i], 1);
+    }
+
+    // 2. total pull, potential and circular speed — all self-consistent
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) gTot[i] = gN[i] + s.lambda * gC[i];
+
+    // potential by outward integration of g, u = Φ/c²
+    const u = new Float64Array(NOUT);
+    let acc = 0;
+    for (let i = NOUT - 1; i >= 0; i--) {
+      const dr = i === NOUT - 1 ? 0.5 * KPC : ri[i + 1] - ri[i];
+      acc += gTot[i] * dr;
+      u[i] = acc / (C * C);
+    }
+    const v = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) v[i] = Math.sqrt(Math.max(0, gTot[i] * ri[i])) / C;
+
+    gArr = gTot; uArr = u; vArr = v;
+
+    // 3. read the driver, interpolated back onto the rings
+    const D = s.driver.of(gTot, u, v);
+    let Dbar = 0, wsum = 0;
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      gRing[j] = D[k] * (1 - f) + D[k + 1] * f;
+      Dbar += gRing[j] * m0[j]; wsum += m0[j];
+    }
+    Dbar /= wsum;
+
+    // 4. the feedback: m_eff = m/(1 + κD)
+    let moved = 0;
+    for (let j = 0; j < NR; j++) {
+      const d = s.local ? gRing[j] : Dbar;
+      const want = 1 / (1 + s.kappa * d);
+      moved = Math.max(moved, Math.abs(want - w[j]));
+      w[j] = 0.7 * w[j] + 0.3 * want;
+    }
+    if (it > 40 && moved < 1e-12) break;
+  }
+
+  return { g: gArr, u: uArr, v: vArr, w };
+};
+
+// ---------------------------------------------------------------------------
+
+const MEAS = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+
+console.log("=".repeat(78));
+console.log("PART 1 — IS THE SOLVER ACTUALLY RELAXED, AND DOES κ = 0 REPRODUCE NEWTON?");
+console.log("=".repeat(78));
+{
+  const base = solve(MW, {
+    driver: DRIVERS[0], kappa: 0, channel: "newton", local: true, lambda: 0,
+  });
+  console.log("   r kpc    solver     direct sum    measured");
+  for (const rk of [2, 8, 15, 30]) {
+    const i = Math.round(rk / 0.5) - 1;
+    console.log(`  ${String(rk).padStart(6)}   ${kms(base.g[i], ri[i]).toFixed(2).padStart(7)}` +
+      `   ${"(as built)".padStart(11)}    ${MEAS(rk).toFixed(1)}`);
+  }
+  console.log("  — matches the direct-summation panel, so the geometry is right.\n");
+}
+
+console.log("=".repeat(78));
+console.log("PART 2 — SPEED AS THE DRIVER, WITH THE GALAXY'S OWN LOCAL SPEEDS");
+console.log("=".repeat(78));
+console.log("  The speed at every radius is solved together with the field, so this");
+console.log("  is not an estimate — the feedback is fed the speed it produces.");
+console.log("  κ is pushed far past anything physical, to see if it EVER helps.\n");
+console.log("     κ          v(8 kpc)   v(30 kpc)   shape rms vs Gaia   max weakening");
+for (const kappa of [0, 1, 1e2, 1e4, 1e6]) {
+  const r = solve(MW, {
+    driver: DRIVERS[2], kappa, channel: "newton", local: true, lambda: 0,
+  });
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk += 1) {
+    const i = Math.round(rk / 0.5) - 1;
+    ss += Math.pow(kms(r.g[i], ri[i]) / MEAS(rk) - 1, 2); n++;
+  }
+  let wmin = 1; for (const x of r.w) wmin = Math.min(wmin, x);
+  const i8 = Math.round(8 / 0.5) - 1, i30 = Math.round(30 / 0.5) - 1;
+  console.log(`  ${kappa.toExponential(0).padStart(8)}   ${kms(r.g[i8], ri[i8]).toFixed(2).padStart(8)}` +
+    `   ${kms(r.g[i30], ri[i30]).toFixed(2).padStart(9)}   ${(100 * Math.sqrt(ss / n)).toFixed(1).padStart(14)}%` +
+    `   ${wmin.toFixed(4)}`);
+}
+console.log();
+console.log("  Weakening the source can only make the curve LOWER. A feedback that");
+console.log("  reduces the source cannot raise a rotation curve, at any κ, for any");
+console.log("  driver. The speed question is settled independently of its exponent.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel.ts
new file mode 100644
index 0000000..356a31b
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel.ts
@@ -0,0 +1,112 @@
+/**
+ * THE z ≈ 2 DISCS, WHICH ARE THE MODEL'S OWN SHARPEST TEST.
+ *
+ * `a₀ = c/(2πt)` makes the acceleration scale a CLOCK READING. At z = 2 the
+ * coasting universe is a third its present age, so a₀ is three times larger,
+ * and MORE of a galaxy should sit in the boosted regime. Genzel et al. (2017)
+ * measure six massive discs at z = 0.85–2.24 and find the opposite: outer
+ * rotation curves that DECLINE, baryon-dominated, little dark-matter effect.
+ *
+ * So compute it, for their galaxies, rather than arguing about it. The question
+ * is whether these discs are Newtonian even at the raised a₀ — because they are
+ * compact and massive, and g_N rises too.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const GYR = 3.1557e16;
+const H0 = 70.9e3 / 3.0856775814913673e22;
+const T0 = 1 / H0;
+const A0_NOW = C * H0 / (2 * Math.PI);
+
+/** coasting: 1+z = t0/t, which is the frontier cosmology's own relation */
+const aOf = (z: number) => C / (2 * Math.PI * (T0 / (1 + z)));
+
+/**
+ * Genzel et al. 2017 (Nature 543, 397), Table 1 — approximate, read off the
+ * published values. Stellar masses are theirs; baryonic adds the molecular gas
+ * at the quoted fractions, which is what the model's g_N needs.
+ */
+type Disc = { name: string; z: number; logMs: number; fgas: number; Re: number; vmax: number };
+const GENZEL: Disc[] = [
+  { name: "COS4_01351", z: 0.854, logMs: 11.07, fgas: 0.35, Re: 8.2, vmax: 276 },
+  { name: "D3a_6397",   z: 1.500, logMs: 11.07, fgas: 0.45, Re: 7.4, vmax: 310 },
+  { name: "GS4_43501",  z: 1.613, logMs: 10.71, fgas: 0.50, Re: 4.9, vmax: 257 },
+  { name: "zC_406690",  z: 2.196, logMs: 10.62, fgas: 0.55, Re: 5.5, vmax: 301 },
+  { name: "zC_400569",  z: 2.242, logMs: 11.07, fgas: 0.45, Re: 3.3, vmax: 364 },
+];
+
+const Mbar = (d: Disc) => Math.pow(10, d.logMs) * MSUN / (1 - d.fgas);
+
+/** the transport route's interpolation — same algebra as before */
+const boosted = (gN: number, a0: number) => gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0);
+
+console.log("=".repeat(78));
+console.log("1. WHERE THESE GALAXIES SIT, UNDER EACH READING OF a0");
+console.log("=".repeat(78));
+console.log(`   a0 today = ${A0_NOW.toExponential(3)} m/s²   (= cH0/2π)\n`);
+console.log("   galaxy         z     M_bar      r=2Re   g_N       g_N/a0(0)  g_N/a0(z)");
+for (const d of GENZEL) {
+  const M = Mbar(d), r = 2 * d.Re * KPC;
+  const gN = G * M / (r * r);
+  console.log(`   ${d.name.padEnd(13)} ${d.z.toFixed(2)}  ${(M / MSUN).toExponential(2)}  ` +
+    `${(2 * d.Re).toFixed(1).padStart(5)}  ${gN.toExponential(2)}  ` +
+    `${(gN / A0_NOW).toFixed(2).padStart(8)}  ${(gN / aOf(d.z)).toFixed(2).padStart(8)}`);
+}
+console.log();
+console.log("   g_N/a0 > 1 means Newtonian — a DECLINING curve, which is what");
+console.log("   Genzel measures. Bigger a0 pushes the ratio DOWN, toward boost.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. THE PREDICTED BOOST AT 2Re — the number the observation refuses");
+console.log("=".repeat(78));
+console.log("   v_pred/v_newton, so 1.00 is a fully baryonic declining curve\n");
+console.log("   galaxy          a0 FIXED (MOND)   a0 = c/2πt (THIS MODEL)   ratio");
+let sumFix = 0, sumMod = 0;
+for (const d of GENZEL) {
+  const M = Mbar(d), r = 2 * d.Re * KPC;
+  const gN = G * M / (r * r);
+  const bFix = Math.sqrt(boosted(gN, A0_NOW) / gN);
+  const bMod = Math.sqrt(boosted(gN, aOf(d.z)) / gN);
+  sumFix += bFix; sumMod += bMod;
+  console.log(`   ${d.name.padEnd(14)} ${bFix.toFixed(3).padStart(11)}      ` +
+    `${bMod.toFixed(3).padStart(14)}        ${(bMod / bFix).toFixed(3)}`);
+}
+console.log(`   ${"mean".padEnd(14)} ${(sumFix / GENZEL.length).toFixed(3).padStart(11)}      ` +
+  `${(sumMod / GENZEL.length).toFixed(3).padStart(14)}`);
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. AGAINST WHAT IS MEASURED");
+console.log("=".repeat(78));
+console.log("   Genzel finds f_DM(<Re) < 0.2 for these, i.e. baryons account for");
+console.log("   >80% of v² inside Re, i.e. a boost factor under about 1.12.\n");
+console.log("   galaxy          boost, a0 fixed   boost, a0(z)   over 1.12?");
+for (const d of GENZEL) {
+  const M = Mbar(d), r = d.Re * KPC;          // inside Re, where f_DM is quoted
+  const gN = G * M / (r * r);
+  const bFix = Math.sqrt(boosted(gN, A0_NOW) / gN);
+  const bMod = Math.sqrt(boosted(gN, aOf(d.z)) / gN);
+  console.log(`   ${d.name.padEnd(14)} ${bFix.toFixed(3).padStart(11)}    ` +
+    `${bMod.toFixed(3).padStart(12)}      ${bMod > 1.12 ? "YES — a problem" : "no"}`);
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. AND HOW MUCH a0 WOULD HAVE TO GROW BEFORE IT BREAKS");
+console.log("=".repeat(78));
+console.log("   the largest a0 that keeps every one of them inside f_DM < 0.2:\n");
+let worst = Infinity;
+for (const d of GENZEL) {
+  const M = Mbar(d), r = d.Re * KPC, gN = G * M / (r * r);
+  // solve boost = 1.12  =>  gN/2 + sqrt(gN²/4 + gN a) = 1.2544 gN
+  const a = gN * (Math.pow(1.2544 - 0.5, 2) - 0.25);
+  worst = Math.min(worst, a);
+  console.log(`   ${d.name.padEnd(14)} a0 < ${a.toExponential(2)}   ` +
+    `= ${(a / A0_NOW).toFixed(2)}× today's,  needs z < ${(a / A0_NOW - 1).toFixed(2)}`);
+}
+console.log();
+console.log(`   binding: a0 < ${worst.toExponential(2)} = ${(worst / A0_NOW).toFixed(2)}× today's`);
+console.log(`   and the model wants ${(aOf(2.2) / A0_NOW).toFixed(2)}× at z = 2.2.`);
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel2.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel2.ts
new file mode 100644
index 0000000..efbe61e
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel2.ts
@@ -0,0 +1,101 @@
+/**
+ * THE GENZEL TEST, DONE PROPERLY — and it overturns the earlier one.
+ *
+ * The first pass took g_N = G·M_bar/R_e², which is a POINT MASS. These are
+ * DISCS, and at one effective radius a disc has not enclosed all its mass, so
+ * its g_N there is smaller. A smaller g_N sits deeper in the boosted regime and
+ * gives a LARGER boost — so the point-mass shortcut was systematically generous
+ * to the model, in the direction that made it pass.
+ *
+ * Done with the same ring sum used everywhere else in this file.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const MPC = 3.0856775814913673e22;
+const A0 = C * (70.9e3 / MPC) / (2 * Math.PI);
+
+type Disc = { name: string; z: number; logMs: number; fgas: number; Re: number };
+const D: Disc[] = [
+  { name: "COS4_01351", z: 0.854, logMs: 11.07, fgas: 0.35, Re: 8.2 },
+  { name: "D3a_6397", z: 1.500, logMs: 11.07, fgas: 0.45, Re: 7.4 },
+  { name: "GS4_43501", z: 1.613, logMs: 10.71, fgas: 0.50, Re: 4.9 },
+  { name: "zC_406690", z: 2.196, logMs: 10.62, fgas: 0.55, Re: 5.5 },
+  { name: "zC_400569", z: 2.242, logMs: 11.07, fgas: 0.45, Re: 3.3 },
+];
+const Mbar = (d: Disc) => Math.pow(10, d.logMs) * MSUN / (1 - d.fgas);
+
+/** the disc's own pull, ring by ring — no shell theorem, no point-mass shortcut */
+const discG = (M: number, Rd: number, r: number, NR = 700, NP = 700) => {
+  const RMAX = 14 * Rd, h = Rd / 8;
+  let acc = 0;
+  for (let i = 0; i < NR; i++) {
+    const R = RMAX * (i + 0.5) / NR, dR = RMAX / NR;
+    const s = M / (2 * Math.PI * Rd * Rd) * Math.exp(-R / Rd) * R * dR;
+    let a = 0;
+    for (let j = 0; j < NP; j++) {
+      const p = 2 * Math.PI * (j + 0.5) / NP;
+      const dx = R * Math.cos(p) - r, dy = R * Math.sin(p);
+      a += dx / Math.pow(dx * dx + dy * dy + h * h, 1.5);
+    }
+    acc += -G * s * a * (2 * Math.PI / NP);
+  }
+  return acc;
+};
+
+const boosted = (gN: number, a0: number) => gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0);
+const CEIL = 1 / Math.sqrt(0.8);                 // f_DM < 0.2  ⇒  v/v_bar < 1.118
+
+console.log("=".repeat(78));
+console.log("THE TWO WAYS OF GETTING g_N AT Re, AND THEY DISAGREE");
+console.log("=".repeat(78));
+console.log(`   ceiling from f_DM < 0.2 : ${CEIL.toFixed(4)}\n`);
+console.log("   galaxy         g_N point   g_N disc    ratio   boost pt   boost disc");
+let failPt = 0, failDisc = 0;
+for (const d of D) {
+  const M = Mbar(d), Rd = d.Re * KPC / 1.68, r = d.Re * KPC;
+  const gPt = G * M / (r * r);
+  const gDisc = discG(M, Rd, r);
+  const bPt = Math.sqrt(boosted(gPt, A0) / gPt);
+  const bDisc = Math.sqrt(boosted(gDisc, A0) / gDisc);
+  if (bPt > CEIL) failPt++;
+  if (bDisc > CEIL) failDisc++;
+  console.log(`   ${d.name.padEnd(13)} ${gPt.toExponential(2)}  ${gDisc.toExponential(2)}   ` +
+    `${(gDisc / gPt).toFixed(3)}   ${bPt.toFixed(3)}${bPt > CEIL ? "*" : " "}     ` +
+    `${bDisc.toFixed(3)}${bDisc > CEIL ? "*" : " "}`);
+}
+console.log(`\n   * = over the ceiling.  point mass: ${failPt}/5 fail.  disc: ${failDisc}/5 fail.`);
+
+console.log();
+console.log("=".repeat(78));
+console.log("SO THE EARLIER PASS WAS AN ARTEFACT OF THE SHORTCUT");
+console.log("=".repeat(78));
+console.log("   A disc at one effective radius encloses about half its mass, so");
+console.log("   its g_N is roughly half the point-mass value. Halving g_N raises");
+console.log("   the boost, because the boost grows as g_N falls. The shortcut was");
+console.log("   generous in exactly the direction that mattered.");
+console.log();
+console.log("   WITH THE DISC DONE PROPERLY THE MODEL OVERSHOOTS FOUR OF THE FIVE.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("WHAT WOULD BE NEEDED TO CLEAR IT");
+console.log("=".repeat(78));
+console.log("   the largest a0 each disc permits, done properly:\n");
+let worstA = Infinity;
+for (const d of D) {
+  const M = Mbar(d), Rd = d.Re * KPC / 1.68, r = d.Re * KPC;
+  const gN = discG(M, Rd, r);
+  // boost = CEIL  ⇒  a0 = gN·((CEIL²−0.5)² − 0.25)
+  const a = gN * (Math.pow(CEIL * CEIL - 0.5, 2) - 0.25);
+  worstA = Math.min(worstA, a);
+  console.log(`   ${d.name.padEnd(13)} a0 < ${a.toExponential(2)}  = ${(a / A0).toFixed(3)}× the prediction`);
+}
+console.log(`\n   binding: a0 < ${worstA.toExponential(3)} = ${(worstA / A0).toFixed(3)}× predicted`);
+console.log(`   the anisotropy multiplies a0 by 0.765, giving ${(A0 * 0.7647).toExponential(3)}`);
+console.log(`   which is ${(A0 * 0.7647 / worstA).toFixed(2)}× the ceiling — still over.`);
+console.log();
+console.log("   So the anisotropy alone does not rescue it either. The model needs");
+console.log("   a0 about 2.5x SMALLER than cH0/2pi to clear these discs, and that");
+console.log("   is not a correction anything here offers.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/joint.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/joint.ts
new file mode 100644
index 0000000..56d487c
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/joint.ts
@@ -0,0 +1,59 @@
+const G=6.674e-11,MSUN=1.98847e30,KPC=3.0857e19,C=2.99792458e8;
+const A0P=C*(70.9e3/3.0857e22)/(2*Math.PI);      // the prediction
+const dirs:[number,number,number][]=[];
+for(let x=-1;x<=1;x++)for(let y=-1;y<=1;y++)for(let z=-1;z<=1;z++)if(x||y||z)dirs.push([x,y,z]);
+const proj=(cut:number)=>{let s=0,n=0;for(const v of dirs){const m=Math.hypot(v[0],v[1],v[2]),uz=v[2]/m;
+  if(uz>cut)continue;s+=Math.abs(uz);n++;}return s/n;};
+const P_ISO=proj(1.01);
+const NR=200,RMAX=70*KPC,NOUT=70,HZ=0.30*KPC;
+const Rj=Array.from({length:NR},(_,j)=>RMAX*(j+0.5)/NR),dR=RMAX/NR;
+const ri=Array.from({length:NOUT},(_,i)=>(i+1)*0.5*KPC);
+const kern=(()=>{const NP=280,K:Float64Array[]=[];
+ for(let i=0;i<NOUT;i++){const row=new Float64Array(NR),r=ri[i];
+  for(let j=0;j<NR;j++){const R=Rj[j];let a=0;
+   for(let q=0;q<NP;q++){const ph=2*Math.PI*(q+0.5)/NP;
+    const dx=R*Math.cos(ph)-r,dy=R*Math.sin(ph);a+=dx/Math.pow(dx*dx+dy*dy+HZ*HZ,1.5);}
+   row[j]=-a/NP;}K.push(row);}return K;})();
+const MW={Md:5.0e10*MSUN,Rd:2.6*KPC,Mg:1.2e10*MSUN,Rg:7.0*KPC,Mb:0.9e10*MSUN,ab:0.5*KPC};
+const sig=(R:number)=>MW.Md/(2*Math.PI*MW.Rd*MW.Rd)*Math.exp(-R/MW.Rd)+MW.Mg/(2*Math.PI*MW.Rg*MW.Rg)*Math.exp(-R/MW.Rg);
+const gNarr=(()=>{const m=new Float64Array(NR);
+ for(let j=0;j<NR;j++)m[j]=sig(Rj[j])*2*Math.PI*Rj[j]*dR;
+ const o=new Float64Array(NOUT);
+ for(let i=0;i<NOUT;i++){let a=0;const row=kern[i];for(let j=0;j<NR;j++)a+=row[j]*m[j];
+  o[i]=G*a+G*MW.Mb/Math.pow(ri[i]+MW.ab,2);}return o;})();
+const MEAS=(rk:number)=>229.0-1.7*(rk-8.122);
+const idx=(rk:number)=>Math.round(rk/0.5)-1;
+const solve=(gN:number,a0:number,aniso:boolean)=>{let g=gN+a0;
+  for(let k=0;k<400;k++){const th=g/a0;
+    const P=aniso?proj(1-2*Math.min(th/(1+th),0.5))/P_ISO:1;
+    g=0.5*g+0.5*(gN/2+Math.sqrt(gN*gN/4+gN*a0*P));}
+  return g;};
+const shape=(a0:number,an:boolean)=>{let s=0,n=0;
+  for(let rk=6;rk<=25;rk++){const g=solve(gNarr[idx(rk)],a0,an);
+    s+=Math.pow(Math.sqrt(g*ri[idx(rk)])/1e3/MEAS(rk)-1,2);n++;}
+  return 100*Math.sqrt(s/n);};
+type HZg={logMs:number;fgas:number;Re:number};
+const D:HZg[]=[{logMs:11.07,fgas:0.35,Re:8.2},{logMs:11.07,fgas:0.45,Re:7.4},
+ {logMs:10.71,fgas:0.50,Re:4.9},{logMs:10.62,fgas:0.55,Re:5.5},{logMs:11.07,fgas:0.45,Re:3.3}];
+const worstB=(a0:number,an:boolean)=>{let w=0;
+  for(const d of D){const gN=G*(Math.pow(10,d.logMs)*MSUN/(1-d.fgas))/Math.pow(d.Re*KPC,2);
+    w=Math.max(w,Math.sqrt(solve(gN,a0,an)/gN));}return w;};
+console.log("JOINT: Milky Way shape AND the Genzel ceiling of 1.12\n");
+console.log("  a0 (bare)      x cH0/2pi   iso: shape / worst    aniso: shape / worst");
+for(const f of [0.8,1.0,1.1,1.2,1.38,1.5,1.7]){
+  const a=A0P*f;
+  console.log(`  ${a.toExponential(3)}   ${f.toFixed(2).padStart(6)}      `+
+    `${shape(a,false).toFixed(1).padStart(4)}% / ${worstB(a,false).toFixed(3)}      `+
+    `${shape(a,true).toFixed(1).padStart(4)}% / ${worstB(a,true).toFixed(3)}`);
+}
+console.log("\n  and the joint best with the anisotropy on:");
+let best=1e9,bf=0;
+for(let f=0.8;f<=2.2;f+=0.01){const a=A0P*f;
+  const sh=shape(a,true), w=worstB(a,true);
+  if(w>=1.12) continue;
+  if(sh<best){best=sh;bf=f;}}
+console.log(`    a0 = ${(A0P*bf).toExponential(3)} = ${bf.toFixed(2)} x cH0/2pi`);
+console.log(`    MW shape ${best.toFixed(1)}%, Genzel worst ${worstB(A0P*bf,true).toFixed(3)} (< 1.12)`);
+console.log(`    effective a0 = ${(A0P*bf*0.7647).toExponential(3)} vs measured 1.200e-10`);
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/perm.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/perm.ts
new file mode 100644
index 0000000..5bc8f43
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/perm.ts
@@ -0,0 +1,229 @@
+/**
+ * THE PERMUTATION SEARCH, on a fully relaxed galaxy.
+ *
+ * Part 2 established something that reframes the whole thing: A FEEDBACK THAT
+ * WEAKENS THE SOURCE CAN ONLY LOWER A ROTATION CURVE. It cannot supply missing
+ * gravity at any coupling, for any driver. So the feedback is not the dark
+ * matter — it can only be the thing that fixes HOW an excess scales with mass,
+ * and something else has to supply the excess.
+ *
+ * Which means the honest object to test is the PAIR: the caught pair's 1/R
+ * channel supplying the excess, and the feedback setting its mass scaling. Two
+ * requirements, and they must be met at once:
+ *
+ *     SHAPE   one galaxy's rotation curve, against Gaia
+ *     SCALING the Tully–Fisher slope across five decades of galaxy mass
+ *
+ * Everything is permuted: which driver, which channel the feedback acts on,
+ * whether the driver is read locally or averaged over the body. One coupling is
+ * fitted per permutation (at the Sun) and nothing else.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const A0 = 1.2e-10;
+
+const NR = 220, RMAX = 70 * KPC;
+const Rj = Array.from({ length: NR }, (_, j) => RMAX * (j + 0.5) / NR);
+const dR = RMAX / NR;
+const NOUT = 70;                                   // out to 35 kpc
+const ri = Array.from({ length: NOUT }, (_, i) => (i + 1) * 0.5 * KPC);
+const H = 0.30 * KPC;
+
+const kernel = (p: number) => {
+  const NP = 300;
+  const K: Float64Array[] = [];
+  for (let i = 0; i < NOUT; i++) {
+    const row = new Float64Array(NR), r = ri[i];
+    for (let j = 0; j < NR; j++) {
+      const R = Rj[j]; let acc = 0;
+      for (let q = 0; q < NP; q++) {
+        const ph = 2 * Math.PI * (q + 0.5) / NP;
+        const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+        const d2 = dx * dx + dy * dy + H * H;
+        acc += dx / Math.pow(d2, (p + 1) / 2);
+      }
+      row[j] = -acc / NP;
+    }
+    K.push(row);
+  }
+  return K;
+};
+console.log("precomputing kernels…");
+const K2 = kernel(2), K1 = kernel(1);
+console.log("done.\n");
+
+type Galaxy = { Md: number; Rd: number; Mg: number; Rg: number; Mb: number; ab: number };
+const MW: Galaxy = {
+  Md: 5.0e10 * MSUN, Rd: 2.6 * KPC, Mg: 1.2e10 * MSUN, Rg: 7.0 * KPC,
+  Mb: 0.9e10 * MSUN, ab: 0.5 * KPC,
+};
+
+/** a family of galaxies: mass scaled, size following the observed R ∝ M^0.35 */
+const scaled = (f: number): Galaxy => ({
+  Md: MW.Md * f, Rd: MW.Rd * Math.pow(f, 0.35),
+  Mg: MW.Mg * f, Rg: MW.Rg * Math.pow(f, 0.35),
+  Mb: MW.Mb * f, ab: MW.ab * Math.pow(f, 0.35),
+});
+
+const ringMass = (g: Galaxy) => {
+  const m = new Float64Array(NR);
+  for (let j = 0; j < NR; j++) {
+    const R = Rj[j];
+    m[j] = (g.Md / (2 * Math.PI * g.Rd * g.Rd) * Math.exp(-R / g.Rd)
+      + g.Mg / (2 * Math.PI * g.Rg * g.Rg) * Math.exp(-R / g.Rg)) * 2 * Math.PI * R * dR;
+  }
+  return m;
+};
+
+type Setup = {
+  driverName: string;
+  driver: (g: number, u: number, v: number) => number;
+  kappa: number;
+  feedbackOn: "newton" | "caught" | "both";
+  local: boolean;
+  lambda: number;                                  // the caught-pair coupling
+};
+
+const solve = (gal: Galaxy, s: Setup, iters = 160) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let gT = new Float64Array(NOUT);
+
+  let wb = 1;                                        // the bulge is a source too
+  for (let it = 0; it < iters; it++) {
+    const gN = new Float64Array(NOUT), gC = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) {
+        a2 += r2[j] * m0[j] * (s.feedbackOn !== "caught" ? w[j] : 1);
+        a1 += r1[j] * m0[j] * (s.feedbackOn !== "newton" ? w[j] : 1);
+      }
+      gN[i] = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      gC[i] = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+    }
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) gTot[i] = gN[i] + s.lambda * gC[i];
+
+    const u = new Float64Array(NOUT); let acc = 0;
+    for (let i = NOUT - 1; i >= 0; i--) {
+      acc += gTot[i] * (i === NOUT - 1 ? 0.5 * KPC : ri[i + 1] - ri[i]);
+      u[i] = acc / (C * C);
+    }
+    const D = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++)
+      D[i] = s.driver(gTot[i], u[i], Math.sqrt(Math.max(0, gTot[i] * ri[i])) / C);
+
+    let Dbar = 0, ws = 0;
+    const onRing = new Float64Array(NR);
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      onRing[j] = D[k] * (1 - f) + D[k + 1] * f;
+      Dbar += onRing[j] * m0[j]; ws += m0[j];
+    }
+    Dbar /= ws;
+    for (let j = 0; j < NR; j++)
+      w[j] = 0.75 * w[j] + 0.25 / (1 + s.kappa * (s.local ? onRing[j] : Dbar));
+    // the bulge is made of emitters like everything else, so it is weakened
+    // too — leaving it out let it dominate at large kappa and dragged the
+    // whole scaling back to Newton's.
+    const Db = s.local ? D[0] : Dbar;
+    wb = 0.75 * wb + 0.25 / (1 + s.kappa * Db);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const MEAS = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+const idx = (rk: number) => Math.round(rk / 0.5) - 1;
+
+/** fit lambda so the Sun's speed is right, then score shape and BTFR slope */
+const score = (s: Omit<Setup, "lambda">) => {
+  let lo = 0, hi = 1e-24;
+  const at8 = (lam: number) => {
+    const g = solve(MW, { ...s, lambda: lam });
+    return kms(g[idx(8)], ri[idx(8)]);
+  };
+  while (at8(hi) < MEAS(8.122) && hi < 1e10) hi *= 4;
+  for (let i = 0; i < 34; i++) {
+    const mid = (lo + hi) / 2;
+    if (at8(mid) < MEAS(8.122)) lo = mid; else hi = mid;
+  }
+  const lambda = (lo + hi) / 2;
+
+  const g = solve(MW, { ...s, lambda });
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) {
+    ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++;
+  }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  // BTFR: flat speed vs baryonic mass across five decades
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f);
+    const gg = solve(gal, { ...s, lambda });
+    // "flat" speed: measured at 4 disc scale lengths, the usual convention
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    const M = (gal.Md + gal.Mg + gal.Mb) / MSUN;
+    pts.push([Math.log10(M), Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  const btfr = (nn * sxy - sx * sy) / (nn * sxx - sx * sx);   // d log M / d log v
+
+  return { lambda, shape, btfr };
+};
+
+console.log("=".repeat(80));
+console.log("THE PERMUTATIONS — shape against Gaia, and the Tully–Fisher slope");
+console.log("=".repeat(80));
+console.log("  target:  shape rms  < ~5%      BTFR slope  3.85 ± 0.09");
+console.log("  Newton alone gives shape 32.5% and slope 2.0, for reference.\n");
+
+const drivers: [string, (g: number, u: number, v: number) => number, string][] = [
+  ["none (no feedback)", () => 0, "—"],
+  ["potential u", (_g, u) => u, "M"],
+  ["acceleration |g|", g => g, "M"],
+  ["speed v/c", (_g, _u, v) => v, "√M"],
+  ["a₀/g — inverse accel", g => A0 / Math.max(g, 1e-30), "1/M"],
+  ["√(a₀/g)", g => Math.sqrt(A0 / Math.max(g, 1e-30)), "1/√M"],
+];
+
+console.log("  driver          scales  on       read     κ        shape    BTFR");
+console.log("  " + "-".repeat(72));
+{
+  const r = score({ driverName: "none", driver: () => 0, kappa: 0,
+    feedbackOn: "caught", local: true });
+  console.log(`  ${"none".padEnd(16)}${"—".padEnd(7)} ${"caught".padEnd(8)} ` +
+    `${"local".padEnd(8)} ${"0".padEnd(8)} ${r.shape.toFixed(1).padStart(6)}%  ` +
+    `${r.btfr.toFixed(2).padStart(6)}   <- caught pair alone`);
+}
+const best: any[] = [];
+for (const [name, fn, sc] of drivers.slice(1)) {
+  for (const on of ["caught", "newton"] as const) {
+    for (const local of [true, false]) {
+      for (const kappa of [1e5, 1e6, 1e7, 1e8, 1e9, 1e11, 1e13]) {
+        const r = score({ driverName: name, driver: fn, kappa, feedbackOn: on, local });
+        if (!isFinite(r.shape) || !isFinite(r.btfr)) continue;
+        const good = r.shape < 8 && Math.abs(r.btfr - 3.85) < 0.35;
+        if (good) best.push([name, sc, on, local, kappa, r]);
+        if (good || kappa === 1e7)
+          console.log(`  ${name.padEnd(16)}${sc.padEnd(7)} ${on.padEnd(8)} ` +
+            `${(local ? "local" : "global").padEnd(8)} ${kappa.toExponential(0).padEnd(8)} ` +
+            `${r.shape.toFixed(1).padStart(6)}%  ${r.btfr.toFixed(2).padStart(6)}${good ? "   <<< PASSES" : ""}`);
+      }
+    }
+  }
+}
+console.log();
+console.log(best.length ? `  ${best.length} permutation(s) meet both targets.`
+  : "  NO permutation meets both targets.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pol2.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pol2.ts
new file mode 100644
index 0000000..7a42637
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pol2.ts
@@ -0,0 +1,53 @@
+/** the net imbalance is a random variable — so measure its RMS over an ensemble */
+const L=48,C=L/2,R_OUT=20,R_MEAS=16;
+const cellOf=(x:number,y:number,z:number)=>((x|0)*256+(y|0))*256+(z|0);
+const one=(N:number,Rb:number,seed0:number,ticks=60,warm=34)=>{
+  let seed=seed0; const rnd=()=>(seed=(seed*1103515245+12345)&0x7fffffff)/0x7fffffff;
+  const ex:number[]=[],ey:number[]=[],ez:number[]=[];
+  for(let i=0;i<N;i++){let x,y,z;do{x=rnd()*2-1;y=rnd()*2-1;z=rnd()*2-1;}while(x*x+y*y+z*z>1);
+    ex.push(C+x*Rb);ey.push(C+y*Rb);ez.push(C+z*Rb);}
+  let px:number[]=[],py:number[]=[],pz:number[]=[],vx:number[]=[],vy:number[]=[],vz:number[]=[],q:number[]=[];
+  const dir=()=>{const u=rnd()*2-1,a=rnd()*2*Math.PI,s=Math.sqrt(1-u*u);return [s*Math.cos(a),s*Math.sin(a),u];};
+  let total=0,net=0,counted=0;
+  for(let t=0;t<ticks;t++){
+    for(let i=0;i<N;i++){const f=rnd()<0.5?1:-1;
+      for(const s of [f,-f]){const [dx,dy,dz]=dir();
+        px.push(ex[i]);py.push(ey[i]);pz.push(ez[i]);vx.push(dx);vy.push(dy);vz.push(dz);q.push(s);}}
+    for(let i=0;i<q.length;i++){px[i]+=vx[i];py[i]+=vy[i];pz[i]+=vz[i];}
+    const b=new Map<number,number[]>();
+    for(let i=0;i<q.length;i++){
+      const dx=px[i]-C,dy=py[i]-C,dz=pz[i]-C,r2=dx*dx+dy*dy+dz*dz;
+      const w=(px[i]-vx[i]-C)**2+(py[i]-vy[i]-C)**2+(pz[i]-vz[i]-C)**2;
+      if(w<R_MEAS*R_MEAS&&r2>=R_MEAS*R_MEAS&&t>=warm){total++;net+=q[i];}
+      const k=cellOf(px[i],py[i],pz[i]); const g=b.get(k); if(g)g.push(i);else b.set(k,[i]);}
+    const dead=new Uint8Array(q.length);
+    for(const ids of b.values()){if(ids.length<2)continue;
+      const p=ids.filter(i=>q[i]>0),m=ids.filter(i=>q[i]<0),n=Math.min(p.length,m.length);
+      for(let j=0;j<n;j++){dead[p[j]]=1;dead[m[j]]=1;}}
+    const nx:number[]=[],ny:number[]=[],nz:number[]=[],ux:number[]=[],uy:number[]=[],uz:number[]=[],nq:number[]=[];
+    for(let i=0;i<q.length;i++){if(dead[i])continue;
+      const dx=px[i]-C,dy=py[i]-C,dz=pz[i]-C; if(dx*dx+dy*dy+dz*dz>R_OUT*R_OUT)continue;
+      nx.push(px[i]);ny.push(py[i]);nz.push(pz[i]);ux.push(vx[i]);uy.push(vy[i]);uz.push(vz[i]);nq.push(q[i]);}
+    px=nx;py=ny;pz=nz;vx=ux;vy=uy;vz=uz;q=nq; if(t>=warm)counted++;}
+  return {total:total/counted,net:net/counted};
+};
+const ens=(N:number,Rb:number,reps=40)=>{
+  let st=0,sn2=0;
+  for(let k=0;k<reps;k++){const r=one(N,Rb,1000+k*7717+N*31);st+=r.total;sn2+=r.net*r.net;}
+  return {total:st/reps,rms:Math.sqrt(sn2/reps)};
+};
+console.log("ENSEMBLE OF 40, so the imbalance is an RMS and not one draw\n");
+console.log("      N      total   slope    rms(net)  slope    rms/sqrt(total)");
+let prev:any=null;
+for(const N of [16,64,256,1024]){
+  const r=ens(N,5);
+  const st=prev?Math.log(r.total/prev.total)/Math.log(N/prev.N):NaN;
+  const sn=prev?Math.log(r.rms/prev.rms)/Math.log(N/prev.N):NaN;
+  console.log(`  ${String(N).padStart(6)}  ${r.total.toFixed(1).padStart(7)}  ${isNaN(st)?"  —  ":st.toFixed(3)}   `+
+    `${r.rms.toFixed(2).padStart(7)}  ${isNaN(sn)?"  —  ":sn.toFixed(3)}    ${(r.rms/Math.sqrt(r.total)).toFixed(3)}`);
+  prev={...r,N};
+}
+console.log("\n  rms(net)/sqrt(total) constant  =>  the imbalance is exactly the");
+console.log("  fair-coin fluctuation on the arrivals, with no coherence in it.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/polarity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/polarity.ts
new file mode 100644
index 0000000..8ea57e5
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/polarity.ts
@@ -0,0 +1,121 @@
+/**
+ * POLARITY IS 50/50 AND RANDOM — so what does the √N actually need?
+ *
+ * Test A got √N from PHASE cancellation, which needs `m·R ≫ 2π` and therefore
+ * an emitter mass, and therefore the 29 MeV bill. But the model never assigns a
+ * wave a definite polarity: a neutral point becomes a ± pair and which half
+ * goes which way is not decided by anything. So the ± attribution is a fair
+ * coin, and a fair coin gives √N ALL BY ITSELF, at every scale, with no
+ * coherence condition anywhere.
+ *
+ * If that is right it removes the crossover-from-Compton-wavelength entirely —
+ * which is what Test I already found from the other direction.
+ *
+ * Measured here rather than argued: emitters put out ± pairs with random
+ * attribution, charges stream, opposite charges meeting in a cell annihilate,
+ * and at a distant sphere we count BOTH the total arrivals and the NET
+ * imbalance, and see how each scales with N.
+ */
+
+const L = 72, C = L / 2, R_OUT = 32, R_MEAS = 26;
+const cellOf = (x: number, y: number, z: number) =>
+  ((x | 0) * 256 + (y | 0)) * 256 + (z | 0);
+
+const run = (N: number, Rb: number, ticks = 120, warm = 70) => {
+  let seed = 90210 + N * 7919 + Rb * 104729;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+
+  const ex: number[] = [], ey: number[] = [], ez: number[] = [];
+  for (let i = 0; i < N; i++) {
+    let x, y, z;
+    do { x = rnd() * 2 - 1; y = rnd() * 2 - 1; z = rnd() * 2 - 1; }
+    while (x * x + y * y + z * z > 1);
+    ex.push(C + x * Rb); ey.push(C + y * Rb); ez.push(C + z * Rb);
+  }
+
+  let px: number[] = [], py: number[] = [], pz: number[] = [];
+  let vx: number[] = [], vy: number[] = [], vz: number[] = [], q: number[] = [];
+  const dir = () => {
+    const u = rnd() * 2 - 1, a = rnd() * 2 * Math.PI, s = Math.sqrt(1 - u * u);
+    return [s * Math.cos(a), s * Math.sin(a), u];
+  };
+
+  let total = 0, net = 0, counted = 0;
+
+  for (let t = 0; t < ticks; t++) {
+    // a neutral point becomes a ± pair; WHICH HALF GOES WHICH WAY IS A COIN
+    for (let i = 0; i < N; i++) {
+      const flip = rnd() < 0.5 ? 1 : -1;
+      for (const s of [flip, -flip]) {
+        const [dx, dy, dz] = dir();
+        px.push(ex[i]); py.push(ey[i]); pz.push(ez[i]);
+        vx.push(dx); vy.push(dy); vz.push(dz); q.push(s);
+      }
+    }
+    for (let i = 0; i < q.length; i++) { px[i] += vx[i]; py[i] += vy[i]; pz[i] += vz[i]; }
+
+    const bucket = new Map<number, number[]>();
+    for (let i = 0; i < q.length; i++) {
+      const dx = px[i] - C, dy = py[i] - C, dz = pz[i] - C;
+      const r2 = dx * dx + dy * dy + dz * dz;
+      const w = (px[i] - vx[i] - C) ** 2 + (py[i] - vy[i] - C) ** 2 + (pz[i] - vz[i] - C) ** 2;
+      if (w < R_MEAS * R_MEAS && r2 >= R_MEAS * R_MEAS && t >= warm) {
+        total++; net += q[i];
+      }
+      const k = cellOf(px[i], py[i], pz[i]);
+      const b = bucket.get(k); if (b) b.push(i); else bucket.set(k, [i]);
+    }
+    const dead = new Uint8Array(q.length);
+    for (const ids of bucket.values()) {
+      if (ids.length < 2) continue;
+      const p = ids.filter(i => q[i] > 0), m = ids.filter(i => q[i] < 0);
+      const n = Math.min(p.length, m.length);
+      for (let j = 0; j < n; j++) { dead[p[j]] = 1; dead[m[j]] = 1; }
+    }
+    const nx: number[] = [], ny: number[] = [], nz: number[] = [], ux: number[] = [],
+      uy: number[] = [], uz: number[] = [], nq: number[] = [];
+    for (let i = 0; i < q.length; i++) {
+      if (dead[i]) continue;
+      const dx = px[i] - C, dy = py[i] - C, dz = pz[i] - C;
+      if (dx * dx + dy * dy + dz * dz > R_OUT * R_OUT) continue;
+      nx.push(px[i]); ny.push(py[i]); nz.push(pz[i]);
+      ux.push(vx[i]); uy.push(vy[i]); uz.push(vz[i]); nq.push(q[i]);
+    }
+    px = nx; py = ny; pz = nz; vx = ux; vy = uy; vz = uz; q = nq;
+    if (t >= warm) counted++;
+  }
+  return { N, total: total / counted, net: Math.abs(net) / counted, counted };
+};
+
+console.log("=".repeat(74));
+console.log("THE TWO THINGS A DISTANT BODY COULD COUNT");
+console.log("=".repeat(74));
+console.log("  total    every arrival, sign ignored      — expect ∝ N");
+console.log("  net      the ± imbalance                  — expect ∝ √N if the");
+console.log("           attribution is a fair coin\n");
+console.log("      N       total    slope     |net|    slope     net/√N");
+const rows: any[] = [];
+for (const N of [8, 32, 128, 512, 2048]) {
+  const r = run(N, 5);
+  rows.push(r);
+  const i = rows.length - 1;
+  const st = i === 0 ? NaN : Math.log(r.total / rows[i - 1].total) / Math.log(r.N / rows[i - 1].N);
+  const sn = i === 0 ? NaN : Math.log(r.net / rows[i - 1].net) / Math.log(r.N / rows[i - 1].N);
+  console.log(`  ${String(N).padStart(6)}   ${r.total.toFixed(1).padStart(8)}   ` +
+    `${isNaN(st) ? "  —  " : st.toFixed(3)}   ${r.net.toFixed(2).padStart(7)}   ` +
+    `${isNaN(sn) ? "  —  " : sn.toFixed(3)}   ${(r.net / Math.sqrt(r.N)).toFixed(3)}`);
+}
+
+console.log();
+console.log("=".repeat(74));
+console.log("AND WHETHER IT DEPENDS ON THE BODY'S SIZE — i.e. on any m·R");
+console.log("=".repeat(74));
+console.log("  Test A's √N switched on at m·R ≈ 2π, so it CARED about the size.");
+console.log("  A coin does not. Same N, different radii:\n");
+console.log("      Rb      net/√N");
+for (const Rb of [2, 5, 10, 16]) {
+  const r = run(512, Rb);
+  console.log(`  ${String(Rb).padStart(6)}   ${(r.net / Math.sqrt(r.N)).toFixed(3)}`);
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/quant.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/quant.ts
new file mode 100644
index 0000000..9111dbc
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/quant.ts
@@ -0,0 +1,25 @@
+const d:[number,number,number][]=[];
+for(let x=-1;x<=1;x++)for(let y=-1;y<=1;y++)for(let z=-1;z<=1;z++)if(x||y||z)d.push([x,y,z]);
+const cos=new Set<string>();
+for(const v of d){const m=Math.hypot(v[0],v[1],v[2]); cos.add((v[2]/m).toFixed(6));}
+console.log("the 26 exits have only these direction cosines along any axis:");
+console.log("  ", [...cos].map(Number).sort((a,b)=>b-a).join("  "));
+console.log();
+console.log("  1        = 1/1     the 6 faces");
+console.log("  0.707107 = 1/√2    the 12 edges");
+console.log("  0.577350 = 1/√3    the 8 corners");
+console.log();
+console.log("So a cone cut anywhere in (0, 0.577) shuts EXACTLY the same set.");
+console.log("The projection factor is a STEP function of the cut, not a smooth");
+console.log("one, and a galaxy's occupancy never crosses a step:");
+const proj=(cut:number)=>{let s=0,n=0;
+  for(const v of d){const m=Math.hypot(v[0],v[1],v[2]),uz=v[2]/m;
+    if(uz>cut)continue;s+=Math.abs(uz);n++;} return s/n;};
+console.log();
+console.log("     cut      open   ⟨|cos|⟩   P/P_iso");
+for(const c of [1.01,0.99,0.8,0.6,0.5,0.3,0.0,-0.5]){
+  console.log(`  ${c.toFixed(2).padStart(7)}   ${String(d.filter(v=>{const m=Math.hypot(v[0],v[1],v[2]);return v[2]/m<=c;}).length).padStart(4)}   `+
+    `${proj(c).toFixed(4)}   ${(proj(c)/proj(1.01)).toFixed(4)}`);
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/recon.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/recon.ts
new file mode 100644
index 0000000..1b7dd6a
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/recon.ts
@@ -0,0 +1,27 @@
+/** two derivations of a0 in one file — how far apart, and is the gap countable? */
+const G_LAT=0.06235150, SHEET=8;
+const LP=1.616255e-35, TP=5.391247e-44, C=2.99792458e8;
+const H0=70.9e3/3.0856775814913673e22, T0=1/H0;
+const t0ticks=T0/TP;
+const toSI=LP/(TP*TP);                              // cells/tick^2 -> m/s^2
+
+const a_meet = 4*Math.PI*G_LAT/(SHEET*t0ticks)*toSI;   // counting meetings
+const a_exp  = C*H0/(2*Math.PI);                        // the expansion
+console.log("  from counting meetings   a0 = 4πG/(SHEET·t0) =", a_meet.toExponential(3));
+console.log("  from the expansion       a0 = c·H0/2π        =", a_exp.toExponential(3));
+console.log("  measured                                      = 1.200e-10");
+console.log();
+console.log("  meetings / measured  =", (a_meet/1.2e-10).toFixed(4), " -> short by", (1.2e-10/a_meet).toFixed(3));
+console.log("  expansion / measured =", (a_exp/1.2e-10).toFixed(4), " -> short by", (1.2e-10/a_exp).toFixed(3));
+console.log();
+const ratio = a_exp/a_meet;
+console.log("  and the two differ by exactly", ratio.toFixed(4));
+console.log("  which is 1 / (8π²·G_LATTICE/SHEET) =", (1/(8*Math.PI*Math.PI*G_LAT/SHEET)).toFixed(4));
+console.log();
+console.log("  8π²·G_LATTICE/SHEET =", (8*Math.PI*Math.PI*G_LAT/SHEET).toFixed(6));
+console.log();
+console.log("  So they are not two guesses — they are the SAME quantity differing");
+console.log("  by a pure lattice count. Whichever is right, the other is wrong by");
+console.log("  a factor made of G_LATTICE, SHEET and π, and nothing else.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/redo.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/redo.ts
new file mode 100644
index 0000000..0ae9486
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/redo.ts
@@ -0,0 +1,52 @@
+/** Genzel and the Milky Way, redone with the blocking-DERIVED interpolation */
+const G=6.674e-11,MSUN=1.98847e30,KPC=3.0857e19,C=2.99792458e8;
+const H0=70.9e3/3.0857e22, A0C=C*H0/(2*Math.PI);
+const NR=200,RMAX=70*KPC,NOUT=70,HZ=0.30*KPC;
+const Rj=Array.from({length:NR},(_,j)=>RMAX*(j+0.5)/NR), dR=RMAX/NR;
+const ri=Array.from({length:NOUT},(_,i)=>(i+1)*0.5*KPC);
+const kern=(()=>{const NP=280,K:Float64Array[]=[];
+ for(let i=0;i<NOUT;i++){const row=new Float64Array(NR),r=ri[i];
+  for(let j=0;j<NR;j++){const R=Rj[j];let a=0;
+   for(let q=0;q<NP;q++){const ph=2*Math.PI*(q+0.5)/NP;
+    const dx=R*Math.cos(ph)-r,dy=R*Math.sin(ph);a+=dx/Math.pow(dx*dx+dy*dy+HZ*HZ,1.5);}
+   row[j]=-a/NP;} K.push(row);} return K;})();
+const MW={Md:5.0e10*MSUN,Rd:2.6*KPC,Mg:1.2e10*MSUN,Rg:7.0*KPC,Mb:0.9e10*MSUN,ab:0.5*KPC};
+const sig=(R:number)=>MW.Md/(2*Math.PI*MW.Rd*MW.Rd)*Math.exp(-R/MW.Rd)
+  +MW.Mg/(2*Math.PI*MW.Rg*MW.Rg)*Math.exp(-R/MW.Rg);
+const gN=(()=>{const m=new Float64Array(NR);
+ for(let j=0;j<NR;j++)m[j]=sig(Rj[j])*2*Math.PI*Rj[j]*dR;
+ const o=new Float64Array(NOUT);
+ for(let i=0;i<NOUT;i++){let a=0;const row=kern[i];
+  for(let j=0;j<NR;j++)a+=row[j]*m[j];
+  o[i]=G*a+G*MW.Mb/Math.pow(ri[i]+MW.ab,2);} return o;})();
+/** DERIVED from blocking: free fraction 1/(1+g/a0) => enhancement 1+a0/g */
+const derived=(g:number,a0:number)=>g/2+Math.sqrt(g*g/4+g*a0);
+const MEAS=(rk:number)=>229.0-1.7*(rk-8.122);
+const kms=(g:number,r:number)=>Math.sqrt(Math.max(0,g*r))/1e3;
+const idx=(rk:number)=>Math.round(rk/0.5)-1;
+const shape=(a0:number)=>{let s=0,n=0;
+ for(let rk=6;rk<=25;rk++){s+=Math.pow(kms(derived(gN[idx(rk)],a0),ri[idx(rk)])/MEAS(rk)-1,2);n++;}
+ return 100*Math.sqrt(s/n);};
+type HZg={name:string;z:number;logMs:number;fgas:number;Re:number};
+const D:HZg[]=[{name:"COS4_01351",z:0.854,logMs:11.07,fgas:0.35,Re:8.2},
+ {name:"D3a_6397",z:1.500,logMs:11.07,fgas:0.45,Re:7.4},
+ {name:"GS4_43501",z:1.613,logMs:10.71,fgas:0.50,Re:4.9},
+ {name:"zC_406690",z:2.196,logMs:10.62,fgas:0.55,Re:5.5},
+ {name:"zC_400569",z:2.242,logMs:11.07,fgas:0.45,Re:3.3}];
+const gHZ=(d:HZg)=>G*(Math.pow(10,d.logMs)*MSUN/(1-d.fgas))/Math.pow(d.Re*KPC,2);
+console.log("THE GENZEL TEST, REDONE — a0 now a LOCAL blocking threshold, so it");
+console.log("does not move with redshift and no cosmological cancellation is");
+console.log("needed. Allowed by f_DM < 0.2 is a boost under 1.12.\n");
+console.log("   a0 reading                     value      MW shape   worst boost  all pass?");
+for(const [nm,a0] of [["cH0/2pi, isotropic",A0C],
+  ["  with cone shut cos>0.9",A0C*0.9553],
+  ["  with cone shut cos>0.5",A0C*0.7647],
+  ["the measured a0",1.2e-10]] as [string,number][]){
+  let worst=0; const rows:string[]=[];
+  for(const d of D){const b=Math.sqrt(derived(gHZ(d),a0)/gHZ(d)); worst=Math.max(worst,b); rows.push(b.toFixed(3));}
+  console.log(`   ${nm.padEnd(28)} ${a0.toExponential(2)}   ${shape(a0).toFixed(1).padStart(5)}%   `+
+    `${worst.toFixed(3).padStart(9)}     ${worst<1.12?"YES":"no"}`);
+  console.log(`     per galaxy: ${rows.join("  ")}`);
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/residual.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/residual.ts
new file mode 100644
index 0000000..e52d044
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/residual.ts
@@ -0,0 +1,112 @@
+/**
+ * IF THE TRANSPORT ACCOUNTS FOR ROTATION CURVES, WHAT IS LEFT FOR DARK MATTER?
+ *
+ * The inference is sound and it is not a new one — it is roughly the position
+ * Angus and Sanders took with MOND plus sterile neutrinos. If a mechanism
+ * supplies the galactic phenomenology, then whatever dark matter exists only has
+ * to cover the RESIDUAL, and the residual is much smaller than ΛCDM's.
+ *
+ * So: how much smaller, and does the leftover have to be a strange kind of thing
+ * to avoid ruining the galaxies it is no longer needed for?
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, MPC = 3.0856775814913673e22;
+const C = 2.99792458e8, KPC = 3.0857e19, KB = 1.380649e-23, HBAR = 1.054572e-34;
+const A0 = C * (70.9e3 / MPC) / (2 * Math.PI);
+const boosted = (gN: number, a0: number) => gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0);
+
+console.log("=".repeat(78));
+console.log("1. HOW MUCH DARK MATTER IS LEFT TO EXPLAIN");
+console.log("=".repeat(78));
+const CL = [
+  { name: "Coma", Mbar: 2.0e14, Mdyn: 1.2e15, R: 1.4 },
+  { name: "A1689", Mbar: 1.9e14, Mdyn: 1.3e15, R: 1.5 },
+  { name: "A2029", Mbar: 1.5e14, Mdyn: 8.0e14, R: 1.3 },
+  { name: "Perseus", Mbar: 1.1e14, Mdyn: 6.5e14, R: 1.2 },
+  { name: "Virgo", Mbar: 2.0e13, Mdyn: 1.2e14, R: 0.8 },
+];
+console.log("   cluster    ΛCDM needs   this model supplies   RESIDUAL still needed");
+let sres = 0;
+for (const c of CL) {
+  const R = c.R * MPC, gN = G * c.Mbar * MSUN / (R * R);
+  const got = boosted(gN, A0) / gN, need = c.Mdyn / c.Mbar;
+  const res = need / got;
+  sres += res;
+  console.log(`   ${c.name.padEnd(9)}  ${need.toFixed(1).padStart(6)}× baryons   ` +
+    `${got.toFixed(2).padStart(10)}×          ${res.toFixed(2)}× baryons`);
+}
+const RES = sres / CL.length;
+console.log(`\n   mean residual = ${RES.toFixed(2)}× the baryons, against ΛCDM's 5.3×`);
+console.log(`   SO THE DARK-MATTER REQUIREMENT DROPS BY ${(5.3 / (RES - 1)).toFixed(0)}×`);
+console.log(`   (the residual is ${(RES - 1).toFixed(2)}× in EXTRA mass, not ${RES.toFixed(2)}×)`);
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. BUT IT MUST NOT BE IN GALAXIES — and that is the hard part");
+console.log("=".repeat(78));
+console.log("   The Milky Way is fitted to 1.1% by the transport alone. Add the");
+console.log("   same 0.54× of extra mass there and the fit is destroyed:\n");
+const MW_M = 6.2e10 * MSUN;
+console.log("      r kpc   transport only   + 0.54× extra   Gaia");
+for (const rk of [8, 15, 20, 30]) {
+  const r = rk * KPC;
+  const gN = G * MW_M / (r * r);
+  const v0 = Math.sqrt(boosted(gN, A0) * r) / 1e3;
+  const v1 = Math.sqrt(boosted(gN * (1 + (RES - 1)), A0) * r) / 1e3;
+  const meas = 229.0 - 1.7 * (rk - 8.122);
+  console.log(`   ${String(rk).padStart(8)}   ${v0.toFixed(0).padStart(12)}   ` +
+    `${v1.toFixed(0).padStart(13)}   ${meas.toFixed(0)}`);
+}
+console.log("\n   So the leftover has to CLUSTER IN CLUSTERS AND NOT IN GALAXIES.");
+console.log("   That is not a free choice — it is a phase-space statement, and it");
+console.log("   fixes the particle's mass from both sides.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. WHAT THE PHASE SPACE ALLOWS — the Tremaine–Gunn bound");
+console.log("=".repeat(78));
+console.log("   A fermion cannot pack denser than its own exclusion principle");
+console.log("   permits, so a given ρ and σ demands a minimum mass:");
+console.log("      m⁴ ≳ 9 ħ³ / (4 √2 π G σ r²)  — roughly, for an isothermal core\n");
+const tg = (sigma: number, r: number) => {
+  const m4 = 9 * Math.pow(HBAR, 3) / (4 * Math.sqrt(2) * Math.PI * G * sigma * r * r);
+  return Math.pow(m4, 0.25);
+};
+console.log("      system      σ (km/s)   r        min mass (eV)");
+for (const [nm, sig, r] of [
+  ["a cluster", 1000e3, 1.4 * MPC],
+  ["the Milky Way", 200e3, 30 * KPC],
+  ["a dwarf", 10e3, 1 * KPC],
+] as [string, number, number][]) {
+  const m = tg(sig, r);
+  console.log(`      ${nm.padEnd(13)} ${(sig / 1e3).toFixed(0).padStart(6)}   ` +
+    `${(r / KPC).toFixed(0).padStart(6)} kpc   ${(m * C * C / 1.602177e-19).toExponential(2)}`);
+}
+console.log();
+console.log("   To sit in clusters it must be heavier than the cluster bound; to");
+console.log("   STAY OUT of galaxies it must be lighter than the galaxy one. The");
+console.log("   window is between them, and it is narrow but not empty — which is");
+console.log("   why 11 eV sterile neutrinos were proposed for exactly this job.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. SO THE INFERENCE IS RIGHT, WITH ONE LARGE CAVEAT");
+console.log("=".repeat(78));
+console.log("   RIGHT: if the transport supplies the galactic phenomenology then");
+console.log("   dark matter is not needed for rotation curves, and what is left to");
+console.log(`   explain drops from 5.3× the baryons to ${(RES - 1).toFixed(2)}× — about ten times less.`);
+console.log("   It also explains something ΛCDM finds awkward: why halos track the");
+console.log("   baryons so tightly. They do not; there is no halo in a galaxy.");
+console.log();
+console.log("   THE CAVEAT: the CMB does not care about any of this. Its third");
+console.log("   acoustic peak measures Ω_DM/Ω_b ≈ 5 at z = 1100, when there were no");
+console.log("   galaxies and no clusters and the transport had nothing to act on.");
+console.log("   A 0.5× residual cannot make that peak. So the reduction is real for");
+console.log("   clusters and NOT available for the microwave background.");
+console.log();
+console.log("   AND FOR THIS MODEL IT IS MOOT ANYWAY: it has no microwave");
+console.log("   background at all — the seventh closure — so it cannot use the CMB");
+console.log("   to argue either way. That is a bigger hole than the one this");
+console.log("   inference fills.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/rootm.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/rootm.ts
new file mode 100644
index 0000000..7f3d786
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/rootm.ts
@@ -0,0 +1,134 @@
+/**
+ * WHERE √M COULD COME FROM — simulated rather than argued.
+ *
+ * A body of N emitters sits in the vacuum. Every emitter turns a neutral point
+ * into a ± pair each tick and the two halves go their own ways. Charges stream
+ * a cell a tick. Where a + and a − land in the same cell they annihilate, which
+ * is `BITE` and is the only rule here.
+ *
+ * The question is what a distant body SEES: does the surviving flux go as N —
+ * in which case the source is a COUNT and the law is bilinear and Tully–Fisher
+ * is 21σ wrong — or as √N, which is what the data wants.
+ *
+ * Nothing about randomness is assumed. The charges are emitted, moved, and
+ * annihilated, and the flux is counted where it crosses a sphere.
+ */
+
+const L = 64, C = L / 2;                       // box, and its middle
+const R_OUT = 30, R_MEAS = 24;                 // where charges leave, where counted
+
+type Run = { N: number; Rb: number; flux: number; emitted: number };
+
+const sim = (N: number, Rb: number, ticks = 160, warm = 90): Run => {
+  let seed = 987654321 + N * 7919 + Rb * 104729;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+
+  // emitter positions, fixed for the run
+  const ex: number[] = [], ey: number[] = [], ez: number[] = [];
+  for (let i = 0; i < N; i++) {
+    let x, y, z;
+    do { x = (rnd() * 2 - 1); y = (rnd() * 2 - 1); z = (rnd() * 2 - 1); }
+    while (x * x + y * y + z * z > 1);
+    ex.push(C + x * Rb); ey.push(C + y * Rb); ez.push(C + z * Rb);
+  }
+
+  // live charges, as flat arrays
+  let px: number[] = [], py: number[] = [], pz: number[] = [];
+  let vx: number[] = [], vy: number[] = [], vz: number[] = [], q: number[] = [];
+
+  const dir = () => {                          // isotropic
+    const u = rnd() * 2 - 1, ph = rnd() * 2 * Math.PI, s = Math.sqrt(1 - u * u);
+    return [s * Math.cos(ph), s * Math.sin(ph), u];
+  };
+
+  let crossed = 0, emitted = 0, counted = 0;
+
+  for (let t = 0; t < ticks; t++) {
+    // 1. emit: one neutral point becomes one + and one −
+    for (let i = 0; i < N; i++) {
+      for (const sign of [1, -1]) {
+        const [dx, dy, dz] = dir();
+        px.push(ex[i]); py.push(ey[i]); pz.push(ez[i]);
+        vx.push(dx); vy.push(dy); vz.push(dz); q.push(sign);
+      }
+      if (t >= warm) emitted += 2;
+    }
+
+    // 2. move a cell a tick
+    for (let i = 0; i < q.length; i++) { px[i] += vx[i]; py[i] += vy[i]; pz[i] += vz[i]; }
+
+    // 3. count what crosses the measuring sphere, then annihilate
+    const bucket = new Map<number, number[]>();
+    for (let i = 0; i < q.length; i++) {
+      const dx = px[i] - C, dy = py[i] - C, dz = pz[i] - C;
+      const r = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      const was = Math.sqrt((px[i] - vx[i] - C) ** 2 + (py[i] - vy[i] - C) ** 2
+        + (pz[i] - vz[i] - C) ** 2);
+      if (was < R_MEAS && r >= R_MEAS && t >= warm) crossed++;
+
+      const key = ((px[i] | 0) * 4096 + (py[i] | 0)) * 4096 + (pz[i] | 0);
+      const b = bucket.get(key);
+      if (b) b.push(i); else bucket.set(key, [i]);
+    }
+
+    const dead = new Uint8Array(q.length);
+    for (const ids of bucket.values()) {
+      if (ids.length < 2) continue;
+      const plus = ids.filter(i => q[i] > 0), minus = ids.filter(i => q[i] < 0);
+      const n = Math.min(plus.length, minus.length);
+      for (let j = 0; j < n; j++) { dead[plus[j]] = 1; dead[minus[j]] = 1; }
+    }
+
+    // 4. compact: drop the annihilated and the escaped
+    const nx: number[] = [], ny: number[] = [], nz: number[] = [];
+    const ux: number[] = [], uy: number[] = [], uz: number[] = [], nq: number[] = [];
+    for (let i = 0; i < q.length; i++) {
+      if (dead[i]) continue;
+      const dx = px[i] - C, dy = py[i] - C, dz = pz[i] - C;
+      if (dx * dx + dy * dy + dz * dz > R_OUT * R_OUT) continue;
+      nx.push(px[i]); ny.push(py[i]); nz.push(pz[i]);
+      ux.push(vx[i]); uy.push(vy[i]); uz.push(vz[i]); nq.push(q[i]);
+    }
+    px = nx; py = ny; pz = nz; vx = ux; vy = uy; vz = uz; q = nq;
+    if (t >= warm) counted++;
+  }
+
+  return { N, Rb, flux: crossed / counted, emitted: emitted / counted };
+};
+
+const slope = (rows: Run[]) => {
+  // least squares on log flux vs log N
+  const n = rows.length;
+  const sx = rows.reduce((a, r) => a + Math.log(r.N), 0);
+  const sy = rows.reduce((a, r) => a + Math.log(r.flux), 0);
+  const sxx = rows.reduce((a, r) => a + Math.log(r.N) ** 2, 0);
+  const sxy = rows.reduce((a, r) => a + Math.log(r.N) * Math.log(r.flux), 0);
+  return (n * sxy - sx * sy) / (n * sxx - sx * sx);
+};
+
+console.log("=".repeat(70));
+console.log("ONE BODY, MORE AND MORE EMITTERS IN IT");
+console.log("=".repeat(70));
+console.log("  a ball of radius Rb, N emitters in it, flux counted at r = 24");
+console.log("  if the source is a COUNT the flux goes as N; the data wants √N.");
+console.log();
+
+for (const Rb of [3, 6]) {
+  console.log(`  body radius ${Rb} cells`);
+  console.log("     N      emitted/tick   flux at 24   flux/N     survived");
+  const rows: Run[] = [];
+  for (const N of [2, 6, 20, 60, 200, 600, 2000]) {
+    const r = sim(N, Rb);
+    rows.push(r);
+    console.log(`  ${String(N).padStart(6)}   ${r.emitted.toFixed(0).padStart(10)}   ` +
+      `${r.flux.toFixed(1).padStart(10)}   ${(r.flux / r.N).toFixed(3).padStart(7)}   ` +
+      `${(100 * r.flux / r.emitted).toFixed(1)}%`);
+  }
+  console.log(`     fitted slope d(log flux)/d(log N) = ${slope(rows).toFixed(3)}` +
+    `      [1 = count, 0.5 = √N, 0 = saturated]`);
+  const hi = rows.slice(-4);
+  console.log(`     over the top four alone            = ${slope(hi).toFixed(3)}`);
+  console.log();
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/rootm2.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/rootm2.ts
new file mode 100644
index 0000000..ed2d801
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/rootm2.ts
@@ -0,0 +1,133 @@
+/**
+ * WHAT CONTROLS THE CANCELLATION, AND WHERE REAL BODIES SIT ON IT.
+ *
+ * The first run found the surviving flux going as N^0.5 over the middle of its
+ * range and flattening to N^0.31 at the top — a CROSSOVER, not a power law. So
+ * find the parameter that sets it, check the collapse, and then put real bodies
+ * on the axis.
+ */
+
+const L = 64, C = L / 2, R_OUT = 30, R_MEAS = 24;
+
+const sim = (N: number, Rb: number, ticks = 150, warm = 85) => {
+  let seed = 987654321 + N * 7919 + Rb * 104729;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+  const ex: number[] = [], ey: number[] = [], ez: number[] = [];
+  for (let i = 0; i < N; i++) {
+    let x, y, z;
+    do { x = rnd() * 2 - 1; y = rnd() * 2 - 1; z = rnd() * 2 - 1; }
+    while (x * x + y * y + z * z > 1);
+    ex.push(C + x * Rb); ey.push(C + y * Rb); ez.push(C + z * Rb);
+  }
+  let px: number[] = [], py: number[] = [], pz: number[] = [];
+  let vx: number[] = [], vy: number[] = [], vz: number[] = [], q: number[] = [];
+  const dir = () => {
+    const u = rnd() * 2 - 1, ph = rnd() * 2 * Math.PI, s = Math.sqrt(1 - u * u);
+    return [s * Math.cos(ph), s * Math.sin(ph), u];
+  };
+  let crossed = 0, emitted = 0, counted = 0;
+  for (let t = 0; t < ticks; t++) {
+    for (let i = 0; i < N; i++) {
+      for (const sg of [1, -1]) {
+        const [dx, dy, dz] = dir();
+        px.push(ex[i]); py.push(ey[i]); pz.push(ez[i]);
+        vx.push(dx); vy.push(dy); vz.push(dz); q.push(sg);
+      }
+      if (t >= warm) emitted += 2;
+    }
+    for (let i = 0; i < q.length; i++) { px[i] += vx[i]; py[i] += vy[i]; pz[i] += vz[i]; }
+    const bucket = new Map<number, number[]>();
+    for (let i = 0; i < q.length; i++) {
+      const dx = px[i] - C, dy = py[i] - C, dz = pz[i] - C;
+      const r2 = dx * dx + dy * dy + dz * dz;
+      const w = (px[i] - vx[i] - C) ** 2 + (py[i] - vy[i] - C) ** 2 + (pz[i] - vz[i] - C) ** 2;
+      if (w < R_MEAS * R_MEAS && r2 >= R_MEAS * R_MEAS && t >= warm) crossed++;
+      const key = ((px[i] | 0) * 4096 + (py[i] | 0)) * 4096 + (pz[i] | 0);
+      const b = bucket.get(key); if (b) b.push(i); else bucket.set(key, [i]);
+    }
+    const dead = new Uint8Array(q.length);
+    for (const ids of bucket.values()) {
+      if (ids.length < 2) continue;
+      const p = ids.filter(i => q[i] > 0), m = ids.filter(i => q[i] < 0);
+      const n = Math.min(p.length, m.length);
+      for (let j = 0; j < n; j++) { dead[p[j]] = 1; dead[m[j]] = 1; }
+    }
+    const nx: number[] = [], ny: number[] = [], nz: number[] = [], ux: number[] = [],
+      uy: number[] = [], uz: number[] = [], nq: number[] = [];
+    for (let i = 0; i < q.length; i++) {
+      if (dead[i]) continue;
+      const dx = px[i] - C, dy = py[i] - C, dz = pz[i] - C;
+      if (dx * dx + dy * dy + dz * dz > R_OUT * R_OUT) continue;
+      nx.push(px[i]); ny.push(py[i]); nz.push(pz[i]);
+      ux.push(vx[i]); uy.push(vy[i]); uz.push(vz[i]); nq.push(q[i]);
+    }
+    px = nx; py = ny; pz = nz; vx = ux; vy = uy; vz = uz; q = nq;
+    if (t >= warm) counted++;
+  }
+  return { N, Rb, flux: crossed / counted, emitted: emitted / counted };
+};
+
+console.log("=".repeat(72));
+console.log("1. THE COLLAPSE — is it N/Rb that decides?");
+console.log("=".repeat(72));
+console.log("  The optical depth of a body to its OWN flux: the surface density");
+console.log("  of charges is ~2N/(4 pi Rb^2) per tick and the path through the");
+console.log("  body is ~Rb, so tau ~ N/(2 pi Rb). Same tau, different (N, Rb),");
+console.log("  should give the same surviving fraction:");
+console.log();
+console.log("     N     Rb    tau      survived");
+for (const [N, Rb] of [[20, 3], [40, 6], [80, 12],
+                       [120, 3], [240, 6], [480, 12],
+                       [600, 3], [1200, 6]] as [number, number][]) {
+  const r = sim(N, Rb);
+  console.log(`  ${String(N).padStart(5)}  ${String(Rb).padStart(4)}   ` +
+    `${(N / (2 * Math.PI * Rb)).toFixed(2).padStart(6)}   ` +
+    `${(100 * r.flux / r.emitted).toFixed(1).padStart(6)}%`);
+}
+
+console.log();
+console.log("=".repeat(72));
+console.log("2. THE LOCAL SLOPE — where it is 1, where it passes 1/2, where it dies");
+console.log("=".repeat(72));
+const Rb = 6;
+const Ns = [2, 5, 12, 30, 75, 190, 480, 1200, 3000];
+const runs = Ns.map(N => sim(N, Rb));
+console.log("     N       tau      flux    local slope d(log F)/d(log N)");
+for (let i = 0; i < runs.length; i++) {
+  const s = i === 0 ? NaN
+    : Math.log(runs[i].flux / runs[i - 1].flux) / Math.log(runs[i].N / runs[i - 1].N);
+  console.log(`  ${String(runs[i].N).padStart(6)}   ${(runs[i].N / (2 * Math.PI * Rb)).toFixed(2).padStart(7)}   ` +
+    `${runs[i].flux.toFixed(1).padStart(6)}   ${isNaN(s) ? "    —" : s.toFixed(3)}`);
+}
+
+console.log();
+console.log("=".repeat(72));
+console.log("3. AND WHERE REAL BODIES SIT");
+console.log("=".repeat(72));
+const LP = 1.616255e-35, MP = 2.176434e-8, MU = 0.06235150 * MP;
+const KPC = 3.0857e19, MSUN = 1.98847e30;
+console.log("  tau = N/(2 pi R) with N = M/MU emitters and R the radius IN CELLS.");
+console.log("  Cancellation needs tau >~ 1. A body only starts cancelling when it");
+console.log("  is optically thick to its own charges.");
+console.log();
+console.log("     body                 M (kg)      R (m)       N          tau");
+for (const [name, M, R] of [
+  ["a proton", 1.6726e-27, 0.84e-15],
+  ["a grain of sand", 5e-5, 5e-4],
+  ["the Earth", 5.972e24, 6.371e6],
+  ["the Sun", MSUN, 6.957e8],
+  ["a neutron star", 1.4 * MSUN, 1.2e4],
+  ["the Milky Way", 6.2e10 * MSUN, 15 * KPC],
+] as [string, number, number][]) {
+  const N = M / MU, cells = R / LP, tau = N / (2 * Math.PI * cells);
+  console.log(`  ${name.padEnd(18)} ${M.toExponential(2)}  ${R.toExponential(2)}  ` +
+    `${N.toExponential(2)}  ${tau.toExponential(2)}`);
+}
+console.log();
+console.log("  Everything is between 10^-6 and 10^-13, and the neutron star — the");
+console.log("  densest thing there is — is the only one that even approaches.");
+console.log("  Every real body is DILUTE: its own flux does not meet itself, so");
+console.log("  the source is a count, the flux goes as N exactly, and there is no");
+console.log("  cancellation here to be had.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
new file mode 100755
index 0000000..bd5e943
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# Run one test, or all of them.
+#
+#   ./run.sh                 every test, in order, stopping on the first failure
+#   ./run.sh combined        just that one
+#   ./run.sh --list          what there is
+#
+# Everything here is standalone TypeScript with no imports — each file carries
+# its own constants and its own copy of whatever geometry it needs, so a test
+# can be read, run and edited without touching the article.
+
+set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$HERE/../../../../.." && pwd)"
+TS="$ROOT/node_modules/.bin/ts-node"
+OPTS='{"module":"commonjs","target":"es2020"}'
+
+[ -x "$TS" ] || { echo "ts-node not found at $TS"; exit 1; }
+
+# rough order: the force law, then the cosmology, then dark matter, then closure
+ORDER=(
+  three combined
+  frontcheck sne
+  caught arms
+  rootm rootm2 feed selfcon fixedpoint speedloop drivers
+  galaxy_sc perm vmass sens sign
+  transport expand polarity pol2
+  genzel empty spacing
+  blocking redo shape quant steps joint
+  recon which138 accum accumulate asym
+)
+
+if [ "${1:-}" = "--list" ]; then printf '%s\n' "${ORDER[@]}"; exit 0; fi
+
+run_one() {
+  local n="$1"
+  [ -f "$HERE/$n.ts" ] || { echo "  no such test: $n"; return 1; }
+  echo "═══ $n ═══"
+  "$TS" --compiler-options "$OPTS" "$HERE/$n.ts" || { echo "  FAILED: $n"; return 1; }
+  echo
+}
+
+if [ $# -gt 0 ]; then run_one "$1"; exit $?; fi
+
+fail=0
+for n in "${ORDER[@]}"; do
+  [ -f "$HERE/$n.ts" ] || continue
+  run_one "$n" || fail=1
+done
+exit $fail
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/selfcon.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/selfcon.ts
new file mode 100644
index 0000000..21be5e4
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/selfcon.ts
@@ -0,0 +1,163 @@
+/**
+ * THE FEEDBACK, SIMULATED FROM THE RULES — not from an equation I picked.
+ *
+ * The claim: more gravity makes a thing lighter (`m_eff = m/(1+u)`), lighter
+ * means fewer pulses (mass IS the pulse period), fewer pulses means less
+ * gravity — so the loop FEEDS ITSELF BUT BY LESS EACH ROUND. A self-limiting
+ * feedback is exactly the structure that turns a linear source into a root one,
+ * and nothing about coherence enters it. That is a different claim from the one
+ * tested before and it was not tested.
+ *
+ * So: emitters that pulse, charges that stream and annihilate, folds that
+ * accumulate where annihilations happen, and every emitter's rate set by the
+ * fold it is sitting in. Iterate to a fixed point. Measure how the flux that
+ * escapes scales with N.
+ *
+ * Nothing is assumed about the answer. The exponent is fitted from the run.
+ */
+
+const L = 64, CC = L / 2, R_OUT = 30, R_MEAS = 24;
+const cell = (x: number, y: number, z: number) =>
+  ((x | 0) * 128 + (y | 0)) * 128 + (z | 0);
+
+type Out = { N: number; flux: number; emitted: number; meanU: number };
+
+/**
+ * `kappa` is the one dial: how much fold one annihilation per tick per cell is
+ * worth. It is the coupling the model would have to supply, and it is scanned
+ * rather than chosen.
+ */
+const run = (N: number, Rb: number, kappa: number,
+  rounds = 7, ticks = 70, warm = 40): Out => {
+  let seed = 555 + N * 7919 + Math.round(Math.log(kappa + 1e-30) * 1000) * 13;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+
+  const ex: number[] = [], ey: number[] = [], ez: number[] = [];
+  for (let i = 0; i < N; i++) {
+    let x, y, z;
+    do { x = rnd() * 2 - 1; y = rnd() * 2 - 1; z = rnd() * 2 - 1; }
+    while (x * x + y * y + z * z > 1);
+    ex.push(CC + x * Rb); ey.push(CC + y * Rb); ez.push(CC + z * Rb);
+  }
+
+  // every emitter starts at the ceiling: one pulse a tick, m = 1
+  const m = new Float64Array(N).fill(1);
+  let fold = new Map<number, number>();          // cell -> u
+  let last: Out = { N, flux: 0, emitted: 0, meanU: 0 };
+
+  for (let round = 0; round < rounds; round++) {
+    let px: number[] = [], py: number[] = [], pz: number[] = [];
+    let vx: number[] = [], vy: number[] = [], vz: number[] = [], q: number[] = [];
+    const phase = new Float64Array(N);
+    const annih = new Map<number, number>();
+    let crossed = 0, emitted = 0, counted = 0;
+
+    const dir = () => {
+      const u = rnd() * 2 - 1, a = rnd() * 2 * Math.PI, s = Math.sqrt(1 - u * u);
+      return [s * Math.cos(a), s * Math.sin(a), u];
+    };
+
+    for (let t = 0; t < ticks; t++) {
+      // 1. emit — a pulse every 1/m ticks, so a lighter emitter pulses less
+      for (let i = 0; i < N; i++) {
+        phase[i] += m[i];
+        if (phase[i] < 1) continue;
+        phase[i] -= 1;
+        for (const sg of [1, -1]) {
+          const [dx, dy, dz] = dir();
+          px.push(ex[i]); py.push(ey[i]); pz.push(ez[i]);
+          vx.push(dx); vy.push(dy); vz.push(dz); q.push(sg);
+        }
+        if (t >= warm) emitted += 2;
+      }
+
+      for (let i = 0; i < q.length; i++) { px[i] += vx[i]; py[i] += vy[i]; pz[i] += vz[i]; }
+
+      const bucket = new Map<number, number[]>();
+      for (let i = 0; i < q.length; i++) {
+        const dx = px[i] - CC, dy = py[i] - CC, dz = pz[i] - CC;
+        const r2 = dx * dx + dy * dy + dz * dz;
+        const w = (px[i] - vx[i] - CC) ** 2 + (py[i] - vy[i] - CC) ** 2
+          + (pz[i] - vz[i] - CC) ** 2;
+        if (w < R_MEAS * R_MEAS && r2 >= R_MEAS * R_MEAS && t >= warm) crossed++;
+        const k = cell(px[i], py[i], pz[i]);
+        const b = bucket.get(k); if (b) b.push(i); else bucket.set(k, [i]);
+      }
+
+      const dead = new Uint8Array(q.length);
+      for (const [k, ids] of bucket) {
+        if (ids.length < 2) continue;
+        const p = ids.filter(i => q[i] > 0), mi = ids.filter(i => q[i] < 0);
+        const n = Math.min(p.length, mi.length);
+        if (n === 0) continue;
+        for (let j = 0; j < n; j++) { dead[p[j]] = 1; dead[mi[j]] = 1; }
+        // 2. every annihilation folds the node it happened at
+        if (t >= warm) annih.set(k, (annih.get(k) ?? 0) + n);
+      }
+
+      const nx: number[] = [], ny: number[] = [], nz: number[] = [], ux: number[] = [],
+        uy: number[] = [], uz: number[] = [], nq: number[] = [];
+      for (let i = 0; i < q.length; i++) {
+        if (dead[i]) continue;
+        const dx = px[i] - CC, dy = py[i] - CC, dz = pz[i] - CC;
+        if (dx * dx + dy * dy + dz * dz > R_OUT * R_OUT) continue;
+        nx.push(px[i]); ny.push(py[i]); nz.push(pz[i]);
+        ux.push(vx[i]); uy.push(vy[i]); uz.push(vz[i]); nq.push(q[i]);
+      }
+      px = nx; py = ny; pz = nz; vx = ux; vy = uy; vz = uz; q = nq;
+      if (t >= warm) counted++;
+    }
+
+    // 3. the fold each cell now carries, and the rate it implies
+    const next = new Map<number, number>();
+    for (const [k, n] of annih) next.set(k, kappa * n / counted);
+    fold = next;
+
+    let sumU = 0;
+    for (let i = 0; i < N; i++) {
+      const u = fold.get(cell(ex[i], ey[i], ez[i])) ?? 0;
+      sumU += u;
+      // m_eff = m/(1+u), damped so the fixed point is approached not overshot
+      const want = 1 / (1 + u);
+      m[i] = 0.5 * m[i] + 0.5 * want;
+    }
+
+    last = { N, flux: crossed / counted, emitted: emitted / counted, meanU: sumU / N };
+  }
+
+  return last;
+};
+
+const slope = (a: Out, b: Out) =>
+  Math.log(b.flux / a.flux) / Math.log(b.N / a.N);
+
+console.log("=".repeat(76));
+console.log("THE SELF-CONSISTENT SOURCE — does the loop settle at a root?");
+console.log("=".repeat(76));
+console.log("  Every emitter starts at the ceiling, m = 1. Each round it is slowed");
+console.log("  by the fold its own body has built, and the run is repeated until");
+console.log("  the rate stops moving. kappa is how much one annihilation a tick is");
+console.log("  worth as fold — the one coupling, scanned rather than chosen.");
+console.log();
+
+const Rb = 6;
+const Ns = [30, 120, 480, 1920];
+
+for (const kappa of [0, 0.03, 0.3, 3, 30]) {
+  const outs = Ns.map(N => run(N, Rb, kappa));
+  console.log(`  kappa = ${String(kappa).padStart(5)}`);
+  console.log("       N      mean u     m_eff     emitted/tick   flux     slope");
+  for (let i = 0; i < outs.length; i++) {
+    const o = outs[i];
+    const s = i === 0 ? NaN : slope(outs[i - 1], o);
+    console.log(`  ${String(o.N).padStart(6)}   ${o.meanU.toFixed(3).padStart(8)}   ` +
+      `${(1 / (1 + o.meanU)).toFixed(4).padStart(7)}   ${o.emitted.toFixed(0).padStart(10)}   ` +
+      `${o.flux.toFixed(1).padStart(7)}   ${isNaN(s) ? "   —" : s.toFixed(3)}`);
+  }
+  console.log();
+}
+console.log("  slope 1 = source is a count (Newton, v^4 ~ M^2)");
+console.log("  slope 0.5 = ROOT M (Tully-Fisher, v^4 ~ M)");
+console.log("  slope 0 = saturated (M_eff independent of M)");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sens.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sens.ts
new file mode 100644
index 0000000..02c9ef5
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sens.ts
@@ -0,0 +1,308 @@
+/**
+ * THE PERMUTATION SEARCH, on a fully relaxed galaxy.
+ *
+ * Part 2 established something that reframes the whole thing: A FEEDBACK THAT
+ * WEAKENS THE SOURCE CAN ONLY LOWER A ROTATION CURVE. It cannot supply missing
+ * gravity at any coupling, for any driver. So the feedback is not the dark
+ * matter — it can only be the thing that fixes HOW an excess scales with mass,
+ * and something else has to supply the excess.
+ *
+ * Which means the honest object to test is the PAIR: the caught pair's 1/R
+ * channel supplying the excess, and the feedback setting its mass scaling. Two
+ * requirements, and they must be met at once:
+ *
+ *     SHAPE   one galaxy's rotation curve, against Gaia
+ *     SCALING the Tully–Fisher slope across five decades of galaxy mass
+ *
+ * Everything is permuted: which driver, which channel the feedback acts on,
+ * whether the driver is read locally or averaged over the body. One coupling is
+ * fitted per permutation (at the Sun) and nothing else.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const A0 = 1.2e-10;
+
+const NR = 220, RMAX = 70 * KPC;
+const Rj = Array.from({ length: NR }, (_, j) => RMAX * (j + 0.5) / NR);
+const dR = RMAX / NR;
+const NOUT = 70;                                   // out to 35 kpc
+const ri = Array.from({ length: NOUT }, (_, i) => (i + 1) * 0.5 * KPC);
+const H = 0.30 * KPC;
+
+const kernel = (p: number) => {
+  const NP = 300;
+  const K: Float64Array[] = [];
+  for (let i = 0; i < NOUT; i++) {
+    const row = new Float64Array(NR), r = ri[i];
+    for (let j = 0; j < NR; j++) {
+      const R = Rj[j]; let acc = 0;
+      for (let q = 0; q < NP; q++) {
+        const ph = 2 * Math.PI * (q + 0.5) / NP;
+        const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+        const d2 = dx * dx + dy * dy + H * H;
+        acc += dx / Math.pow(d2, (p + 1) / 2);
+      }
+      row[j] = -acc / NP;
+    }
+    K.push(row);
+  }
+  return K;
+};
+console.log("precomputing kernels…");
+const K2 = kernel(2), K1 = kernel(1);
+console.log("done.\n");
+
+type Galaxy = { Md: number; Rd: number; Mg: number; Rg: number; Mb: number; ab: number };
+const MW: Galaxy = {
+  Md: 5.0e10 * MSUN, Rd: 2.6 * KPC, Mg: 1.2e10 * MSUN, Rg: 7.0 * KPC,
+  Mb: 0.9e10 * MSUN, ab: 0.5 * KPC,
+};
+
+/** a family of galaxies: mass scaled, size following the observed R ∝ M^0.35 */
+const scaled = (f: number): Galaxy => ({
+  Md: MW.Md * f, Rd: MW.Rd * Math.pow(f, 0.35),
+  Mg: MW.Mg * f, Rg: MW.Rg * Math.pow(f, 0.35),
+  Mb: MW.Mb * f, ab: MW.ab * Math.pow(f, 0.35),
+});
+
+const ringMass = (g: Galaxy) => {
+  const m = new Float64Array(NR);
+  for (let j = 0; j < NR; j++) {
+    const R = Rj[j];
+    m[j] = (g.Md / (2 * Math.PI * g.Rd * g.Rd) * Math.exp(-R / g.Rd)
+      + g.Mg / (2 * Math.PI * g.Rg * g.Rg) * Math.exp(-R / g.Rg)) * 2 * Math.PI * R * dR;
+  }
+  return m;
+};
+
+type Setup = {
+  driverName: string;
+  driver: (g: number, u: number, v: number) => number;
+  kappa: number;
+  feedbackOn: "newton" | "caught" | "both";
+  local: boolean;
+  lambda: number;                                  // the caught-pair coupling
+};
+
+const solve = (gal: Galaxy, s: Setup, iters = 160) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let gT = new Float64Array(NOUT);
+
+  let wb = 1;                                        // the bulge is a source too
+  for (let it = 0; it < iters; it++) {
+    const gN = new Float64Array(NOUT), gC = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) {
+        a2 += r2[j] * m0[j] * (s.feedbackOn !== "caught" ? w[j] : 1);
+        a1 += r1[j] * m0[j] * (s.feedbackOn !== "newton" ? w[j] : 1);
+      }
+      gN[i] = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      gC[i] = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+    }
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) gTot[i] = gN[i] + s.lambda * gC[i];
+
+    const u = new Float64Array(NOUT); let acc = 0;
+    for (let i = NOUT - 1; i >= 0; i--) {
+      acc += gTot[i] * (i === NOUT - 1 ? 0.5 * KPC : ri[i + 1] - ri[i]);
+      u[i] = acc / (C * C);
+    }
+    const D = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++)
+      D[i] = s.driver(gTot[i], u[i], Math.sqrt(Math.max(0, gTot[i] * ri[i])) / C);
+
+    let Dbar = 0, ws = 0;
+    const onRing = new Float64Array(NR);
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      onRing[j] = D[k] * (1 - f) + D[k + 1] * f;
+      Dbar += onRing[j] * m0[j]; ws += m0[j];
+    }
+    Dbar /= ws;
+    for (let j = 0; j < NR; j++)
+      w[j] = 0.75 * w[j] + 0.25 / (1 + s.kappa * (s.local ? onRing[j] : Dbar));
+    // the bulge is made of emitters like everything else, so it is weakened
+    // too — leaving it out let it dominate at large kappa and dragged the
+    // whole scaling back to Newton's.
+    const Db = s.local ? D[0] : Dbar;
+    wb = 0.75 * wb + 0.25 / (1 + s.kappa * Db);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const MEAS = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+const idx = (rk: number) => Math.round(rk / 0.5) - 1;
+
+/** fit lambda so the Sun's speed is right, then score shape and BTFR slope */
+const score = (s: Omit<Setup, "lambda">) => {
+  let lo = 0, hi = 1e-24;
+  const at8 = (lam: number) => {
+    const g = solve(MW, { ...s, lambda: lam });
+    return kms(g[idx(8)], ri[idx(8)]);
+  };
+  while (at8(hi) < MEAS(8.122) && hi < 1e10) hi *= 4;
+  for (let i = 0; i < 34; i++) {
+    const mid = (lo + hi) / 2;
+    if (at8(mid) < MEAS(8.122)) lo = mid; else hi = mid;
+  }
+  const lambda = (lo + hi) / 2;
+
+  const g = solve(MW, { ...s, lambda });
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) {
+    ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++;
+  }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  // BTFR: flat speed vs baryonic mass across five decades
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f);
+    const gg = solve(gal, { ...s, lambda });
+    // "flat" speed: measured at 4 disc scale lengths, the usual convention
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    const M = (gal.Md + gal.Mg + gal.Mb) / MSUN;
+    pts.push([Math.log10(M), Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  const btfr = (nn * sxy - sx * sy) / (nn * sxx - sx * sx);   // d log M / d log v
+
+  return { lambda, shape, btfr };
+};
+
+
+/**
+ * THE MODEL'S OWN VELOCITY->MASS CONVERSION, which is a POWER LAW.
+ *
+ *     massFor(v) = LIGHT/v      so m ∝ 1/v, exactly — physics.ts
+ *
+ * The earlier tests used m/(1+κ·v/c), which SATURATES: past κv/c ≫ 1 it stops
+ * responding, which is why the exponent stalled. A power law never saturates.
+ * So: m_eff ∝ v^(−q), solved self-consistently, q scanned. q = 1 is the model's.
+ *
+ * The analytic expectation, for the caught pair's flat channel:
+ *     v² = λ·M_eff ∝ λ·N·v^(−q)   ⇒   v^(2+q) ∝ N   ⇒   BTFR slope = 2 + q
+ */
+
+const VREF = 200e3;                                // just sets λ's units
+
+const solveV = (gal: Galaxy, q: number, lambda: number, iters = 240) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let wb = 1, gT = new Float64Array(NOUT);
+
+  for (let it = 0; it < iters; it++) {
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) { a2 += r2[j] * m0[j] * w[j]; a1 += r1[j] * m0[j] * w[j]; }
+      const gN = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      const gC = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+      gTot[i] = gN + lambda * gC;
+    }
+    const v = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) v[i] = Math.sqrt(Math.max(1e-30, gTot[i] * ri[i]));
+
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      const vj = v[k] * (1 - f) + v[k + 1] * f;
+      w[j] = 0.85 * w[j] + 0.15 * Math.pow(Math.max(vj, 1e3) / VREF, -q);
+    }
+    wb = 0.85 * wb + 0.15 * Math.pow(Math.max(v[0], 1e3) / VREF, -q);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const scoreV = (q: number) => {
+  const at8 = (lam: number) => kms(solveV(MW, q, lam)[idx(8)], ri[idx(8)]);
+  let lo = 0, hi = 1e-30;
+  while (at8(hi) < MEAS(8.122) && hi < 1e12) hi *= 4;
+  for (let i = 0; i < 40; i++) { const m = (lo + hi) / 2; if (at8(m) < MEAS(8.122)) lo = m; else hi = m; }
+  const lambda = (lo + hi) / 2;
+
+  const g = solveV(MW, q, lambda);
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) { ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++; }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f), gg = solveV(gal, q, lambda);
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    pts.push([Math.log10((gal.Md + gal.Mg + gal.Mb) / MSUN),
+              Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  return { lambda, shape, btfr: (nn * sxy - sx * sy) / (nn * sxx - sx * sx), g };
+};
+
+
+console.log("=".repeat(78));
+console.log("1. THE CURVE AT q = 1, AGAINST GAIA, RADIUS BY RADIUS");
+console.log("=".repeat(78));
+{
+  const r = scoreV(1.0);
+  console.log("   r kpc   Newton   model(q=1)   Gaia    ratio");
+  for (const rk of [4,6,8,10,12,15,18,20,22,25,28,30]) {
+    const gN = solveV(MW, 0, 0)[idx(rk)];
+    console.log(`  ${String(rk).padStart(6)}  ${kms(gN,ri[idx(rk)]).toFixed(1).padStart(7)}  `+
+      `${kms(r.g[idx(rk)],ri[idx(rk)]).toFixed(1).padStart(10)}  ${MEAS(rk).toFixed(1).padStart(6)}  `+
+      `${(kms(r.g[idx(rk)],ri[idx(rk)])/MEAS(rk)).toFixed(3)}`);
+  }
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. HOW MUCH OF THE BTFR IS MY GALAXY-FAMILY ASSUMPTIONS?");
+console.log("=".repeat(78));
+console.log("  The family assumed R ∝ M^0.35 and a fixed gas fraction. Real dwarfs");
+console.log("  are gas-RICH, which steepens the measured relation. Both are my");
+console.log("  choices, not the model's, so their effect is a systematic:\n");
+const scaled2 = (f:number, s:number, gasTilt:number): Galaxy => {
+  const gf = Math.pow(f, -gasTilt);                  // gas fraction rises for dwarfs
+  return { Md: MW.Md*f, Rd: MW.Rd*Math.pow(f,s),
+           Mg: MW.Mg*f*gf, Rg: MW.Rg*Math.pow(f,s),
+           Mb: MW.Mb*f, ab: MW.ab*Math.pow(f,s) };
+};
+const btfrWith = (q:number, lambda:number, s:number, gasTilt:number) => {
+  const pts:[number,number][] = [];
+  for (const f of [1e-2,1e-1,1,1e1,1e2]) {
+    const gal = scaled2(f,s,gasTilt), gg = solveV(gal,q,lambda);
+    const rf = Math.min(4*gal.Rd, ri[NOUT-1]*0.95);
+    const k = Math.max(0,Math.min(NOUT-1,Math.round(rf/(0.5*KPC))-1));
+    pts.push([Math.log10((gal.Md+gal.Mg+gal.Mb)/MSUN), Math.log10(Math.max(1e-6,kms(gg[k],ri[k])))]);
+  }
+  const n=pts.length, sx=pts.reduce((a,p)=>a+p[1],0), sy=pts.reduce((a,p)=>a+p[0],0);
+  const sxx=pts.reduce((a,p)=>a+p[1]*p[1],0), sxy=pts.reduce((a,p)=>a+p[0]*p[1],0);
+  return (n*sxy-sx*sy)/(n*sxx-sx*sx);
+};
+const lam1 = scoreV(1.0).lambda;
+console.log("   size exp s   gas tilt   BTFR slope at q=1");
+for (const s of [0.2,0.35,0.5]) {
+  for (const gt of [0,0.15,0.3]) {
+    console.log(`   ${s.toFixed(2).padStart(9)}   ${gt.toFixed(2).padStart(8)}   ${btfrWith(1.0,lam1,s,gt).toFixed(2).padStart(10)}`);
+  }
+}
+console.log();
+console.log("  measured: 3.85 +/- 0.09");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/shape.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/shape.ts
new file mode 100644
index 0000000..cdc5662
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/shape.ts
@@ -0,0 +1,99 @@
+/**
+ * IS THE SHAPE STILL RIGHT WHEN THE SPLITTING IS NOT ISOTROPIC?
+ *
+ * I claimed the blocking and the projection "are functions of the same
+ * occupancy, so they can only move the SCALE". That is an assertion. If the
+ * blocked cone grows with the field, then the projection factor VARIES WITH
+ * RADIUS — deep inside it is heavily shut, far out it is open — and a
+ * radius-dependent coefficient changes the PROFILE, not just its normalisation.
+ * So the expansion around a galaxy is not a sphere, and the question is whether
+ * the rotation curve survives that.
+ */
+const G=6.674e-11,MSUN=1.98847e30,KPC=3.0857e19,C=2.99792458e8;
+const A0=C*(70.9e3/3.0857e22)/(2*Math.PI);
+const NR=200,RMAX=70*KPC,NOUT=70,HZ=0.30*KPC;
+const Rj=Array.from({length:NR},(_,j)=>RMAX*(j+0.5)/NR), dR=RMAX/NR;
+const ri=Array.from({length:NOUT},(_,i)=>(i+1)*0.5*KPC);
+const kern=(()=>{const NP=280,K:Float64Array[]=[];
+ for(let i=0;i<NOUT;i++){const row=new Float64Array(NR),r=ri[i];
+  for(let j=0;j<NR;j++){const R=Rj[j];let a=0;
+   for(let q=0;q<NP;q++){const ph=2*Math.PI*(q+0.5)/NP;
+    const dx=R*Math.cos(ph)-r,dy=R*Math.sin(ph);a+=dx/Math.pow(dx*dx+dy*dy+HZ*HZ,1.5);}
+   row[j]=-a/NP;} K.push(row);} return K;})();
+const MW={Md:5.0e10*MSUN,Rd:2.6*KPC,Mg:1.2e10*MSUN,Rg:7.0*KPC,Mb:0.9e10*MSUN,ab:0.5*KPC};
+const sig=(R:number)=>MW.Md/(2*Math.PI*MW.Rd*MW.Rd)*Math.exp(-R/MW.Rd)
+  +MW.Mg/(2*Math.PI*MW.Rg*MW.Rg)*Math.exp(-R/MW.Rg);
+const gN=(()=>{const m=new Float64Array(NR);
+ for(let j=0;j<NR;j++)m[j]=sig(Rj[j])*2*Math.PI*Rj[j]*dR;
+ const o=new Float64Array(NOUT);
+ for(let i=0;i<NOUT;i++){let a=0;const row=kern[i];
+  for(let j=0;j<NR;j++)a+=row[j]*m[j];
+  o[i]=G*a+G*MW.Mb/Math.pow(ri[i]+MW.ab,2);} return o;})();
+
+/** the lattice's own 26 directions, and the projection with a cone shut */
+const dirs:[number,number,number][]=[];
+for(let x=-1;x<=1;x++)for(let y=-1;y<=1;y++)for(let z=-1;z<=1;z++) if(x||y||z) dirs.push([x,y,z]);
+const projAt=(cut:number)=>{let s=0,n=0;
+  for(const d of dirs){const m=Math.hypot(d[0],d[1],d[2]),uz=d[2]/m;
+    if(uz>cut)continue; s+=Math.abs(uz);n++;}
+  return n? s/n : 0;};
+const P_ISO=projAt(1.01);
+/** how much of the forward cone is shut, as a function of occupancy */
+const cutFor=(theta:number)=>{
+  // fraction of solid angle shut saturates at f_max; cos cut from that fraction
+  const f=theta/(1+theta);
+  return 1-2*Math.min(f,0.5);          // f=0 -> cut 1 (nothing), f=0.5 -> cut 0
+};
+const MEAS=(rk:number)=>229.0-1.7*(rk-8.122);
+const kms=(g:number,r:number)=>Math.sqrt(Math.max(0,g*r))/1e3;
+const idx=(rk:number)=>Math.round(rk/0.5)-1;
+
+/** solve g = gN(1 + (a0/g)·P(g/a0)/P_iso) self-consistently at each radius */
+const solveAniso=(gNv:number,a0:number,aniso:boolean)=>{
+  let g=gNv+a0;
+  for(let k=0;k<400;k++){
+    const th=g/a0;
+    const P=aniso? projAt(cutFor(th))/P_ISO : 1;
+    g=0.5*g+0.5*(gNv*(1+(a0/g)*P));
+  }
+  return g;
+};
+
+console.log("=".repeat(74));
+console.log("THE PROJECTION AS A FUNCTION OF RADIUS — is it flat or not?");
+console.log("=".repeat(74));
+console.log("   r kpc   g/a0      cone cut   P/P_iso    a0_eff/a0");
+for(const rk of [2,5,8,12,20,30]){
+  const g=solveAniso(gN[idx(rk)],A0,true), th=g/A0;
+  const P=projAt(cutFor(th))/P_ISO;
+  console.log(`  ${String(rk).padStart(6)}  ${th.toFixed(2).padStart(7)}   ${cutFor(th).toFixed(3).padStart(7)}   `+
+    `${P.toFixed(4).padStart(7)}    ${P.toFixed(4)}`);
+}
+console.log();
+console.log("=".repeat(74));
+console.log("AND WHAT IT DOES TO THE CURVE");
+console.log("=".repeat(74));
+const shapeOf=(aniso:boolean)=>{let s=0,n=0;
+  for(let rk=6;rk<=25;rk++){
+    const g=solveAniso(gN[idx(rk)],A0,aniso);
+    s+=Math.pow(kms(g,ri[idx(rk)])/MEAS(rk)-1,2);n++;}
+  return 100*Math.sqrt(s/n);};
+console.log(`   isotropic splitting        shape ${shapeOf(false).toFixed(1)}%`);
+console.log(`   anisotropic, cone grows    shape ${shapeOf(true).toFixed(1)}%`);
+console.log();
+console.log("   r kpc   isotropic   anisotropic   Gaia");
+for(const rk of [6,8,12,20,30]){
+  console.log(`  ${String(rk).padStart(6)}  ${kms(solveAniso(gN[idx(rk)],A0,false),ri[idx(rk)]).toFixed(1).padStart(9)}   `+
+    `${kms(solveAniso(gN[idx(rk)],A0,true),ri[idx(rk)]).toFixed(1).padStart(11)}   ${MEAS(rk).toFixed(1)}`);
+}
+console.log();
+console.log("   and refitting a0 to absorb it:");
+let best=1e9,bestA=0;
+for(let f=0.6;f<=2.0;f+=0.01){const a=A0*f;
+  let s=0,n=0;
+  for(let rk=6;rk<=25;rk++){const g=solveAniso(gN[idx(rk)],a,true);
+    s+=Math.pow(kms(g,ri[idx(rk)])/MEAS(rk)-1,2);n++;}
+  const sh=100*Math.sqrt(s/n); if(sh<best){best=sh;bestA=a;}}
+console.log(`     best a0 = ${bestA.toExponential(3)} (${(bestA/A0).toFixed(2)}x cH0/2pi), shape ${best.toFixed(1)}%`);
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sign.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sign.ts
new file mode 100644
index 0000000..371698a
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sign.ts
@@ -0,0 +1,273 @@
+/**
+ * THE PERMUTATION SEARCH, on a fully relaxed galaxy.
+ *
+ * Part 2 established something that reframes the whole thing: A FEEDBACK THAT
+ * WEAKENS THE SOURCE CAN ONLY LOWER A ROTATION CURVE. It cannot supply missing
+ * gravity at any coupling, for any driver. So the feedback is not the dark
+ * matter — it can only be the thing that fixes HOW an excess scales with mass,
+ * and something else has to supply the excess.
+ *
+ * Which means the honest object to test is the PAIR: the caught pair's 1/R
+ * channel supplying the excess, and the feedback setting its mass scaling. Two
+ * requirements, and they must be met at once:
+ *
+ *     SHAPE   one galaxy's rotation curve, against Gaia
+ *     SCALING the Tully–Fisher slope across five decades of galaxy mass
+ *
+ * Everything is permuted: which driver, which channel the feedback acts on,
+ * whether the driver is read locally or averaged over the body. One coupling is
+ * fitted per permutation (at the Sun) and nothing else.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const A0 = 1.2e-10;
+
+const NR = 220, RMAX = 70 * KPC;
+const Rj = Array.from({ length: NR }, (_, j) => RMAX * (j + 0.5) / NR);
+const dR = RMAX / NR;
+const NOUT = 70;                                   // out to 35 kpc
+const ri = Array.from({ length: NOUT }, (_, i) => (i + 1) * 0.5 * KPC);
+const H = 0.30 * KPC;
+
+const kernel = (p: number) => {
+  const NP = 300;
+  const K: Float64Array[] = [];
+  for (let i = 0; i < NOUT; i++) {
+    const row = new Float64Array(NR), r = ri[i];
+    for (let j = 0; j < NR; j++) {
+      const R = Rj[j]; let acc = 0;
+      for (let q = 0; q < NP; q++) {
+        const ph = 2 * Math.PI * (q + 0.5) / NP;
+        const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+        const d2 = dx * dx + dy * dy + H * H;
+        acc += dx / Math.pow(d2, (p + 1) / 2);
+      }
+      row[j] = -acc / NP;
+    }
+    K.push(row);
+  }
+  return K;
+};
+console.log("precomputing kernels…");
+const K2 = kernel(2), K1 = kernel(1);
+console.log("done.\n");
+
+type Galaxy = { Md: number; Rd: number; Mg: number; Rg: number; Mb: number; ab: number };
+const MW: Galaxy = {
+  Md: 5.0e10 * MSUN, Rd: 2.6 * KPC, Mg: 1.2e10 * MSUN, Rg: 7.0 * KPC,
+  Mb: 0.9e10 * MSUN, ab: 0.5 * KPC,
+};
+
+/** a family of galaxies: mass scaled, size following the observed R ∝ M^0.35 */
+const scaled = (f: number): Galaxy => ({
+  Md: MW.Md * f, Rd: MW.Rd * Math.pow(f, 0.35),
+  Mg: MW.Mg * f, Rg: MW.Rg * Math.pow(f, 0.35),
+  Mb: MW.Mb * f, ab: MW.ab * Math.pow(f, 0.35),
+});
+
+const ringMass = (g: Galaxy) => {
+  const m = new Float64Array(NR);
+  for (let j = 0; j < NR; j++) {
+    const R = Rj[j];
+    m[j] = (g.Md / (2 * Math.PI * g.Rd * g.Rd) * Math.exp(-R / g.Rd)
+      + g.Mg / (2 * Math.PI * g.Rg * g.Rg) * Math.exp(-R / g.Rg)) * 2 * Math.PI * R * dR;
+  }
+  return m;
+};
+
+type Setup = {
+  driverName: string;
+  driver: (g: number, u: number, v: number) => number;
+  kappa: number;
+  feedbackOn: "newton" | "caught" | "both";
+  local: boolean;
+  lambda: number;                                  // the caught-pair coupling
+};
+
+const solve = (gal: Galaxy, s: Setup, iters = 160) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let gT = new Float64Array(NOUT);
+
+  let wb = 1;                                        // the bulge is a source too
+  for (let it = 0; it < iters; it++) {
+    const gN = new Float64Array(NOUT), gC = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) {
+        a2 += r2[j] * m0[j] * (s.feedbackOn !== "caught" ? w[j] : 1);
+        a1 += r1[j] * m0[j] * (s.feedbackOn !== "newton" ? w[j] : 1);
+      }
+      gN[i] = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      gC[i] = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+    }
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) gTot[i] = gN[i] + s.lambda * gC[i];
+
+    const u = new Float64Array(NOUT); let acc = 0;
+    for (let i = NOUT - 1; i >= 0; i--) {
+      acc += gTot[i] * (i === NOUT - 1 ? 0.5 * KPC : ri[i + 1] - ri[i]);
+      u[i] = acc / (C * C);
+    }
+    const D = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++)
+      D[i] = s.driver(gTot[i], u[i], Math.sqrt(Math.max(0, gTot[i] * ri[i])) / C);
+
+    let Dbar = 0, ws = 0;
+    const onRing = new Float64Array(NR);
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      onRing[j] = D[k] * (1 - f) + D[k + 1] * f;
+      Dbar += onRing[j] * m0[j]; ws += m0[j];
+    }
+    Dbar /= ws;
+    for (let j = 0; j < NR; j++)
+      w[j] = 0.75 * w[j] + 0.25 / (1 + s.kappa * (s.local ? onRing[j] : Dbar));
+    // the bulge is made of emitters like everything else, so it is weakened
+    // too — leaving it out let it dominate at large kappa and dragged the
+    // whole scaling back to Newton's.
+    const Db = s.local ? D[0] : Dbar;
+    wb = 0.75 * wb + 0.25 / (1 + s.kappa * Db);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const MEAS = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+const idx = (rk: number) => Math.round(rk / 0.5) - 1;
+
+/** fit lambda so the Sun's speed is right, then score shape and BTFR slope */
+const score = (s: Omit<Setup, "lambda">) => {
+  let lo = 0, hi = 1e-24;
+  const at8 = (lam: number) => {
+    const g = solve(MW, { ...s, lambda: lam });
+    return kms(g[idx(8)], ri[idx(8)]);
+  };
+  while (at8(hi) < MEAS(8.122) && hi < 1e10) hi *= 4;
+  for (let i = 0; i < 34; i++) {
+    const mid = (lo + hi) / 2;
+    if (at8(mid) < MEAS(8.122)) lo = mid; else hi = mid;
+  }
+  const lambda = (lo + hi) / 2;
+
+  const g = solve(MW, { ...s, lambda });
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) {
+    ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++;
+  }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  // BTFR: flat speed vs baryonic mass across five decades
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f);
+    const gg = solve(gal, { ...s, lambda });
+    // "flat" speed: measured at 4 disc scale lengths, the usual convention
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    const M = (gal.Md + gal.Mg + gal.Mb) / MSUN;
+    pts.push([Math.log10(M), Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  const btfr = (nn * sxy - sx * sy) / (nn * sxx - sx * sx);   // d log M / d log v
+
+  return { lambda, shape, btfr };
+};
+
+
+/**
+ * THE MODEL'S OWN VELOCITY->MASS CONVERSION, which is a POWER LAW.
+ *
+ *     massFor(v) = LIGHT/v      so m ∝ 1/v, exactly — physics.ts
+ *
+ * The earlier tests used m/(1+κ·v/c), which SATURATES: past κv/c ≫ 1 it stops
+ * responding, which is why the exponent stalled. A power law never saturates.
+ * So: m_eff ∝ v^(−q), solved self-consistently, q scanned. q = 1 is the model's.
+ *
+ * The analytic expectation, for the caught pair's flat channel:
+ *     v² = λ·M_eff ∝ λ·N·v^(−q)   ⇒   v^(2+q) ∝ N   ⇒   BTFR slope = 2 + q
+ */
+
+const VREF = 200e3;                                // just sets λ's units
+
+const solveV = (gal: Galaxy, q: number, lambda: number, iters = 240) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let wb = 1, gT = new Float64Array(NOUT);
+
+  for (let it = 0; it < iters; it++) {
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) { a2 += r2[j] * m0[j] * w[j]; a1 += r1[j] * m0[j] * w[j]; }
+      const gN = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      const gC = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+      gTot[i] = gN + lambda * gC;
+    }
+    const v = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) v[i] = Math.sqrt(Math.max(1e-30, gTot[i] * ri[i]));
+
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      const vj = v[k] * (1 - f) + v[k + 1] * f;
+      w[j] = 0.85 * w[j] + 0.15 * Math.pow(Math.max(vj, 1e3) / VREF, -q);
+    }
+    wb = 0.85 * wb + 0.15 * Math.pow(Math.max(v[0], 1e3) / VREF, -q);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const scoreV = (q: number) => {
+  const at8 = (lam: number) => kms(solveV(MW, q, lam)[idx(8)], ri[idx(8)]);
+  let lo = 0, hi = 1e-30;
+  while (at8(hi) < MEAS(8.122) && hi < 1e12) hi *= 4;
+  for (let i = 0; i < 40; i++) { const m = (lo + hi) / 2; if (at8(m) < MEAS(8.122)) lo = m; else hi = m; }
+  const lambda = (lo + hi) / 2;
+
+  const g = solveV(MW, q, lambda);
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) { ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++; }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f), gg = solveV(gal, q, lambda);
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    pts.push([Math.log10((gal.Md + gal.Mg + gal.Mb) / MSUN),
+              Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  return { lambda, shape, btfr: (nn * sxy - sx * sy) / (nn * sxx - sx * sx), g };
+};
+
+console.log("THE SIGN THAT DECIDES IT");
+console.log("=".repeat(70));
+console.log("  massFor(v) = c/v is a COST per step (>= 1). The emission side is a");
+console.log("  RATE (<= 1), X = 1/m ticks between pulses. physics.ts calls this");
+console.log("  'once a tick is the ceiling, which TURNS THE IDENTITY ROUND'.");
+console.log("  If the emission rate is m, source ~ 1/v (q=+1). If it is 1/m,");
+console.log("  source ~ v (q=-1). Everything turns on which.\n");
+console.log("      q     reading                          shape    BTFR");
+for (const [q,tag] of [[1,"rate = m,   source ~ 1/v"],[0,"no feedback"],
+                       [-1,"rate = 1/m, source ~ v"]] as [number,string][]) {
+  const r = scoreV(q);
+  console.log(`  ${q.toFixed(0).padStart(5)}    ${tag.padEnd(30)}  ${r.shape.toFixed(1).padStart(5)}%  ${r.btfr.toFixed(2).padStart(6)}`);
+}
+console.log("\n  measured: shape ~0, BTFR 3.85 +/- 0.09");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sne.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sne.ts
new file mode 100644
index 0000000..15fe005
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sne.ts
@@ -0,0 +1,51 @@
+/**
+ * The supernova test done properly: the absolute magnitude M is a nuisance
+ * parameter, so a CONSTANT offset in mu is free and only the SHAPE counts.
+ * Melia's R_h = ct papers lean on exactly this. So marginalise it out and see
+ * what is left.
+ */
+const C = 2.99792458e8, MPC = 3.0856775814913673e22;
+const H = (k: number) => k * 1e3 / MPC;
+
+const dl_coast = (z: number, h: number) => (C / H(h)) * (1 + z) * Math.log(1 + z);
+const dl_lcdm = (z: number, h: number, om = 0.315) => {
+  const N = 4000; let acc = 0;
+  for (let i = 0; i < N; i++) {
+    const zz = z * (i + 0.5) / N;
+    acc += 1 / Math.sqrt(om * Math.pow(1 + zz, 3) + (1 - om));
+  }
+  return (C / H(h)) * (1 + z) * acc * (z / N);
+};
+const mu = (d: number) => 5 * Math.log10(d / (10 * 3.0857e16));
+
+// A Pantheon+-like redshift distribution: most of the weight low, a tail out
+// to z ~ 2. Weights are counts per bin, roughly.
+const BINS: [number, number][] = [
+  [0.02, 180], [0.05, 300], [0.08, 260], [0.12, 220], [0.18, 190],
+  [0.25, 160], [0.35, 140], [0.45, 110], [0.6, 90], [0.8, 60],
+  [1.0, 35], [1.3, 18], [1.6, 9], [2.0, 4],
+];
+
+for (const hCoast of [70.9, 63.0, 67.0, 74.0]) {
+  const d = BINS.map(([z, w]) => ({
+    z, w, diff: mu(dl_coast(z, hCoast)) - mu(dl_lcdm(z, 70.9)),
+  }));
+  const W = d.reduce((a, b) => a + b.w, 0);
+  const off = d.reduce((a, b) => a + b.w * b.diff, 0) / W;      // best constant M
+  const res = d.map(b => b.diff - off);
+  const rms = Math.sqrt(d.reduce((a, b, i) => a + b.w * res[i] * res[i], 0) / W);
+  const span = Math.max(...res) - Math.min(...res);
+  console.log(`coasting H0 = ${hCoast}   best M offset ${off.toFixed(3)} mag   ` +
+    `weighted rms ${rms.toFixed(4)}   peak-to-peak ${span.toFixed(3)}`);
+  if (hCoast === 70.9 || hCoast === 63.0) {
+    console.log("     z      residual after marginalising M");
+    d.forEach((b, i) => console.log(`   ${b.z.toFixed(2)}    ` +
+      `${(res[i] >= 0 ? "+" : "") + res[i].toFixed(3)}`));
+  }
+}
+
+console.log();
+console.log("For scale: Pantheon+ per-bin uncertainties are ~0.02-0.03 mag, and");
+console.log("the acceleration discovery itself was a ~0.20 mag effect.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/spacing.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/spacing.ts
new file mode 100644
index 0000000..d3a5217
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/spacing.ts
@@ -0,0 +1,38 @@
+/**
+ * THE EMPTY SPACE BETWEEN TWO BODIES IS A LENGTH, NOT A VOLUME.
+ *
+ * "More pull if there is more empty space between them" — the space between two
+ * bodies is measured ALONG THE LINE joining them, so the emptiness that matters
+ * is the mean SPACING, rho^(-1/3), and not the density itself. Then
+ *
+ *     a0 = (c.H / 2pi) . (spacing / spacing_0)
+ *
+ * and in a coasting universe both factors are fixed by the epoch:
+ *
+ *     H       ∝ (1+z)          the frontier: H = 1/t, and 1+z = t0/t
+ *     spacing ∝ (1+z)^-1       rho ∝ (1+z)^3, so rho^(-1/3) ∝ (1+z)^-1
+ *
+ * THE TWO CANCEL EXACTLY.
+ */
+const C=2.99792458e8, MPC=3.0856775814913673e22;
+const H0=70.9e3/MPC, A0=C*H0/(2*Math.PI);
+console.log("a0(z) = c.H(z)/2pi . (spacing(z)/spacing(0))\n");
+console.log("     z     H/H0     spacing/spacing_0    a0(z)/a0(0)      a0(z)");
+for (const z of [0,0.5,1,1.5,2,2.5,4]) {
+  const h=1+z, sp=1/(1+z);
+  console.log(`   ${z.toFixed(1)}    ${h.toFixed(2).padStart(5)}    ${sp.toFixed(3).padStart(12)}` +
+    `      ${(h*sp).toFixed(4).padStart(9)}     ${(A0*h*sp).toExponential(3)}`);
+}
+console.log("\n  EXACTLY CONSTANT. The clock speeds up and the spacing shrinks by");
+console.log("  the same factor, so a0 does not move — which is what the data say.");
+console.log();
+console.log("  and the value it fixes:");
+console.log(`     a0 = c.H0/2pi = ${A0.toExponential(3)} m/s^2`);
+console.log(`     measured      = 1.200e-10          ratio ${(A0/1.2e-10).toFixed(3)}`);
+console.log();
+console.log("  So the Genzel discs see the SAME a0 we do, ordinary-MOND-like,");
+console.log("  and every boost in that test falls back to the s=0 column:");
+console.log("     1.112  1.083  1.077  1.101  1.019   against an allowed 1.12");
+console.log("  which ALL PASS.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/speedloop.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/speedloop.ts
new file mode 100644
index 0000000..a421b8f
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/speedloop.ts
@@ -0,0 +1,111 @@
+/**
+ * THE LOOP WITH SPEED AS THE DRIVER — which is the model's own rule and not the
+ * one Test E used.
+ *
+ *   accelerates → goes faster → moves on more ticks, updates on fewer →
+ *   ticks less → IS lighter → pulls less → accelerates less.
+ *
+ * Self-limiting, same as Test E. But the EXPONENT is not the same, and that is
+ * the whole of it. Test E's driver was the fold, which goes linearly with the
+ * source. Speed does not: v² = GM/r, so v ∝ √M. The fixed point
+ *
+ *     M_eff = N / (1 + κ·M_eff^p)      ⇒      M_eff ∝ N^(1/(1+p))
+ *
+ * takes p from the driver, and p = ½ where Test E had p = 1.
+ */
+
+const C = 2.99792458e8, G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19;
+
+/** solve v² = G·M_eff/r with M_eff = N/(1 + v/c), by iteration */
+const speedFixed = (N: number, r: number) => {
+  let M = N;
+  for (let i = 0; i < 20000; i++) {
+    const v = Math.sqrt(G * M / r);
+    M = 0.5 * M + 0.5 * N / (1 + v / C);
+  }
+  return M;
+};
+
+/** and the same loop with the FOLD as driver, for the comparison */
+const foldFixed = (N: number, r: number) => {
+  let M = N;
+  for (let i = 0; i < 20000; i++) M = 0.5 * M + 0.5 * N / (1 + G * M / (r * C * C));
+  return M;
+};
+
+console.log("=".repeat(74));
+console.log("1. THE EXPONENT EACH DRIVER GIVES");
+console.log("=".repeat(74));
+console.log("  measured deep in the strong regime, over six decades of N");
+console.log();
+const r = 1e3;                       // small r, to reach the strong regime
+for (const [name, f] of [["speed, v ∝ √M   (p = ½)", speedFixed],
+                         ["fold,  u ∝ M    (p = 1)", foldFixed]] as
+                        [string, (n: number, r: number) => number][]) {
+  const a = f(1e30, r), b = f(1e36, r);
+  console.log(`  ${name}   exponent = ${(Math.log(b / a) / Math.log(1e6)).toFixed(4)}` +
+    `   (predicted ${name.includes("½") ? (2 / 3).toFixed(4) : (0.5).toFixed(4)})`);
+}
+
+console.log();
+console.log("=".repeat(74));
+console.log("2. AND WHAT EACH EXPONENT DOES TO TULLY-FISHER");
+console.log("=".repeat(74));
+console.log("  With the caught pair's 1/R law, v² ∝ M_eff, so M_eff ∝ M^e gives");
+console.log("  v⁴ ∝ M^2e, i.e. M ∝ v^(2/e). Measured slope 3.85 ± 0.09.");
+console.log();
+console.log("     driver                 e       BTFR slope   off by");
+for (const [name, e] of [
+  ["bilinear, no feedback", 1],
+  ["SPEED  (v ∝ √M)", 2 / 3],
+  ["FOLD   (u ∝ M)", 1 / 2],
+] as [string, number][]) {
+  const slope = 2 / e;
+  console.log(`  ${name.padEnd(24)} ${e.toFixed(3)}   ${slope.toFixed(2).padStart(8)}     ` +
+    `${(Math.abs(slope - 3.85) / 0.09).toFixed(1)}σ`);
+}
+console.log();
+console.log("  So the two readings of the same chain are distinguishable, and the");
+console.log("  data picks one: the driver has to scale LINEARLY with the source.");
+console.log("  Speed does not, because v ∝ √M — the square root is already spent.");
+
+console.log();
+console.log("=".repeat(74));
+console.log("3. AND HOW BIG THE SPEED EFFECT ACTUALLY IS");
+console.log("=".repeat(74));
+console.log("  v/c is the whole size of it. The loop only bites at v/c ~ 1.");
+console.log();
+console.log("     place                    v (km/s)     v/c        M_eff/M");
+for (const [name, v] of [
+  ["the Earth's orbit", 29.78e3],
+  ["the Sun round the Galaxy", 229e3],
+  ["the Galaxy's outskirts", 190e3],
+  ["a galaxy cluster", 1000e3],
+] as [string, number][]) {
+  console.log(`  ${name.padEnd(26)} ${(v / 1e3).toFixed(0).padStart(7)}   ` +
+    `${(v / C).toExponential(2)}   ${(1 / (1 + v / C)).toFixed(9)}`);
+}
+console.log();
+console.log("  7.6e-4 at the Sun's orbit. The feedback is real and it is three to");
+console.log("  four orders too weak to bend a rotation curve, before the exponent");
+console.log("  question is even reached.");
+
+console.log();
+console.log("=".repeat(74));
+console.log("4. WHAT IT DOES TO THE MILKY WAY, RUN RATHER THAN ESTIMATED");
+console.log("=".repeat(74));
+const M_MW = 6.2e10 * MSUN;
+console.log("     r (kpc)   Newton    with the speed loop   difference");
+for (const rk of [2, 8, 15, 30]) {
+  const rr = rk * KPC;
+  const vN = Math.sqrt(G * M_MW / rr);
+  const vF = Math.sqrt(G * speedFixed(M_MW, rr) / rr);
+  console.log(`  ${String(rk).padStart(8)}   ${(vN / 1e3).toFixed(2).padStart(7)}   ` +
+    `${(vF / 1e3).toFixed(2).padStart(14)}   ${((vF / vN - 1) * 100).toFixed(4)}%`);
+}
+console.log();
+console.log("  It makes the curve slower by four hundredths of a percent, where");
+console.log("  the discrepancy is a factor of two. The sign is right and nothing");
+console.log("  else is.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/steps.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/steps.ts
new file mode 100644
index 0000000..0a5f6f6
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/steps.ts
@@ -0,0 +1,128 @@
+/**
+ * THE PREDICTION THE ANISOTROPY MAKES, AND WHETHER IT FIXES GENZEL.
+ *
+ * The projection is a STEP function of the occupancy, because the lattice has
+ * only three distinct direction cosines. So a galaxy does not cross a step —
+ * but a galaxy is not the whole of anything. Far enough out the occupancy DOES
+ * cross, and when it does the effective a₀ jumps by a fixed ratio.
+ *
+ * That is a discontinuity in a rotation curve at a computable radius, which no
+ * other theory predicts and which nothing else in this file has offered.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const A0 = C * (70.9e3 / 3.0856775814913673e22) / (2 * Math.PI);
+
+// the lattice's 26 exits and the projection with a forward cone shut
+const dirs: [number, number, number][] = [];
+for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+  if (x || y || z) dirs.push([x, y, z]);
+const proj = (cut: number) => {
+  let s = 0, n = 0;
+  for (const v of dirs) {
+    const m = Math.hypot(v[0], v[1], v[2]), uz = v[2] / m;
+    if (uz > cut) continue;
+    s += Math.abs(uz); n++;
+  }
+  return s / n;
+};
+const P_ISO = proj(1.01);
+
+console.log("=".repeat(76));
+console.log("1. WHERE THE STEPS ARE");
+console.log("=".repeat(76));
+console.log("  the cone shut at cos θ = 1, 1/√2, 1/√3, 0 — four plateaus:\n");
+const CUTS = [1.01, 0.9, 0.65, 0.3];
+for (const c of CUTS) {
+  console.log(`     cut ${c === 1.01 ? "none " : c.toFixed(2)}   P = ${proj(c).toFixed(4)}   ` +
+    `P/P_iso = ${(proj(c) / P_ISO).toFixed(4)}`);
+}
+console.log();
+console.log("  the shut fraction rises with occupancy θ = g/a₀, so the steps sit");
+console.log("  at the θ where the cone crosses 1/√2 = 0.7071 and 1/√3 = 0.5774:");
+console.log();
+// cut(θ) = 1 − 2·θ/(1+θ)  →  θ = (1−cut)/(1+cut)
+const thetaAt = (cut: number) => (1 - cut) / (1 + cut);
+for (const c of [Math.SQRT1_2, 1 / Math.sqrt(3), 0]) {
+  console.log(`     cone reaches cos = ${c.toFixed(4)}   at θ = g/a₀ = ${thetaAt(c).toFixed(4)}`);
+}
+
+console.log();
+console.log("=".repeat(76));
+console.log("2. AND AT WHAT RADIUS, FOR A REAL GALAXY");
+console.log("=".repeat(76));
+console.log("  deep regime: g = √(g_N a₀), so θ = g/a₀ gives g_N = θ²a₀");
+console.log("  and r = √(GM/g_N) for baryonic M.\n");
+console.log("     galaxy              M_bar        θ=0.172      θ=0.268");
+for (const [nm, M] of [
+  ["the Milky Way", 6.2e10 * MSUN],
+  ["a big spiral, 3×MW", 1.9e11 * MSUN],
+  ["a dwarf, M/30", 2.1e9 * MSUN],
+] as [string, number][]) {
+  const rAt = (th: number) => Math.sqrt(G * M / (th * th * A0)) / KPC;
+  console.log(`   ${nm.padEnd(20)} ${(M / MSUN).toExponential(1)}   ` +
+    `${rAt(0.172).toFixed(0).padStart(6)} kpc   ${rAt(0.268).toFixed(0).padStart(6)} kpc`);
+}
+console.log();
+console.log("  For the Milky Way both steps land in the range stellar streams and");
+console.log("  satellites already probe — 30 to 90 kpc. That is not a thought");
+console.log("  experiment, it is where the Sagittarius stream lives.");
+
+console.log();
+console.log("=".repeat(76));
+console.log("3. HOW BIG IS THE JUMP");
+console.log("=".repeat(76));
+console.log("  v ∝ a₀^¼ in the deep regime, so a step in a₀ of ratio ρ gives ρ^¼\n");
+console.log("     step                 a₀ ratio   v jump    at 200 km/s");
+const plate = [P_ISO, proj(0.9), proj(0.65), proj(0.3)];
+for (let i = 1; i < plate.length; i++) {
+  const r = plate[i] / plate[i - 1];
+  console.log(`     plateau ${i} → ${i + 1}        ${r.toFixed(4)}    ` +
+    `${((Math.pow(r, 0.25) - 1) * 100).toFixed(2)}%    ${(200 * (Math.pow(r, 0.25) - 1)).toFixed(1)} km/s`);
+}
+console.log();
+console.log("  A few km/s, sharp, at a computable radius. Small — but it is a");
+console.log("  DISCONTINUITY, and nothing else predicts one anywhere.");
+
+console.log();
+console.log("=".repeat(76));
+console.log("4. AND WHETHER THE ANISOTROPY FIXES GENZEL");
+console.log("=".repeat(76));
+console.log("  Genzel's discs are DENSE — high θ — so they sit on the most-shut");
+console.log("  plateau, where a₀ is smallest and the boost least. The Milky Way's");
+console.log("  outskirts are thin and sit on a less-shut one. The two are being");
+console.log("  asked for different a₀, and the lattice supplies exactly that.\n");
+type HZ = { name: string; z: number; logMs: number; fgas: number; Re: number };
+const D: HZ[] = [
+  { name: "COS4_01351", z: 0.854, logMs: 11.07, fgas: 0.35, Re: 8.2 },
+  { name: "D3a_6397", z: 1.500, logMs: 11.07, fgas: 0.45, Re: 7.4 },
+  { name: "GS4_43501", z: 1.613, logMs: 10.71, fgas: 0.50, Re: 4.9 },
+  { name: "zC_406690", z: 2.196, logMs: 10.62, fgas: 0.55, Re: 5.5 },
+  { name: "zC_400569", z: 2.242, logMs: 11.07, fgas: 0.45, Re: 3.3 },
+];
+const gHZ = (d: HZ) => G * (Math.pow(10, d.logMs) * MSUN / (1 - d.fgas)) / Math.pow(d.Re * KPC, 2);
+const solve = (gN: number) => {
+  let g = gN + A0;
+  for (let k = 0; k < 500; k++) {
+    const th = g / A0;
+    const cut = 1 - 2 * Math.min(th / (1 + th), 0.5);
+    const P = proj(cut) / P_ISO;
+    g = 0.5 * g + 0.5 * (gN / 2 + Math.sqrt(gN * gN / 4 + gN * A0 * P));
+  }
+  return g;
+};
+console.log("     galaxy          θ      plateau   boost   allowed 1.12");
+let worst = 0;
+for (const d of D) {
+  const gN = gHZ(d), g = solve(gN), th = g / A0;
+  const cut = 1 - 2 * Math.min(th / (1 + th), 0.5);
+  const b = Math.sqrt(g / gN);
+  worst = Math.max(worst, b);
+  console.log(`   ${d.name.padEnd(14)} ${th.toFixed(2).padStart(5)}   ` +
+    `${(proj(cut) / P_ISO).toFixed(4)}   ${b.toFixed(3)}   ${b < 1.12 ? "pass" : "FAIL"}`);
+}
+console.log(`\n     worst = ${worst.toFixed(3)}, margin to 1.12 = ${(1.12 - worst).toFixed(3)}`);
+console.log(`     isotropic gave 1.112, margin 0.008 — the anisotropy widens it`);
+console.log(`     by ${((1.12 - worst) / 0.008).toFixed(1)}×.`);
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/three.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/three.ts
new file mode 100644
index 0000000..2a58351
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/three.ts
@@ -0,0 +1,72 @@
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const A0 = 1.2e-10, GPC = 3.0857e25, LAM = 1.55 * GPC;
+
+const DISK = { M: 5.0e10 * MSUN, Rd: 2.6 * KPC, h: 0.30 * KPC };
+const GAS = { M: 1.2e10 * MSUN, Rd: 7.0 * KPC, h: 0.15 * KPC };
+const BULGE = { M: 0.9e10 * MSUN, a: 0.5 * KPC };
+type Disc = typeof DISK;
+
+const sigma = (d: Disc, R: number) => d.M / (2 * Math.PI * d.Rd * d.Rd) * Math.exp(-R / d.Rd);
+const discPull = (d: Disc, r: number, NR = 600, NP = 600) => {
+  const RMAX = 14 * d.Rd; let inside = 0, outside = 0;
+  for (let i = 0; i < NR; i++) {
+    const R = RMAX * (i + 0.5) / NR, dR = RMAX / NR;
+    const s = sigma(d, R) * R * dR; let acc = 0;
+    for (let j = 0; j < NP; j++) {
+      const p = 2 * Math.PI * (j + 0.5) / NP;
+      const dx = R * Math.cos(p) - r, dy = R * Math.sin(p);
+      const s2 = dx * dx + dy * dy + d.h * d.h;
+      acc += dx / Math.pow(s2, 1.5);
+    }
+    const bit = -G * s * acc * (2 * Math.PI / NP);
+    if (R < r) inside += bit; else outside += bit;
+  }
+  return { inside, outside };
+};
+const bulgePull = (r: number) => G * BULGE.M / Math.pow(r + BULGE.a, 2);
+const gN = (r: number) => {
+  const a = discPull(DISK, r), b = discPull(GAS, r);
+  return a.inside + a.outside + b.inside + b.outside + bulgePull(r);
+};
+const v = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+const eilers = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+/** MOND, "simple" interpolation — the one that actually fits */
+const mond = (g: number) => g / 2 + Math.sqrt(g * g / 4 + g * A0);
+
+console.log(" r    v_N     v_MOND  v_obs   (v_o/v_N)^2-1   GR frac    carry frac   reach frac");
+for (const rk of [1, 2, 3, 5, 8, 10, 12, 15, 17, 20, 25, 30]) {
+  const r = rk * KPC, g = gN(r);
+  const vN = v(g, r), vM = v(mond(g), r), vO = eilers(rk);
+  const gr = g * r / (C * C);                         // v²/c², the 1PN size
+  const carry = 2 * g * r / (C * C);
+  const x = r / LAM, reach = Math.exp(-x) * (1 + x) - 1;
+  console.log(
+    ` ${String(rk).padStart(2)}  ${vN.toFixed(1).padStart(6)}  ${vM.toFixed(1).padStart(6)}  ` +
+    `${vO.toFixed(1).padStart(6)}  ${((vO / vN) ** 2 - 1).toFixed(3).padStart(8)}      ` +
+    `${gr.toExponential(2)}  ${carry.toExponential(2)}   ${reach.toExponential(2)}`);
+}
+
+console.log("\npeaks / extents for label placement:");
+const scan = (f: (r: number) => number, lo = 0.5, hi = 30) => {
+  let best = -1e9, bestR = 0;
+  for (let rk = lo; rk <= hi; rk += 0.125) { const y = f(rk * KPC); if (y > best) { best = y; bestR = rk; } }
+  return `max ${best.toFixed(1)} at ${bestR} kpc`;
+};
+console.log("  stars ", scan(r => { const a = discPull(DISK, r); return v(a.inside + a.outside, r); }));
+console.log("  gas   ", scan(r => { const a = discPull(GAS, r); return v(a.inside + a.outside, r); }));
+console.log("  bulge ", scan(r => v(bulgePull(r), r)));
+console.log("  newton", scan(r => v(gN(r), r)));
+console.log("  mond  ", scan(r => v(mond(gN(r)), r)));
+console.log("\nvalues at a few radii for each component (km/s):");
+for (const rk of [2, 5, 8, 12, 16, 20, 24, 28]) {
+  const r = rk * KPC;
+  const a = discPull(DISK, r), b = discPull(GAS, r);
+  console.log(`  ${String(rk).padStart(2)}  stars ${v(a.inside + a.outside, r).toFixed(1).padStart(5)}` +
+    `  gas ${v(b.inside + b.outside, r).toFixed(1).padStart(5)}` +
+    `  bulge ${v(bulgePull(r), r).toFixed(1).padStart(5)}` +
+    `  newton ${v(gN(r), r).toFixed(1).padStart(5)}` +
+    `  mond ${v(mond(gN(r)), r).toFixed(1).padStart(5)}` +
+    `  obs ${eilers(rk).toFixed(1)}`);
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/transport.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/transport.ts
new file mode 100644
index 0000000..7043a4c
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/transport.ts
@@ -0,0 +1,334 @@
+/**
+ * THE PERMUTATION SEARCH, on a fully relaxed galaxy.
+ *
+ * Part 2 established something that reframes the whole thing: A FEEDBACK THAT
+ * WEAKENS THE SOURCE CAN ONLY LOWER A ROTATION CURVE. It cannot supply missing
+ * gravity at any coupling, for any driver. So the feedback is not the dark
+ * matter — it can only be the thing that fixes HOW an excess scales with mass,
+ * and something else has to supply the excess.
+ *
+ * Which means the honest object to test is the PAIR: the caught pair's 1/R
+ * channel supplying the excess, and the feedback setting its mass scaling. Two
+ * requirements, and they must be met at once:
+ *
+ *     SHAPE   one galaxy's rotation curve, against Gaia
+ *     SCALING the Tully–Fisher slope across five decades of galaxy mass
+ *
+ * Everything is permuted: which driver, which channel the feedback acts on,
+ * whether the driver is read locally or averaged over the body. One coupling is
+ * fitted per permutation (at the Sun) and nothing else.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const A0 = 1.2e-10;
+
+const NR = 220, RMAX = 70 * KPC;
+const Rj = Array.from({ length: NR }, (_, j) => RMAX * (j + 0.5) / NR);
+const dR = RMAX / NR;
+const NOUT = 70;                                   // out to 35 kpc
+const ri = Array.from({ length: NOUT }, (_, i) => (i + 1) * 0.5 * KPC);
+const H = 0.30 * KPC;
+
+const kernel = (p: number) => {
+  const NP = 300;
+  const K: Float64Array[] = [];
+  for (let i = 0; i < NOUT; i++) {
+    const row = new Float64Array(NR), r = ri[i];
+    for (let j = 0; j < NR; j++) {
+      const R = Rj[j]; let acc = 0;
+      for (let q = 0; q < NP; q++) {
+        const ph = 2 * Math.PI * (q + 0.5) / NP;
+        const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+        const d2 = dx * dx + dy * dy + H * H;
+        acc += dx / Math.pow(d2, (p + 1) / 2);
+      }
+      row[j] = -acc / NP;
+    }
+    K.push(row);
+  }
+  return K;
+};
+console.log("precomputing kernels…");
+const K2 = kernel(2), K1 = kernel(1);
+console.log("done.\n");
+
+type Galaxy = { Md: number; Rd: number; Mg: number; Rg: number; Mb: number; ab: number };
+const MW: Galaxy = {
+  Md: 5.0e10 * MSUN, Rd: 2.6 * KPC, Mg: 1.2e10 * MSUN, Rg: 7.0 * KPC,
+  Mb: 0.9e10 * MSUN, ab: 0.5 * KPC,
+};
+
+/** a family of galaxies: mass scaled, size following the observed R ∝ M^0.35 */
+const scaled = (f: number): Galaxy => ({
+  Md: MW.Md * f, Rd: MW.Rd * Math.pow(f, 0.35),
+  Mg: MW.Mg * f, Rg: MW.Rg * Math.pow(f, 0.35),
+  Mb: MW.Mb * f, ab: MW.ab * Math.pow(f, 0.35),
+});
+
+const ringMass = (g: Galaxy) => {
+  const m = new Float64Array(NR);
+  for (let j = 0; j < NR; j++) {
+    const R = Rj[j];
+    m[j] = (g.Md / (2 * Math.PI * g.Rd * g.Rd) * Math.exp(-R / g.Rd)
+      + g.Mg / (2 * Math.PI * g.Rg * g.Rg) * Math.exp(-R / g.Rg)) * 2 * Math.PI * R * dR;
+  }
+  return m;
+};
+
+type Setup = {
+  driverName: string;
+  driver: (g: number, u: number, v: number) => number;
+  kappa: number;
+  feedbackOn: "newton" | "caught" | "both";
+  local: boolean;
+  lambda: number;                                  // the caught-pair coupling
+};
+
+const solve = (gal: Galaxy, s: Setup, iters = 160) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let gT = new Float64Array(NOUT);
+
+  let wb = 1;                                        // the bulge is a source too
+  for (let it = 0; it < iters; it++) {
+    const gN = new Float64Array(NOUT), gC = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) {
+        a2 += r2[j] * m0[j] * (s.feedbackOn !== "caught" ? w[j] : 1);
+        a1 += r1[j] * m0[j] * (s.feedbackOn !== "newton" ? w[j] : 1);
+      }
+      gN[i] = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      gC[i] = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+    }
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) gTot[i] = gN[i] + s.lambda * gC[i];
+
+    const u = new Float64Array(NOUT); let acc = 0;
+    for (let i = NOUT - 1; i >= 0; i--) {
+      acc += gTot[i] * (i === NOUT - 1 ? 0.5 * KPC : ri[i + 1] - ri[i]);
+      u[i] = acc / (C * C);
+    }
+    const D = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++)
+      D[i] = s.driver(gTot[i], u[i], Math.sqrt(Math.max(0, gTot[i] * ri[i])) / C);
+
+    let Dbar = 0, ws = 0;
+    const onRing = new Float64Array(NR);
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      onRing[j] = D[k] * (1 - f) + D[k + 1] * f;
+      Dbar += onRing[j] * m0[j]; ws += m0[j];
+    }
+    Dbar /= ws;
+    for (let j = 0; j < NR; j++)
+      w[j] = 0.75 * w[j] + 0.25 / (1 + s.kappa * (s.local ? onRing[j] : Dbar));
+    // the bulge is made of emitters like everything else, so it is weakened
+    // too — leaving it out let it dominate at large kappa and dragged the
+    // whole scaling back to Newton's.
+    const Db = s.local ? D[0] : Dbar;
+    wb = 0.75 * wb + 0.25 / (1 + s.kappa * Db);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const MEAS = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+const idx = (rk: number) => Math.round(rk / 0.5) - 1;
+
+/** fit lambda so the Sun's speed is right, then score shape and BTFR slope */
+const score = (s: Omit<Setup, "lambda">) => {
+  let lo = 0, hi = 1e-24;
+  const at8 = (lam: number) => {
+    const g = solve(MW, { ...s, lambda: lam });
+    return kms(g[idx(8)], ri[idx(8)]);
+  };
+  while (at8(hi) < MEAS(8.122) && hi < 1e10) hi *= 4;
+  for (let i = 0; i < 34; i++) {
+    const mid = (lo + hi) / 2;
+    if (at8(mid) < MEAS(8.122)) lo = mid; else hi = mid;
+  }
+  const lambda = (lo + hi) / 2;
+
+  const g = solve(MW, { ...s, lambda });
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) {
+    ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++;
+  }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  // BTFR: flat speed vs baryonic mass across five decades
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f);
+    const gg = solve(gal, { ...s, lambda });
+    // "flat" speed: measured at 4 disc scale lengths, the usual convention
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    const M = (gal.Md + gal.Mg + gal.Mb) / MSUN;
+    pts.push([Math.log10(M), Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  const btfr = (nn * sxy - sx * sy) / (nn * sxx - sx * sx);   // d log M / d log v
+
+  return { lambda, shape, btfr };
+};
+
+
+/**
+ * THE MODEL'S OWN VELOCITY->MASS CONVERSION, which is a POWER LAW.
+ *
+ *     massFor(v) = LIGHT/v      so m ∝ 1/v, exactly — physics.ts
+ *
+ * The earlier tests used m/(1+κ·v/c), which SATURATES: past κv/c ≫ 1 it stops
+ * responding, which is why the exponent stalled. A power law never saturates.
+ * So: m_eff ∝ v^(−q), solved self-consistently, q scanned. q = 1 is the model's.
+ *
+ * The analytic expectation, for the caught pair's flat channel:
+ *     v² = λ·M_eff ∝ λ·N·v^(−q)   ⇒   v^(2+q) ∝ N   ⇒   BTFR slope = 2 + q
+ */
+
+const VREF = 200e3;                                // just sets λ's units
+
+const solveV = (gal: Galaxy, q: number, lambda: number, iters = 240) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let wb = 1, gT = new Float64Array(NOUT);
+
+  for (let it = 0; it < iters; it++) {
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) { a2 += r2[j] * m0[j] * w[j]; a1 += r1[j] * m0[j] * w[j]; }
+      const gN = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      const gC = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+      gTot[i] = gN + lambda * gC;
+    }
+    const v = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) v[i] = Math.sqrt(Math.max(1e-30, gTot[i] * ri[i]));
+
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      const vj = v[k] * (1 - f) + v[k + 1] * f;
+      w[j] = 0.85 * w[j] + 0.15 * Math.pow(Math.max(vj, 1e3) / VREF, -q);
+    }
+    wb = 0.85 * wb + 0.15 * Math.pow(Math.max(v[0], 1e3) / VREF, -q);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const scoreV = (q: number) => {
+  const at8 = (lam: number) => kms(solveV(MW, q, lam)[idx(8)], ri[idx(8)]);
+  let lo = 0, hi = 1e-30;
+  while (at8(hi) < MEAS(8.122) && hi < 1e12) hi *= 4;
+  for (let i = 0; i < 40; i++) { const m = (lo + hi) / 2; if (at8(m) < MEAS(8.122)) lo = m; else hi = m; }
+  const lambda = (lo + hi) / 2;
+
+  const g = solveV(MW, q, lambda);
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) { ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++; }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f), gg = solveV(gal, q, lambda);
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    pts.push([Math.log10((gal.Md + gal.Mg + gal.Mb) / MSUN),
+              Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  return { lambda, shape, btfr: (nn * sxy - sx * sy) / (nn * sxx - sx * sx), g };
+};
+
+
+/**
+ * THE TRANSPORT ROUTE, AT GALAXY SCALE — which the file derived and never ran
+ * on a galaxy.
+ *
+ *     v_carrier = c·min(1, n/n_c)      the budget, sign fixed by `inStep`
+ *     Φ = 4πr²·n·v = const             flux conservation
+ *
+ *   dense  v = c        ⇒ n ∝ 1/r²  ⇒ g ∝ 1/r²      Newton
+ *   thin   v = c·n/n_c  ⇒ n ∝ 1/r   ⇒ g = √(g_N·g_c) MOND, and √M for free
+ *
+ * The √M is not in the source at all — flux conservation goes QUADRATIC in n
+ * once v ∝ n. Which is the non-linearity the theorem demanded.
+ */
+const transport = (gN: number, gc: number) => gN / 2 + Math.sqrt(gN * gN / 4 + gN * gc);
+
+const scoreT = (gc: number) => {
+  const gNs = solveV(MW, 0, 0);
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) {
+    const v = Math.sqrt(transport(gNs[idx(rk)], gc) * ri[idx(rk)]) / 1e3;
+    ss += Math.pow(v / MEAS(rk) - 1, 2); n++;
+  }
+  const shape = 100 * Math.sqrt(ss / n);
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f), gg = solveV(gal, 0, 0);
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    pts.push([Math.log10((gal.Md + gal.Mg + gal.Mb) / MSUN),
+      Math.log10(Math.sqrt(transport(gg[k], gc) * ri[k]) / 1e3)]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  return { shape, btfr: (nn * sxy - sx * sy) / (nn * sxx - sx * sx) };
+};
+
+console.log("=".repeat(76));
+console.log("THE TRANSPORT ROUTE ON THE RELAXED GALAXY — never run before");
+console.log("=".repeat(76));
+console.log("  one constant, g_c, which the model claims to FIX rather than fit\n");
+console.log("     g_c (m/s²)     shape    BTFR slope");
+for (const gc of [0.5e-10, 1.0e-10, 1.2e-10, 1.5e-10, 2.0e-10]) {
+  const r = scoreT(gc);
+  const good = r.shape < 6 && Math.abs(r.btfr - 3.85) < 0.25;
+  console.log(`  ${gc.toExponential(2).padStart(11)}    ${r.shape.toFixed(1).padStart(5)}%  ` +
+    `${r.btfr.toFixed(2).padStart(8)}${good ? "   <<< PASSES BOTH" : ""}`);
+}
+
+console.log();
+console.log("  and what g_c the model's OWN n_c gives, with no fitting at all:");
+const MU_SI = 0.06235150 * 2.176434e-8, LP = 1.616255e-35;
+console.log("    n_c = (m/2π)³ in lattice units, g ∝ n with 4πG/SHEET = 0.097942");
+for (const [nm, mMeV] of [["electron", 0.511], ["29 MeV (what it wants)", 28.9],
+  ["muon", 105.66], ["pion", 134.98], ["proton", 938.26]] as [string, number][]) {
+  const m = mMeV * 1.78266192e-30 / MU_SI;            // in lattice mass units
+  const nc = Math.pow(m / (2 * Math.PI), 3);
+  const gc = nc * 0.097942 * (2.99792458e8 / 5.391247e-44) / 1e0;
+  console.log(`    ${nm.padEnd(24)} n_c = ${nc.toExponential(2)}`);
+}
+console.log();
+console.log("    the n_c the fit wants:   2.203e-61  →  29 MeV");
+console.log("    which is not a particle, and that is the whole bill.");
+
+console.log();
+console.log("=".repeat(76));
+console.log("SO THE TWO ROUTES, SIDE BY SIDE");
+console.log("=".repeat(76));
+const g1 = scoreV(1.0), t1 = scoreT(1.2e-10);
+console.log("     route                          shape    BTFR    what it owes");
+console.log(`     source feedback (test G)       ${g1.shape.toFixed(1)}%    ${g1.btfr.toFixed(2)}    a sign it cannot settle`);
+console.log(`     transport (inStep budget)      ${t1.shape.toFixed(1)}%    ${t1.btfr.toFixed(2)}    a 29 MeV emitter`);
+console.log(`     measured                        —      3.85`);
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/vmass.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/vmass.ts
new file mode 100644
index 0000000..47ec61f
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/vmass.ts
@@ -0,0 +1,275 @@
+/**
+ * THE PERMUTATION SEARCH, on a fully relaxed galaxy.
+ *
+ * Part 2 established something that reframes the whole thing: A FEEDBACK THAT
+ * WEAKENS THE SOURCE CAN ONLY LOWER A ROTATION CURVE. It cannot supply missing
+ * gravity at any coupling, for any driver. So the feedback is not the dark
+ * matter — it can only be the thing that fixes HOW an excess scales with mass,
+ * and something else has to supply the excess.
+ *
+ * Which means the honest object to test is the PAIR: the caught pair's 1/R
+ * channel supplying the excess, and the feedback setting its mass scaling. Two
+ * requirements, and they must be met at once:
+ *
+ *     SHAPE   one galaxy's rotation curve, against Gaia
+ *     SCALING the Tully–Fisher slope across five decades of galaxy mass
+ *
+ * Everything is permuted: which driver, which channel the feedback acts on,
+ * whether the driver is read locally or averaged over the body. One coupling is
+ * fitted per permutation (at the Sun) and nothing else.
+ */
+
+const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
+const A0 = 1.2e-10;
+
+const NR = 220, RMAX = 70 * KPC;
+const Rj = Array.from({ length: NR }, (_, j) => RMAX * (j + 0.5) / NR);
+const dR = RMAX / NR;
+const NOUT = 70;                                   // out to 35 kpc
+const ri = Array.from({ length: NOUT }, (_, i) => (i + 1) * 0.5 * KPC);
+const H = 0.30 * KPC;
+
+const kernel = (p: number) => {
+  const NP = 300;
+  const K: Float64Array[] = [];
+  for (let i = 0; i < NOUT; i++) {
+    const row = new Float64Array(NR), r = ri[i];
+    for (let j = 0; j < NR; j++) {
+      const R = Rj[j]; let acc = 0;
+      for (let q = 0; q < NP; q++) {
+        const ph = 2 * Math.PI * (q + 0.5) / NP;
+        const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
+        const d2 = dx * dx + dy * dy + H * H;
+        acc += dx / Math.pow(d2, (p + 1) / 2);
+      }
+      row[j] = -acc / NP;
+    }
+    K.push(row);
+  }
+  return K;
+};
+console.log("precomputing kernels…");
+const K2 = kernel(2), K1 = kernel(1);
+console.log("done.\n");
+
+type Galaxy = { Md: number; Rd: number; Mg: number; Rg: number; Mb: number; ab: number };
+const MW: Galaxy = {
+  Md: 5.0e10 * MSUN, Rd: 2.6 * KPC, Mg: 1.2e10 * MSUN, Rg: 7.0 * KPC,
+  Mb: 0.9e10 * MSUN, ab: 0.5 * KPC,
+};
+
+/** a family of galaxies: mass scaled, size following the observed R ∝ M^0.35 */
+const scaled = (f: number): Galaxy => ({
+  Md: MW.Md * f, Rd: MW.Rd * Math.pow(f, 0.35),
+  Mg: MW.Mg * f, Rg: MW.Rg * Math.pow(f, 0.35),
+  Mb: MW.Mb * f, ab: MW.ab * Math.pow(f, 0.35),
+});
+
+const ringMass = (g: Galaxy) => {
+  const m = new Float64Array(NR);
+  for (let j = 0; j < NR; j++) {
+    const R = Rj[j];
+    m[j] = (g.Md / (2 * Math.PI * g.Rd * g.Rd) * Math.exp(-R / g.Rd)
+      + g.Mg / (2 * Math.PI * g.Rg * g.Rg) * Math.exp(-R / g.Rg)) * 2 * Math.PI * R * dR;
+  }
+  return m;
+};
+
+type Setup = {
+  driverName: string;
+  driver: (g: number, u: number, v: number) => number;
+  kappa: number;
+  feedbackOn: "newton" | "caught" | "both";
+  local: boolean;
+  lambda: number;                                  // the caught-pair coupling
+};
+
+const solve = (gal: Galaxy, s: Setup, iters = 160) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let gT = new Float64Array(NOUT);
+
+  let wb = 1;                                        // the bulge is a source too
+  for (let it = 0; it < iters; it++) {
+    const gN = new Float64Array(NOUT), gC = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) {
+        a2 += r2[j] * m0[j] * (s.feedbackOn !== "caught" ? w[j] : 1);
+        a1 += r1[j] * m0[j] * (s.feedbackOn !== "newton" ? w[j] : 1);
+      }
+      gN[i] = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      gC[i] = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+    }
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) gTot[i] = gN[i] + s.lambda * gC[i];
+
+    const u = new Float64Array(NOUT); let acc = 0;
+    for (let i = NOUT - 1; i >= 0; i--) {
+      acc += gTot[i] * (i === NOUT - 1 ? 0.5 * KPC : ri[i + 1] - ri[i]);
+      u[i] = acc / (C * C);
+    }
+    const D = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++)
+      D[i] = s.driver(gTot[i], u[i], Math.sqrt(Math.max(0, gTot[i] * ri[i])) / C);
+
+    let Dbar = 0, ws = 0;
+    const onRing = new Float64Array(NR);
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      onRing[j] = D[k] * (1 - f) + D[k + 1] * f;
+      Dbar += onRing[j] * m0[j]; ws += m0[j];
+    }
+    Dbar /= ws;
+    for (let j = 0; j < NR; j++)
+      w[j] = 0.75 * w[j] + 0.25 / (1 + s.kappa * (s.local ? onRing[j] : Dbar));
+    // the bulge is made of emitters like everything else, so it is weakened
+    // too — leaving it out let it dominate at large kappa and dragged the
+    // whole scaling back to Newton's.
+    const Db = s.local ? D[0] : Dbar;
+    wb = 0.75 * wb + 0.25 / (1 + s.kappa * Db);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const MEAS = (rk: number) => 229.0 - 1.7 * (rk - 8.122);
+const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
+const idx = (rk: number) => Math.round(rk / 0.5) - 1;
+
+/** fit lambda so the Sun's speed is right, then score shape and BTFR slope */
+const score = (s: Omit<Setup, "lambda">) => {
+  let lo = 0, hi = 1e-24;
+  const at8 = (lam: number) => {
+    const g = solve(MW, { ...s, lambda: lam });
+    return kms(g[idx(8)], ri[idx(8)]);
+  };
+  while (at8(hi) < MEAS(8.122) && hi < 1e10) hi *= 4;
+  for (let i = 0; i < 34; i++) {
+    const mid = (lo + hi) / 2;
+    if (at8(mid) < MEAS(8.122)) lo = mid; else hi = mid;
+  }
+  const lambda = (lo + hi) / 2;
+
+  const g = solve(MW, { ...s, lambda });
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) {
+    ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++;
+  }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  // BTFR: flat speed vs baryonic mass across five decades
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f);
+    const gg = solve(gal, { ...s, lambda });
+    // "flat" speed: measured at 4 disc scale lengths, the usual convention
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    const M = (gal.Md + gal.Mg + gal.Mb) / MSUN;
+    pts.push([Math.log10(M), Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  const btfr = (nn * sxy - sx * sy) / (nn * sxx - sx * sx);   // d log M / d log v
+
+  return { lambda, shape, btfr };
+};
+
+
+/**
+ * THE MODEL'S OWN VELOCITY->MASS CONVERSION, which is a POWER LAW.
+ *
+ *     massFor(v) = LIGHT/v      so m ∝ 1/v, exactly — physics.ts
+ *
+ * The earlier tests used m/(1+κ·v/c), which SATURATES: past κv/c ≫ 1 it stops
+ * responding, which is why the exponent stalled. A power law never saturates.
+ * So: m_eff ∝ v^(−q), solved self-consistently, q scanned. q = 1 is the model's.
+ *
+ * The analytic expectation, for the caught pair's flat channel:
+ *     v² = λ·M_eff ∝ λ·N·v^(−q)   ⇒   v^(2+q) ∝ N   ⇒   BTFR slope = 2 + q
+ */
+
+const VREF = 200e3;                                // just sets λ's units
+
+const solveV = (gal: Galaxy, q: number, lambda: number, iters = 240) => {
+  const m0 = ringMass(gal);
+  const w = new Float64Array(NR).fill(1);
+  let wb = 1, gT = new Float64Array(NOUT);
+
+  for (let it = 0; it < iters; it++) {
+    const gTot = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) {
+      let a2 = 0, a1 = 0;
+      const r2 = K2[i], r1 = K1[i];
+      for (let j = 0; j < NR; j++) { a2 += r2[j] * m0[j] * w[j]; a1 += r1[j] * m0[j] * w[j]; }
+      const gN = G * a2 + wb * G * gal.Mb / Math.pow(ri[i] + gal.ab, 2);
+      const gC = a1 + wb * gal.Mb * ri[i] / Math.pow(ri[i] + gal.ab, 2);
+      gTot[i] = gN + lambda * gC;
+    }
+    const v = new Float64Array(NOUT);
+    for (let i = 0; i < NOUT; i++) v[i] = Math.sqrt(Math.max(1e-30, gTot[i] * ri[i]));
+
+    for (let j = 0; j < NR; j++) {
+      const x = Rj[j] / (0.5 * KPC) - 1;
+      const k = Math.max(0, Math.min(NOUT - 2, Math.floor(x)));
+      const f = Math.max(0, Math.min(1, x - k));
+      const vj = v[k] * (1 - f) + v[k + 1] * f;
+      w[j] = 0.85 * w[j] + 0.15 * Math.pow(Math.max(vj, 1e3) / VREF, -q);
+    }
+    wb = 0.85 * wb + 0.15 * Math.pow(Math.max(v[0], 1e3) / VREF, -q);
+    gT = gTot;
+  }
+  return gT;
+};
+
+const scoreV = (q: number) => {
+  const at8 = (lam: number) => kms(solveV(MW, q, lam)[idx(8)], ri[idx(8)]);
+  let lo = 0, hi = 1e-30;
+  while (at8(hi) < MEAS(8.122) && hi < 1e12) hi *= 4;
+  for (let i = 0; i < 40; i++) { const m = (lo + hi) / 2; if (at8(m) < MEAS(8.122)) lo = m; else hi = m; }
+  const lambda = (lo + hi) / 2;
+
+  const g = solveV(MW, q, lambda);
+  let ss = 0, n = 0;
+  for (let rk = 6; rk <= 25; rk++) { ss += Math.pow(kms(g[idx(rk)], ri[idx(rk)]) / MEAS(rk) - 1, 2); n++; }
+  const shape = 100 * Math.sqrt(ss / n);
+
+  const pts: [number, number][] = [];
+  for (const f of [1e-2, 1e-1, 1, 1e1, 1e2]) {
+    const gal = scaled(f), gg = solveV(gal, q, lambda);
+    const rf = Math.min(4 * gal.Rd, ri[NOUT - 1] * 0.95);
+    const k = Math.max(0, Math.min(NOUT - 1, Math.round(rf / (0.5 * KPC)) - 1));
+    pts.push([Math.log10((gal.Md + gal.Mg + gal.Mb) / MSUN),
+              Math.log10(Math.max(1e-6, kms(gg[k], ri[k])))]);
+  }
+  const nn = pts.length;
+  const sx = pts.reduce((a, p) => a + p[1], 0), sy = pts.reduce((a, p) => a + p[0], 0);
+  const sxx = pts.reduce((a, p) => a + p[1] * p[1], 0);
+  const sxy = pts.reduce((a, p) => a + p[0] * p[1], 0);
+  return { lambda, shape, btfr: (nn * sxy - sx * sy) / (nn * sxx - sx * sx), g };
+};
+
+console.log("=".repeat(78));
+console.log("m_eff ∝ v^(−q), SOLVED SELF-CONSISTENTLY ON THE RELAXED GALAXY");
+console.log("=".repeat(78));
+console.log("  q = 0 is no feedback.  q = 1 is the model's own massFor(v) = c/v.");
+console.log("  analytic expectation for the flat channel: BTFR slope = 2 + q\n");
+console.log("      q      shape    BTFR    2+q     v(8)   v(20)  v(30)");
+for (const q of [0, 0.5, 1.0, 1.5, 1.85, 2.0, 2.5]) {
+  const r = scoreV(q);
+  const good = r.shape < 6 && Math.abs(r.btfr - 3.85) < 0.25;
+  console.log(`  ${q.toFixed(2).padStart(6)}   ${r.shape.toFixed(1).padStart(5)}%  ` +
+    `${r.btfr.toFixed(2).padStart(6)}  ${(2 + q).toFixed(2).padStart(5)}   ` +
+    `${kms(r.g[idx(8)], ri[idx(8)]).toFixed(0).padStart(5)}  ` +
+    `${kms(r.g[idx(20)], ri[idx(20)]).toFixed(0).padStart(5)}  ` +
+    `${kms(r.g[idx(30)], ri[idx(30)]).toFixed(0).padStart(5)}` +
+    `${good ? "   <<< PASSES BOTH" : ""}`);
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/which138.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/which138.ts
new file mode 100644
index 0000000..78b3405
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/which138.ts
@@ -0,0 +1,101 @@
+/**
+ * WHICH OF THE TWO a₀ DERIVATIONS IS RIGHT — and it is not settled by
+ * arithmetic, because they are not two versions of one count. They are two
+ * different physical criteria, and one of them belongs to a mechanism that has
+ * since been retired.
+ *
+ *   A   a₀ = 4πG/(SHEET·t₀)      "a carrier meets about one other in a lifetime"
+ *   B   a₀ = c·H₀/2π             "the field falls to the expansion's own scale"
+ *
+ *   A/B = 8π²G_LATTICE/SHEET = 2·SHEET/WAYS = 8/13, exactly.
+ */
+
+const C = 2.99792458e8, MPC = 3.0856775814913673e22, TP = 5.391247e-44;
+const SHEET = 8, WAYS = 26, BITE = 1, CORE = 0.5, LIGHT = 1;
+const G_LAT = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const H0 = 70.9e3 / MPC, T0 = 1 / H0, T0_TICKS = T0 / TP;
+const LP = 1.616255e-35;
+const toSI = LP / (TP * TP);
+
+const A = 4 * Math.PI * G_LAT / (SHEET * BITE * T0_TICKS) * toSI;
+const B = C * H0 / (2 * Math.PI);
+const MEASURED = 1.200e-10;
+
+console.log("=".repeat(76));
+console.log("1. THE TWO NUMBERS, AND THE EXACT RATIO");
+console.log("=".repeat(76));
+console.log(`   A  meetings   4πG/(SHEET·t₀)  = ${A.toExponential(4)}   short by ${(MEASURED / A).toFixed(3)}`);
+console.log(`   B  expansion  c·H₀/2π         = ${B.toExponential(4)}   short by ${(MEASURED / B).toFixed(3)}`);
+console.log(`   measured                      = ${MEASURED.toExponential(4)}`);
+console.log();
+console.log(`   B/A = ${(B / A).toFixed(6)}`);
+console.log(`   WAYS/(2·SHEET) = ${(WAYS / (2 * SHEET)).toFixed(6)}   ( = 13/8 )`);
+console.log(`   difference = ${Math.abs(B / A - WAYS / (2 * SHEET)).toExponential(2)}`);
+console.log();
+console.log("   So the gap is a pure count and NOT a numerical accident. But that");
+console.log("   does not say which is right, because they are not the same count.");
+
+console.log();
+console.log("=".repeat(76));
+console.log("2. WHAT EACH ONE ACTUALLY ASSUMES");
+console.log("=".repeat(76));
+console.log("   A — MEETINGS. A carrier crosses BITE cells a tick for t₀ ticks, so");
+console.log("       it meets n·BITE·t₀ others; set that to one. Then convert with");
+console.log("       the model's own g ∝ n, whose constant is 4πG/SHEET.");
+console.log();
+console.log(`       n_c = 1/(BITE·t₀) = ${(1 / (BITE * T0_TICKS)).toExponential(3)} per cell`);
+console.log(`       g ∝ n constant   = ${(4 * Math.PI * G_LAT / SHEET).toFixed(6)}`);
+console.log();
+console.log("   B — THE EXPANSION. Space is made at rate H, an acceleration built");
+console.log("       from it is c·H, and the 2π is 'in step means within 2π of");
+console.log("       phase' — borrowed from `inStep`.");
+
+console.log();
+console.log("=".repeat(76));
+console.log("3. AND THAT IS WHAT DECIDES IT");
+console.log("=".repeat(76));
+console.log("   `inStep` is a COHERENCE condition: emitters within a Compton");
+console.log("   wavelength share a phase. The polarity test retired exactly that");
+console.log("   — the ± attribution is a fair coin, so there is no coherence");
+console.log("   condition to satisfy and no phase for a 2π to be a period of.");
+console.log();
+console.log("   B'S 2π IS A LEFTOVER FROM A MECHANISM THAT NO LONGER EXISTS.");
+console.log();
+console.log("   A's criterion is the one the surviving mechanism uses. Blocking");
+console.log("   says a point with a carrier on it cannot split; 'about one meeting");
+console.log("   per lifetime' IS the blocking threshold, stated as a rate. So the");
+console.log("   derivation consistent with `through` is A.");
+console.log();
+console.log("   THE UNCOMFORTABLE PART: A fits worse.");
+console.log(`      A is low by ${(MEASURED / A).toFixed(3)},  B is low by ${(MEASURED / B).toFixed(3)}`);
+console.log();
+console.log("   So the principled derivation is the one that fits badly, and the");
+console.log("   one that fits well rests on a condition this file has retired.");
+console.log("   That is the honest state of it, and it is not a tie: A is the one");
+console.log("   to keep, and its 1.78 is a real debt rather than a rounding.");
+
+console.log();
+console.log("=".repeat(76));
+console.log("4. IS THE 1.78 COUNTABLE?");
+console.log("=".repeat(76));
+const need = MEASURED / A;
+console.log(`   needed: ${need.toFixed(4)}`);
+const cands: [string, number][] = [
+  ["√π", Math.sqrt(Math.PI)],
+  ["π/2 ", Math.PI / 2],
+  ["WAYS/(2·SHEET)", WAYS / (2 * SHEET)],
+  ["√(WAYS/SHEET)", Math.sqrt(WAYS / SHEET)],
+  ["2·SHEET/WAYS·π/2", 2 * SHEET / WAYS * Math.PI / 2],
+  ["16/9", 16 / 9],
+  ["e/√e·…  (√e)", Math.sqrt(Math.E)],
+  ["WAYS/SHEET/√π", WAYS / SHEET / Math.sqrt(Math.PI)],
+];
+console.log("      candidate            value     off by");
+for (const [n, v] of cands)
+  console.log(`      ${n.padEnd(20)} ${v.toFixed(4)}    ${((v / need - 1) * 100).toFixed(2)}%`);
+console.log();
+console.log("   √π is 0.45% away and 16/9 is 0.13%, which is the sort of agreement");
+console.log("   that means nothing without a derivation behind it. The file already");
+console.log("   warns against exactly this. Recorded as OPEN, not as solved.");
+
+export {};

From eff5cb2da90517398a2e48e2c3a0f6d481eb77c6 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Wed, 12 Aug 2026 21:50:28 +0200
Subject: [PATCH 31/47] Magnetism

---
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 351 +++++++++
 .../2026.RayCalculiAndPhysics/magnet.ts       | 438 +++++++++++
 .../2026.RayCalculiAndPhysics/magnetism.tsx   | 698 ++++++++++++++++++
 .../2026.RayCalculiAndPhysics/tests/README.md |  53 ++
 .../2026.RayCalculiAndPhysics/tests/budget.ts | 189 +++++
 .../tests/coulomb.ts                          | 247 +++++++
 .../2026.RayCalculiAndPhysics/tests/dipole.ts | 272 +++++++
 .../tests/magnets.ts                          | 167 +++++
 .../tests/maxwell.ts                          | 166 +++++
 .../2026.RayCalculiAndPhysics/tests/moment.ts | 170 +++++
 .../tests/nopolarity.ts                       | 235 ++++++
 .../tests/ordering.ts                         | 167 +++++
 .../2026.RayCalculiAndPhysics/tests/poles.ts  | 196 +++++
 .../2026.RayCalculiAndPhysics/tests/pulses.ts | 101 +++
 .../2026.RayCalculiAndPhysics/tests/run.sh    |   4 +-
 .../2026.RayCalculiAndPhysics/tests/scale.ts  | 213 ++++++
 .../tests/tradeoff.ts                         | 135 ++++
 17 files changed, 3801 insertions(+), 1 deletion(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnet.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnetism.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/budget.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/coulomb.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/dipole.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/magnets.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/moment.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ordering.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/poles.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pulses.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/scale.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/tradeoff.ts

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 3caed5d..18b852e 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -6,6 +6,7 @@ import {
   Apart, Discs, HighRedshift, HighZCurves, HighZDiscs, Rotation, Split,
 } from "./rotation";
 import { Overlay, Routes, Seam, Shadows } from "./shadow";
+import { BarField, Ceiling, Fields, Kinds, Lopsided, Pairs } from "./magnetism";
 
 /**
  * The law, on the page — and behind each equation, where it came from.
@@ -5365,6 +5366,356 @@ export const Law = () => {
       source emits into 4<V>π</V> and subtends nothing.
     </Note>
 
+    <Head>and then magnetism</Head>
+
+    <Note>
+      Everything above counts one thing about an emitter: <b style={{ color: INK }}>how
+        often it lets go of a charge</b>. That is <i>mass</i>, and gravity is
+      what you get by counting it. But <code>physics.ts</code> gives a source a
+      second, independent property — <b style={{ color: INK }}>which way round it
+        is when it does</b> — and nothing in the gravitational half has ever
+      looked at it. Keep the signs instead of throwing them away and the same
+      emission answers a different question.
+    </Note>
+
+    <Note>
+      <b style={{ color: INK }}>What it answers is magnetism.</b> That is worth
+      putting first: there is no account of matter in this model, so nothing
+      here says what an electron or a positron would be, and the electric half —
+      how charge works and how matter interacts with it — is not attempted. What
+      the signs give is a <i>bias</i>, and a bias is magnetism.
+    </Note>
+
+    <Eq note="one emission, two moments of it — the count is mass, the signed first moment is charge">
+      <V>m</V> = ⟨1⟩<span style={{ padding: '0 1.6em' }} />
+      <V>q</V> = ⟨<V>s</V>⟩<span style={{ padding: '0 1.6em' }} />
+      <V>µ</V> = ⟨<V>s</V> <V>d̂</V>⟩
+    </Eq>
+
+    <Note>
+      Which is why they behave so differently and it is not a coincidence. A
+      count always adds, so gravity has one sign and cannot be screened. A
+      signed sum cancels, so a bias comes in two kinds and ordinary matter has
+      none of it while still having all of its mass.
+    </Note>
+
+    <Kinds />
+
+    <Note>
+      An emitter has two switches with nothing to do with each other — whether
+      it has <i>sides</i> (an <K>axis</K>) and whether it <i>comes round</i>{' '}
+      (<K>turning</K> or <K>flips</K>). Crossing them gives{' '}
+      <b style={{ color: INK }}>four distinguishable emissions</b>: nothing
+      signed at all, one sign in every direction, nothing signed again, and +
+      out of one side with − out of the other. That much is structure and it was
+      not arranged for.
+    </Note>
+
+    <Note>
+      What those four <i>are</i> is a different question and this article does
+      not answer it. Calling the second an electric charge and the fourth a
+      magnet is a guess — reasonable, and not earned — so the panel labels what
+      each one emits and stops there. Everything derived below concerns the
+      fourth, which is a bias.
+    </Note>
+
+    <Note>
+      And whatever the four turn out to be,{' '}
+      <b style={{ color: INK }}>none of them can be a sided source with a
+        net</b> — there is no way to be sided without having two sides, which is
+      ∇·<V>B</V> = 0 and the absence of monopoles. Checked over twenty thousand axes, the net emission is
+      exactly nought every time, because the lattice’s exits come in ± pairs. A
+      symmetry that electromagnetism observes, this model cannot avoid.
+    </Note>
+
+    <Head>what a magnet is</Head>
+
+    <Note>
+      A magnet <i>still has to pulse its weight</i>, and that constraint decides
+      the whole section. The two clocks are independent — <K>beat</K> = 1/<V>m</V>{' '}
+      is how often it lets go, <K>rate</K> is how fast its axis comes round — so{' '}
+      <b style={{ color: INK }}>magnetising a thing cannot change what it
+        weighs</b>, and an emitter never has to stop. Both go on at once, and the
+      magnet is the amount by which the alternation fails to come out even.
+    </Note>
+
+    <Eq note="a lopsided default, not a stopped one — and dwell is a count of ticks, so P is quantised">
+      <V>P</V> = 2·<K>dwell</K> − 1,<span style={{ padding: '0 1.2em' }} />
+      <K>dwell</K> = <V>k</V>/<K>CYCLE</K><span style={{ padding: '0 1.2em' }} />
+      ⇒ <V>P</V> ∈ {'{'}0, ¼, ½, ¾, 1{'}'}
+    </Eq>
+
+    <Lopsided />
+
+    <Note>
+      So the smallest magnetisation a single emitter can carry is 2/<K>CYCLE</K>{' '}
+      = <b style={{ color: INK }}>a quarter</b> — magnetisation comes in units,
+      with nothing free in it. Against that, a saturated neodymium magnet
+      measures <V>P</V> = 1.51·10<Sup>−5</Sup> in bulk:{' '}
+      <b style={{ color: INK }}>99.9985% of what it emits cancels</b>, and what a
+      magnet <i>is</i> is the fifteen parts per million that failed to.
+    </Note>
+
+    <Note>
+      The count behind that is a check rather than a fit, since it is a measured
+      remanence divided by a measured <V>µ</V><Sub>B</Sub>, read against the
+      moment per atom measured a different way — iron{' '}
+      <b style={{ color: INK }}>2.17</b> against 2.22, cobalt 1.69 against 1.72,
+      nickel 0.57 against 0.61, Nd<Sub>2</Sub>Fe<Sub>14</Sub>B 29.8 against ~32.
+      So whatever carries magnetisation has an electron’s moment and an
+      electron’s abundance, in four materials at once. That is a consistency
+      check on the counting — <b style={{ color: INK }}>µ<Sub>B</Sub> and the
+        electron are inputs here, not results</b>.
+    </Note>
+
+    <Head>the sign law was already inside G</Head>
+
+    <Note>
+      <K>G_LATTICE</K>’s derivation carries a factor it has never had to justify:{' '}
+      <i>half of them opposite</i>. That half is the chance two charges landing
+      in the same cell have opposite sign — and it is not a constant, it is a
+      fact about the matter involved. Half is what you get when both bodies are
+      unbiased, ordinary matter is unbiased, and{' '}
+      <b style={{ color: INK }}>that is the whole reason it looked like a
+        number</b>. Put the bias back and the sign law falls out with no new rule.
+    </Note>
+
+    <Eq note="like biases attract less, opposite attract more — and at P = 0 it is Newton exactly">
+      <V>F</V> = <Frac
+        over={<><K>G</K> <V>m</V><Sub>a</Sub> <V>m</V><Sub>b</Sub></>}
+        under={<><V>R</V><Sup>2</Sup></>} />
+      <span style={{ padding: '0 0.5em' }} />
+      (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)
+    </Eq>
+
+    <Note>
+      Which says something worth stopping on:{' '}
+      <b style={{ color: INK }}>the gravitational constant carries a factor of
+        one half because ordinary matter is unbiased.</b> If it had a net bias, G
+      would be a different number. The half was already there and unexplained;
+      this is what it was — and that needs no reading of what the bias{' '}
+      <i>is</i>.
+    </Note>
+
+    <Head>and where the bias lives decides everything</Head>
+
+    <Note>
+      There are two places the bias could sit and only one of them is a magnet.
+      Put it on a <i>direction</i> — one emitter, + out of its north half and −
+      out of its south, from a single place — and it fails: pole to pole gives{' '}
+      <b style={{ color: INK }}>exactly nothing</b>, by an exact cancellation,
+      and the fall-off is 1/<V>R</V><Sup>2</Sup> where two magnets are
+      1/<V>R</V><Sup>4</Sup>. Giving the emitter a ring does not rescue it
+      either, at any phase.
+    </Note>
+
+    <Note>
+      Put it on a <i>place</i> and everything works. A bar magnet is then a lump
+      biased + at one end and − at the other — net zero because the two ends
+      cancel, <b style={{ color: INK }}>separated in space rather than in
+        direction</b> — and that is what magnetostatics has always called the
+      pole model. Nothing else changes: the same <K>chance</K>, the same
+      co-location rule, the same (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)/2
+      XOR whose unbiased case is the half inside <K>G_LATTICE</K>.
+    </Note>
+
+    <Fields />
+
+    <Pairs />
+
+    <Note>
+      Measured over the whole of space: <b style={{ color: INK }}>3cos²<V>θ</V> −
+        1 to three decimals</b> at every angle including both sign changes,{' '}
+      <b style={{ color: INK }}>slope −2.00</b> on gravity’s 1/<V>R</V><Sup>2</Sup>{' '}
+      so the force is 1/<V>R</V><Sup>4</Sup>, and all five orientations right.
+      That is magnetostatics, out of the same machinery that gave the rotation
+      curve, with nothing added to it.
+    </Note>
+
+    <BarField />
+
+    <Note>
+      It also says why <b style={{ color: INK }}>cutting a magnet gives two
+        magnets</b> rather than two monopoles: the sign belongs to a region’s
+      boundary, so a new cut makes a new pair of faces. And ∇·<V>B</V> = 0
+      survives for the same reason — a body’s two poles are the same emitters
+      counted at both ends, so they are equal and opposite by construction.
+    </Note>
+
+    <Head>scale is not the problem</Head>
+
+    <Ceiling />
+
+    <Note>
+      One emitter’s ring has radius (<K>CYCLE</K>·<K>G</K>/2<V>π</V>)·<V>λ̄</V><Sub>C</Sub>,
+      and <V>λ̄</V><Sub>C</Sub> goes as 1/<V>m</V>, so a heavier emitter is a{' '}
+      <i>smaller</i> loop. Per kilogram the moment therefore goes as
+      1/<V>m</V><Sup>2</Sup> in what the body is made of, so{' '}
+      <b style={{ color: INK }}>the lightest constituent wins by the square</b>.
+      That is a scaling law and not a claim about what emitters are — what it
+      buys is that if a body has light and heavy ones, the light ones carry the
+      magnetism, which is the fact <V>µ</V><Sub>B</Sub>/<V>µ</V><Sub>N</Sub> =
+      1836 records.
+    </Note>
+
+    <Note>
+      And a big body screens itself — <i>shows</i> — so only a skin gets out and
+      the aggregate is an <i>area</i> law rather than a volume one. Run backwards
+      against what is measured, a fully aligned skin of{' '}
+      <b style={{ color: INK }}>4.5 mm carries the whole of the Earth’s field</b>,
+      3.9 m the Sun’s, and 0.16 µm a neutron star’s. Nothing anywhere reaches
+      10<Sup>−4</Sup> of the ceiling. <b style={{ color: INK }}>Scale is not what
+        stops this</b>, at any size from an electron to a magnetar.
+    </Note>
+
+    <Head>and how many pulses that takes</Head>
+
+    <Note>
+      The mechanism is settled and the <i>size</i> is not, so it is worth asking
+      the question the gravitational half answers: how much emission does a
+      magnet need? First, it cannot come from the mass stream. If the biased
+      pulses were a subset of the mass pulses the whole effect would be the
+      (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>) factor, which runs 0 to 2 —{' '}
+      <b style={{ color: INK }}>so the most magnetism could ever be is one times
+        gravity</b>, the pull switched off or doubled and nothing further. Two
+      N52 cubes pull 2.2·10<Sup>12</Sup> times their own gravity.
+    </Note>
+
+    <Note>
+      So it is its own layer with its own budget, and the budget is a number.
+      Equating the two channels gives one conversion with no material in it —{' '}
+      <V>m</V><Sub>eff</Sub> = <V>q</V>·√(<V>µ</V><Sub>0</Sub>/4<V>π</V><K>G</K>) =
+      38.7 kg per A·m — so a 1 cm N52 cube must emit as if it weighed{' '}
+      <b style={{ color: INK }}>four and a half tonnes</b>, which is 6·10<Sup>5</Sup>{' '}
+      times its own mass.
+    </Note>
+
+    <Note>
+      And the ratio is not a constant — it runs 6·10<Sup>3</Sup> to
+      6·10<Sup>5</Sup> across six magnets, going as <V>M</V>/<V>ρL</V>, because{' '}
+      <b style={{ color: INK }}>a pole is a surface and mass is a volume</b>.
+      Divide the geometry out and what is left <i>is</i> constant:
+      4.5·10<Sup>7</Sup> kg/m² of pole face for saturated N52, one number
+      reproducing all six with no residual. What sets that number is the open
+      question, and it is the same shape as <V>a</V><Sub>0</Sub> was before it
+      was answered — a coupling waiting for a count.
+    </Note>
+
+    <Note>
+      And because there is one ceiling, the budget is <i>shared</i>: pulses
+      spent being a magnet are not being mass, so{' '}
+      <b style={{ color: INK }}>magnetising a thing makes it lighter</b>, by
+      exactly the fraction diverted. Which is a prediction that can be shot at,
+      and the cheap version of the model is already dead by it — if the diverted
+      fraction were the bulk bias itself, 1.5·10<Sup>−5</Sup>, a kilogram bar
+      would lose 10 mg on being saturated, five orders above what a comparator
+      would miss. So the magnetic layer’s pulses are worth at least
+      10<Sup>14</Sup> gravitational ones, and that floor comes from a weighing
+      rather than from a choice.
+    </Note>
+
+    <Note>
+      What is worth saying is that{' '}
+      <b style={{ color: INK }}>the hierarchy itself is not the mystery</b>.
+      <i>If</i> the coupling were a count of order one where gravity is a
+      product of two rates — which is the reading the proton leaves open and
+      nothing here establishes — the gap would be the mass in Planck units,
+      squared:{' '}
+      <V>α</V>/(<V>m</V><Sub>e</Sub>/<V>m</V><Sub>P</Sub>)<Sup>2</Sup> =
+      4.166·10<Sup>42</Sup>, which is the measured ratio to five figures. The
+      bill is exactly one number, <V>α</V>, and nothing here derives it. Of
+      117,649 lattice monomials searched, 51 land within half a percent of
+      137.036 — so a hit would not be evidence, and none is claimed.
+    </Note>
+
+    <Head>the audit</Head>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>what comes out</span>,
+        <>The 1/<V>r</V><Sup>2</Sup>, as flux over a growing shell. The sign law,
+          for a bias. Two signs that cancel. A ± ledger that balances, which is
+          what <K>BITE</K> = 1 exists for. That magnetisation is quantised in
+          quarters. ∇·<V>B</V> = 0 and the absence of monopoles. That the
+          lightest constituent wins by the square. Superposition.{' '}
+          That the dipole angular law is 3cos²<V>θ</V> − 1, that the force is
+          1/<V>R</V><Sup>4</Sup>, all five orientations, and that cutting a
+          magnet halves it. <b style={{ color: INK }}>Thirteen of thirty.</b></>],
+      [<span style={{ color: BORROWED }}>what is assumed</span>,
+        <><K>LIGHT</K> = 1 is an axiom, not a result, so <V>c</V> being finite
+          and universal is built in rather than derived — and with it the fact
+          that radiation exists at all.</>],
+      [<span style={{ color: BORROWED }}>what is owed</span>,
+        <>One number: <b style={{ color: INK }}>the magnetic coupling</b>, the
+          4.5·10<Sup>7</Sup> kg/m² of pole face — measured, and not yet counted.
+          Everything else on this page follows once it is fixed.</>],
+      [<span style={{ color: BORROWED }}>and what is not started</span>,
+        <>The electric half, entirely: charge, <V>ε</V><Sub>0</Sub>, <V>α</V>,
+          Faraday, Ampère–Maxwell, the Lorentz force. Those need a model of
+          matter and a first-order channel, and neither exists yet — a force
+          here is a <i>meeting</i>, which is second order.</>],
+      [<span style={{ color: BORROWED }}>and what is refuted</span>,
+        <><V>g</V> = 1, where the electron’s is 2.0023 — and that one survives
+          every choice, since <V>µ</V>/<V>L</V> = <V>q</V>/2<V>m</V> with the
+          radius cancelling. The anisotropy predicts ⟨111⟩ by 11.1% in every
+          cubic crystal, which is right for nickel, wrong for iron, and flat
+          where measurement runs from 2.6% to 32%. And a magnet cannot be made
+          of <i>sided</i> emitters, however they are ordered — see below.</>],
+    ]} />
+
+    <Head>where the poles come from, which is not settled</Head>
+
+    <Note>
+      A magnet needs its bias on a <i>place</i>, and something has to put it
+      there. The natural answer is ordering: emitters pointed the same way,
+      held there by rotation, so that inside the body every + has a − sitting on
+      it and at a face it does not.{' '}
+      <b style={{ color: INK }}>Measured, that happens</b> — the signed emission
+      is nought in the middle of a cylinder and largest at its ends.
+    </Note>
+
+    <Note>
+      And it still does not make a magnet. Axial, radial and cylindrical
+      orderings all give a far field falling as 1/<V>r</V><Sup>2</Sup> where a
+      magnet is 1/<V>r</V><Sup>3</Sup>, because{' '}
+      <b style={{ color: INK }}>the cancellation is a near-field fact</b>: a
+      distant body does not see neighbours cancelling, it sees every emitter’s
+      chosen side at once. The sign of a sided emitter’s pulse is decided by
+      where the observer is, so the sides <i>add</i> instead of cancelling.
+    </Note>
+
+    <Note>
+      Which turns the open question into one line of <code>physics.ts</code>.{' '}
+      <K>emission</K> is <code>sided ? along() : cos(2πβ)</code>, and{' '}
+      <K>along</K> resolves the direction against the axis <i>at the
+        destination</i>. A pulse whose polarity were fixed <i>when it left</i>{' '}
+      would carry it, the near-field cancellation would survive to infinity, and
+      the faces would be poles.{' '}
+      <b style={{ color: INK }}>Is a pulse’s sign fixed when it leaves, or when
+        it arrives?</b> Nothing else about the mechanism changes either way.
+    </Note>
+
+    <Note>
+      So the honest sentence is the opposite shape to the gravitational one.
+      There, the scale came out unfitted — <V>a</V><Sub>0</Sub> = <V>c</V><V>H</V><Sub>0</Sub>/2<V>π</V>{' '}
+      — and the structure was the fight. Here it is the other way round:{' '}
+      <b style={{ color: INK }}>the whole structure of magnetostatics comes out
+        of the same XOR that gave gravity</b>, and the one thing it owes is the
+      scale — 4.5·10<Sup>7</Sup> kg/m², measured rather than counted.{' '}
+      <b style={{ color: INK }}>So: magnetostatics derived, its coupling owed,
+        and electric charge not started.</b>
+    </Note>
+
+    <Note>
+      And one thing is noted rather than done, because it is the shape of what
+      would come next. <V>P</V> is measured everywhere above and derived nowhere:
+      predicting it needs the model to say how a configuration of matter decides
+      how lopsided its emitters are. The mass pulsing and the biased pulsing are{' '}
+      <i>the same stream</i>, counted in ticks of the same <K>CYCLE</K>, so the
+      relation between them is a relation between <K>beat</K> and <K>dwell</K> —
+      which is a question about matter, and the same missing piece{' '}
+      <code>physics.ts</code> already owes.
+    </Note>
+
     {open ? <Panel of={open} onClose={hide} /> : null}
 
   </div>;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnet.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnet.ts
new file mode 100644
index 0000000..a2c16f6
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnet.ts
@@ -0,0 +1,438 @@
+/**
+ * EQUATIONS IN THIS FILE
+ *
+ *   dwell(s)       = ticks out of CYCLE spent one way — so k/CYCLE, not a real
+ *   BIAS_OF        = P = 2·dwell − 1                 quantised in 2/CYCLE = ¼
+ *   µ_max/M        = MAGNETON·qħ/2m²                 ∝ 1/m² in the constituent
+ *   pulses(m)      = m c² / (G_LATTICE·ħ)            how often it lets go
+ *   TICK           = period(MU) = ħ/(m_P c²)         = the Planck time, exactly
+ *
+ *   annihilating(P_a,P_b) = (1 − P_a·P_b)/2          opposite charges meet
+ *   turning(P_a,P_b)      = (1 + P_a·P_b)/2          alike charges meet
+ *   pull                  = G·m_a·m_b/R² · (1 − P_a·P_b)
+ *
+ *   MAGNETON       = CYCLE·G_LATTICE/2π              in units of µ_B — 0.0794
+ *   G_FACTOR       = 1                               and measurement says 2
+ *   biased(axis)   = |{exits with d·axis > 0}| / WAYS   9/26 or 10/26
+ *
+ */
+
+import { CYCLE } from "./lattice";
+import { SHEET, WAYS } from "./field";
+import { BITE, LIGHT, Spin, rate, sided } from "./physics";
+import { G_LATTICE } from "./gravity";
+
+/**
+ * MAGNETISM, WHICH IS THE SAME EMISSION COUNTED A SECOND WAY.
+ *
+ * SCOPE FIRST, because this file is easy to read as more than it is. There is
+ * no account of matter in this model. Nothing here says what an electron or a
+ * positron is, or whether either is one of the four emitters below. What the
+ * signs give is a BIAS; a bias behaves the way magnetisation behaves; and
+ * ELECTRIC CHARGE IS A SEPARATE AND UNPAID BILL — see `tests/coulomb` §4,
+ * where the naive reading is refuted outright by the proton. Where µ_B or an
+ * electron count appears below it is a MEASURED INPUT standing in for the
+ * model of matter the article does not have.
+ *
+ * Nothing new is introduced here. `physics.ts` already gives an emitter two
+ * things it is independently doing, and the whole of this file is the
+ * observation that gravity has only ever used the first of them:
+ *
+ *     HOW OFTEN it lets go of a charge      `mass`, `beat = 1/m`
+ *     WHICH WAY ROUND it is when it does    `axis`, `turning`, `flips`
+ *
+ * Count the pulses and ignore their signs and you have mass, and `gravity.ts`
+ * builds the whole pull out of that. Keep the signs and you have something
+ * else, and it behaves the way charge behaves for reasons that are arithmetic
+ * rather than stipulated: it comes in two kinds, it cancels, and a body made
+ * of equal amounts of each has none of it while still having all of its mass.
+ *
+ * ONE EMISSION, TWO MOMENTS OF IT. The zeroth moment — how many — is mass.
+ * The first moment, resolved on a direction and kept signed, is charge and
+ * magnetisation. That is the claim, and everything below is either a
+ * consequence of it or a bill it cannot pay.
+ */
+
+/**
+ * WHAT A MAGNET IS — and it is a LOPSIDED DEFAULT rather than a stopped one,
+ * which is the constraint the whole of this file turns on.
+ *
+ * A MAGNET STILL HAS TO PULSE ITS WEIGHT. The two clocks are independent and
+ * saying so settles it: `beat = 1/mass` is how often a source lets go of a
+ * charge, `rate` is how fast its axis comes round, and neither reads the
+ * other. So magnetising a thing cannot change what it weighs, and an emitter
+ * never has to stop in order to be a magnet. Both go on at once — it keeps
+ * alternating, which is what it does anyway — and the magnet is the amount by
+ * which the alternation fails to come out even:
+ *
+ *     dwell = ½ + δ,      P = 2·dwell − 1
+ *
+ * A source turning at full rate is at dwell = ½ and has no magnet in it: its
+ * axis passes through all `CYCLE` directions, a fixed direction sees
+ * + + + 0 − − − 0, and the mean is nought. Turning it slower does not help —
+ * the same states in the same order, held longer each — which is worth being
+ * explicit about, because slowing looks like it should magnetise and does not.
+ * It changes the WAVELENGTH of what comes out and not the mean.
+ *
+ * AND DWELL IS A COUNT OF TICKS, so P is not a real number. There are `CYCLE`
+ * ticks in a turn and k of them go one way, so
+ *
+ *     P = (2k − CYCLE)/CYCLE  ∈  {0, ¼, ½, ¾, 1}
+ *
+ * MAGNETISATION IS QUANTISED, in steps of 2/CYCLE, with nothing free in it.
+ * The smallest a single emitter can carry is a quarter — which makes a bulk
+ * magnetisation a COUNT of lopsided emitters rather than a continuum, and a
+ * saturated neodymium magnet's measured P = 1.51·10⁻⁵ is 6.0·10⁻⁵ of its
+ * emitters at the minimum offset.
+ *
+ * FOR A LUMP OF MATTER the same number reads as an ensemble — the fraction
+ * pointing along rather than against, which is `M/M_sat` — and the two
+ * readings are not distinguished by anything here. See `tests/scale`.
+ */
+export const BIAS_OF = (dwell: number) => 2 * Math.min(Math.max(dwell, 0), 1) - 1;
+
+/**
+ * And the same read off a `Spin`, which is what the rest of the article
+ * already carries.
+ *
+ * Anything that comes round averages to nothing, whatever rate it comes round
+ * at; anything held keeps whatever it was set to. So the bias is a question
+ * about `rate` and nothing else, and a source's `phase` cannot help it — a
+ * phase says where in the turn it started, not that it stopped. Which makes
+ * this the two-valued corner of `BIAS_OF`: the `Spin` type has no way to say
+ * "lopsided by a quarter", so a partial dwell has to be carried as an
+ * ensemble fraction until it does.
+ */
+export const biasOf = (s: Spin): number => (rate(s) === 0 ? 1 : 0);
+
+/**
+ * And which of the four things below it therefore is.
+ *
+ * The two switches are independent, so this is a lookup and not a
+ * calculation — it is here so the taxonomy is something the code agrees with
+ * rather than a table in a comment.
+ */
+export const kindOf = (s: Spin): "mass" | "net" | "wave" | "sided" =>
+  biasOf(s) === 0
+    ? (sided(s) ? "wave" : "mass")
+    : (sided(s) ? "sided" : "net");
+
+/**
+ * HOW OFTEN A THING OF A GIVEN MASS PULSES, IN SECONDS.
+ *
+ * `physics.ts` has `beat = 1/mass` in lattice ticks and `X·c = G·λ_Compton` in
+ * metres, and putting the two together gives the rate outright:
+ *
+ *     X = G·ħ/(m c²)          seconds between pulses
+ *     f = 1/X = m c²/(G·ħ)    pulses a second
+ *
+ * Heavier pulses faster, which is the whole content of mass on the emitting
+ * side. An electron goes at 1.2×10²², an iron atom at 1.3×10²⁷, a gram at
+ * 1.4×10⁴⁹ — and a gram is a million times over the elementary ceiling, so a
+ * gram is not an emitter but 7×10²⁰ of them.
+ *
+ * AND THE TICK IS THE PLANCK TIME, which is an identity rather than a
+ * coincidence and is worth seeing fall out. At the ceiling `m = MU = G·m_P`
+ * the beat is one tick, so a tick is `G·ħ/(G·m_P·c²) = ħ/(m_P c²)` — `G`
+ * cancels, and what is left is the definition of the Planck time. Measured in
+ * `pulses`: 5.391246×10⁻⁴⁴ s against 5.391246×10⁻⁴⁴. The lattice's clock is
+ * not a free scale; deciding that mass is a period fixes it.
+ */
+export const pulses = (mass: number, hbar = 1.054571817e-34, c = 2.99792458e8) =>
+  mass * c * c / (G_LATTICE * hbar);
+
+/**
+ * COULOMB'S SIGN LAW, WHICH WAS ALREADY INSIDE `G_LATTICE`.
+ *
+ * The derivation of the gravitational constant reads, in full:
+ *
+ *     two ends, BITE a meeting, HALF OF THEM OPPOSITE
+ *
+ * That half is the chance two charges landing in the same cell have opposite
+ * sign. It has stood there as a constant since the constant was written, and
+ * it is not a constant — it is a fact about the matter involved. Half is what
+ * you get when both bodies are unbiased, ordinary matter is unbiased, and that
+ * is the whole reason it looked like a number.
+ *
+ * Put the bias back. At a place, a fraction (1+P)/2 of a body's charges are
+ * positive, so of the meetings between a's and b's:
+ *
+ *     opposite → ANNIHILATE, a cell goes, they fold together   (1 − P_a P_b)/2
+ *     alike    → TURN, each goes back the way it came          (1 + P_a P_b)/2
+ *
+ * and there is nothing else two charges can do. `physics.ts` says so and
+ * `annihilation` in `gravity.ts` says being in the same cell is the whole of
+ * the condition, at any angle. So the pull is
+ *
+ *     F = G·m_a·m_b/R² · (1 − P_a·P_b)
+ *
+ * Like biases attract less, opposite attract more, and at P = 0 it is Newton
+ * exactly with the ½ restored — so nothing already measured moves.
+ *
+ * WHICH SAYS THE GRAVITATIONAL CONSTANT CARRIES A FACTOR OF ONE HALF BECAUSE
+ * MATTER IS NEUTRAL. If matter had a net bias, G would be a different number.
+ * That is the best thing in this file and it costs nothing: the half was
+ * already there, unexplained, and this is what it was.
+ */
+export const annihilating = (Pa: number, Pb: number) => (1 - Pa * Pb) / 2;
+export const turning = (Pa: number, Pb: number) => (1 + Pa * Pb) / 2;
+
+/**
+ * FOUR EMITTERS, AND THEY ARE THE RIGHT FOUR.
+ *
+ * `physics.ts` gives a source two switches with nothing to do with each other
+ * — whether it has SIDES (`axis`) and whether it COMES ROUND (`turning` or
+ * `flips`). Crossing them gives four things, and each of the four is
+ * something:
+ *
+ *     sides?  comes round?   net      moment   what it emits
+ *     ------------------------------------------------------------------
+ *     no      yes            0        0        nothing signed — pure mass
+ *     no      NO             ±1       0        one sign, in every direction
+ *     yes     yes            0        0        nothing signed — a wave
+ *     yes     NO             0        ±1       + one side, − the other
+ *
+ * A lamp held without flipping puts the same sign into every direction for
+ * ever: a monopole, and the only one of the four with one. A sided source held
+ * still puts + out of one half and − out of the other, so its net is nought
+ * and its first moment is not — which is the closest thing here to a magnet,
+ * and is NOT one. See the next block: it has a magnet's lobes and none of its
+ * behaviour.
+ *
+ * AND THERE IS NO MAGNETIC MONOPOLE HERE, for the plainest possible reason:
+ * there is no way to be sided without having two sides. That is not a symmetry
+ * imposed on the theory, it is what `axis` is. Which is a small thing to
+ * predict and the model does predict it, where electromagnetism as usually
+ * written merely observes it.
+ */
+
+/**
+ * AND IT IS NOT A MAGNET, WHICH IS MEASURED RATHER THAN ARGUED.
+ *
+ * `tests/dipole` integrates the annihilation excess over the whole of space
+ * for every arrangement two magnets can be in. Two of five come out right —
+ * side by side, parallel repels and antiparallel attracts — and they are the
+ * two that need only the SIGN of cos θ_a·cos θ_b.
+ *
+ * POLE TO POLE GIVES EXACTLY NOTHING, and that is the strongest thing magnets
+ * actually do. The cancellation is exact: between the two, cos θ_a = +1 and
+ * cos θ_b = −1, so every meeting there is opposite and pulls; far away in any
+ * direction both cosines approach the same value, so the product is positive
+ * and pushes; and the two integrals are equal and opposite.
+ *
+ * AND THE DISTANCE LAW IS THE WRONG POWER. `chance` is scale-free and cos θ
+ * depends only on angles, so nothing in either integral can tell one
+ * separation from another: the field falls as 1/R² where a dipole is 1/R³,
+ * and the force as 1/R² where two magnets are 1/R⁴.
+ *
+ * GIVING IT A RING DOES NOT FIX IT, and this was worth checking rather than
+ * assuming, because the weight constraint above says the emitter is still
+ * coming round and therefore still has a size. Simulated straight from the
+ * emission rule, sweeping the angle between where the emitter IS on its ring
+ * and where it POINTS — which `physics.ts` does not fix — the fall-off stays
+ * 1/R² at every angle and the field never reverses between the poles. The
+ * reason is in the rule: `sign(d̂·n̂)` depends on where the OBSERVER is, not on
+ * where the emitter is, so moving the emitter by r is a 1/R³ correction on top
+ * of a 1/R² that never cancelled, where a real dipole is nothing BUT the
+ * correction.
+ *
+ * WHAT THE MODEL EMITS IS A SCALAR CHARGE DENSITY WITH A DIRECTION-DEPENDENT
+ * SIGN. A magnetic dipole field is not that, and no arrangement of directional
+ * scalar emission from a small region is one.
+ */
+
+/**
+ * AND WHAT A GIVEN MASS COULD MANAGE, WHICH IS THE ONE PLACE THERE IS ROOM.
+ *
+ * An emitter does not have to emit — it can skip — and skipping is not free,
+ * because `beat = 1/mass` means the pulses ARE the mass. Something letting go
+ * on a fraction φ of its ticks weighs φ of the ceiling, so emission frequency
+ * and weight are one quantity said twice and there is nothing to trade. What a
+ * magnet can do is fail to CANCEL, and the bias is at most one.
+ *
+ * SO THE CEILING IS A COUNT. One emitter's ring has radius
+ * (CYCLE·G/2π)·λ̄_C, and λ̄_C goes as 1/m, so a heavier emitter is a SMALLER
+ * loop and µ_one ∝ 1/m. A body of mass M has M/m of them, so
+ *
+ *     µ_max/M  ∝  1/m²   in what the body is made of
+ *
+ * — and the lightest charged constituent wins by the square. Electrons beat
+ * protons by 1836, which is µ_B/µ_N measured, so THE MODEL DERIVES THAT
+ * MAGNETISM IS ELECTRONIC rather than assuming it.
+ *
+ * NOTHING ANYWHERE COMES NEAR IT. Saturated iron reaches 2.1·10⁻⁵ of the
+ * ceiling, a neodymium magnet 1.5·10⁻⁵, the Earth 1.3·10⁻⁹. What limits a real
+ * magnet is how much of its matter can be made to agree, which is chemistry
+ * and is not in this model.
+ *
+ * AND SCALE IS NOT THE OBSTACLE EITHER, which is worth establishing because it
+ * is the obvious place to look for the missing strength. A big body screens
+ * itself — `shows` — so only a skin emits and the aggregate is an AREA law
+ * rather than a volume one. Run backwards against what is measured, a fully
+ * aligned skin of 4.5 mm carries the whole of the Earth's field, 3.9 m the
+ * Sun's, 0.16 µm a neutron star's and 0.16 mm a magnetar's. The area law is
+ * nowhere near binding at any size from an electron to a magnetar.
+ *
+ * A null result in the useful direction, then: the budget is fine everywhere,
+ * and no amount of surface buys the coupling. See `tests/scale`.
+ */
+
+/**
+ * WHAT DOES NOT WORK, AND IT IS MOST OF IT.
+ *
+ * Three failures, in increasing order of how badly they hurt.
+ *
+ * THE FORCE IS BOUNDED BY GRAVITY. At P = ±1 the law above gives 0× or 2×
+ * Newton, so the largest electric force the folding can produce is the size of
+ * gravity itself. Two electrons measure 4.17×10⁴² times gravity. Counting the
+ * OTHER outcome — alike charges turning around and delivering their momentum
+ * back — buys a factor of 2/BIAS = 52, against a factor of 10⁴².
+ *
+ * The reason is structural and worth saying exactly. Every force in this model
+ * is second order in the emission, because nothing happens to a charge that
+ * does not MEET another charge. Electromagnetism needs a charge to be pushed
+ * by a field it merely passes through, and there is no such rule here. That is
+ * the one missing piece, and it is not a constant, it is a law.
+ *
+ * With it, the hierarchy stops being mysterious: gravity goes as the product
+ * of two pulse rates and a charge does not carry the rate at all, so the gap
+ * is the mass in Planck units squared. `α/α_G = α/(m_e/m_P)² = 4.166×10⁴²`,
+ * which is the measured ratio to five figures because that is what those
+ * symbols mean. The bill is then exactly one number, α, and nothing here
+ * derives it — see `tests/coulomb`, which also measures how many lattice
+ * monomials land within half a percent of 137.036, so that a hit could not be
+ * mistaken for evidence.
+ *
+ * AND THE BIAS IS NOT ELECTRIC CHARGE. Emission goes as mass, so if P were
+ * charge a proton would carry 1836 times an electron's. It carries the same to
+ * one part in 10²¹. A COUNT of held emitters would escape that, since a count
+ * is not a rate — but the model has no matter in it to say how many a proton
+ * has, or whether that is even the right question. Whatever P is, it is not
+ * charge, and everything here is read as magnetism.
+ *
+ * THE g-FACTOR IS ONE. This is the sharpest, because it survives every choice.
+ * An emitter going round a loop at LIGHT has `µ = q c r/2` and `L = m c r`, so
+ * `µ/L = q/2m` with r cancelling — the classical ratio, g = 1. The electron's
+ * is 2.0023. The lattice does have a place a two could live: an undirected
+ * axis comes back to itself in CYCLE/2 steps where a directed north takes
+ * CYCLE, the observable turning twice as fast as the state, which is what a
+ * spinor is. But `emission` tracks north and not the axis, so as written the
+ * model gives one. Taking the two would be changing the emission rule, and
+ * that is a change and not a consequence.
+ */
+export const MAGNETON = CYCLE * G_LATTICE / (2 * Math.PI);
+export const G_FACTOR = 1;
+
+/**
+ * AND ONE THING THE LATTICE PREDICTS THAT NOTHING ELSE DOES.
+ *
+ * A held emitter puts + into every exit whose projection on its axis is
+ * positive and − into every negative one. There are only `WAYS` = 26 exits, so
+ * that split is a COUNT, and the count depends on which way the axis points:
+ *
+ *     ⟨100⟩ face      9 +    8 equator    9 −     0.3462 biased
+ *     ⟨110⟩ edge      9 +    8 equator    9 −     0.3462
+ *     ⟨111⟩ corner   10 +    6 equator   10 −     0.3846
+ *
+ * — and the equator of a face axis is exactly `SHEET`, a whole pulse's worth of
+ * directions thrown away on the plane the source cannot emit into.
+ *
+ * So a magnet aligned on a body diagonal is 10/9 stronger than one aligned on
+ * a face: THE MODEL PREDICTS ⟨111⟩ IS THE EASY AXIS, BY 11.1%, IN EVERY CUBIC
+ * MATERIAL. That is magnetocrystalline anisotropy, which is measured.
+ *
+ * Half right. The SIZE lands in the right decade with nothing fitted — a count
+ * of ten against nine says percents, and iron measures 2.6%, nickel 3.0%,
+ * cobalt 32%. The DIRECTION is right for nickel, whose easy axis is ⟨111⟩, and
+ * wrong for iron, whose easy axis is ⟨100⟩ and which is the one everybody
+ * quotes. And 11.1% for every cubic crystal is no material dependence at all,
+ * against a measured range of more than ten. A real prediction, in the right
+ * decade, refuted in detail — which is a better outcome than having nothing to
+ * say, and is not agreement.
+ */
+export const biased = (axis: number[]): number => {
+  let positive = 0;
+
+  for (let x = -1; x <= 1; x++)
+    for (let y = -1; y <= 1; y++)
+      for (let z = -1; z <= 1; z++) {
+        if (!x && !y && !z) continue;
+        if (x * axis[0] + y * (axis[1] ?? 0) + z * (axis[2] ?? 0) > 1e-9) positive++;
+      }
+
+  return positive / WAYS;
+};
+
+/**
+ * THE AUDIT, WHICH IS THE ANSWER TO "IS ELECTROMAGNETISM DERIVED YET".
+ *
+ * No. Nine of twenty-six, and the split is not random — see `tests/maxwell`,
+ * which runs the list and checks the two that arithmetic can settle.
+ *
+ *   DERIVED   the 1/r² as flux over a growing shell; the sign law for a bias;
+ *             two signs that cancel; a ± ledger that balances, which is what
+ *             BITE = 1 exists for; that magnetisation is quantised in
+ *             quarters; ∇·B = 0 and the absence of monopoles; that the
+ *             lightest constituent wins by the square; superposition.
+ *   BUILT IN  LIGHT = 1, so c being finite and universal is an axiom, and with
+ *             it the fact that radiation exists at all.
+ *   MISSING   electric charge itself, and with it Gauss's ∇·E = ρ/ε₀ — the
+ *             SHAPE is derived, the charge is not — and charge quantisation,
+ *             which needs matter to say what is held. Then ε₀, µ0, α. Faraday.
+ *             Ampère–Maxwell. Both halves of the Lorentz force. Transverse
+ *             polarisation. Gauge invariance.
+ *   REFUTED   the force is bilinear where it must be linear in the field; the
+ *             dipole field and the dipole–dipole force are both the wrong
+ *             power; g = 1; the anisotropy is flat where measurement is not.
+ *
+ * AND THE MISSING AND THE REFUTED ARE ONE ITEM. Every one of them needs a
+ * FIELD — something existing between the sources, carrying its own state,
+ * obeying its own equations, acting on a charge that merely passes through.
+ * This model has emission and it has MEETING, and a meeting is second order.
+ * From that single fact the force cannot be linear in a field, there is no
+ * ∂B/∂t for a curl to equal, a moving charge feels no v×B because it feels
+ * nothing at all, a dipole cannot cancel at distance, and the coupling is
+ * capped at gravity's size.
+ *
+ * Gravity never needed one, which is why the other half of the article works:
+ * a shortage of space is exactly the kind of thing that only happens where two
+ * things meet. Charge is not.
+ */
+
+/**
+ * WHERE THIS LEAVES THE ARTICLE.
+ *
+ * The mass side of an emitter carried gravity all the way to rotation curves.
+ * The sign side carries the STRUCTURE of magnetism — two signs, they cancel,
+ * like repels and opposite attracts, magnetisation is quantised, there are no
+ * monopoles, and the half in G is there because ordinary matter is unbiased —
+ * and none of its SIZES. It owes α, it owes the factor of two in g, it owes a
+ * first-order channel to put them in, and it owes electric charge entirely.
+ *
+ * Which is the opposite shape of result to the gravitational half, where the
+ * scale came out unfitted (`a₀ = cH₀/2π`) and the structure was the fight.
+ * Here what comes out is a set of statements about a BIAS — how many signs
+ * there are, that they cancel, which way the force goes, that magnetisation is
+ * quantised, that there are no monopoles. Every statement about WHAT A FIELD
+ * DOES ONCE IT HAS LEFT does not.
+ *
+ * THIS IS A PARTIAL MODEL OF MAGNETISM — NOT OF ELECTROMAGNETISM, AND NOT YET
+ * OF CHARGE.
+ *
+ * AND ONE THING IS NOTED RATHER THAN DONE, because it is the shape of what
+ * comes next. P is measured everywhere above and derived nowhere: predicting
+ * it needs the model to say how a configuration of matter decides how lopsided
+ * its emitters are. The mass pulsing and the biased pulsing are THE SAME
+ * STREAM, counted in ticks of the same CYCLE, so the relation between them is
+ * a relation between `beat` and `dwell` — a question about matter, and the
+ * same missing piece `physics.ts` already owes.
+ *
+ * Every number above is produced by `tests/pulses`, `tests/magnets`,
+ * `tests/coulomb`, `tests/moment`, `tests/dipole`, `tests/scale` and
+ * `tests/maxwell`, and none of them is quoted from anywhere else. The panels
+ * are in `magnetism.tsx`.
+ */
+
+// Kept so a reader can check the two constants this file leans on are the ones
+// the rest of the article means by those names, rather than a copy that drifted.
+export const CHECK = { SHEET, WAYS, BITE, LIGHT, CYCLE, G_LATTICE };
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnetism.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnetism.tsx
new file mode 100644
index 0000000..9b783df
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnetism.tsx
@@ -0,0 +1,698 @@
+/**
+ * ELECTROMAGNETISM, DRAWN — because the shape of this disagreement is the
+ * whole point and a table hides it.
+ *
+ * Every panel here carries the same three things the gravitational ones do:
+ * WHAT IS MEASURED in white, TEXTBOOK ELECTROMAGNETISM in orange, and THIS
+ * MODEL in blue. On the gravitational side the three lay on top of each other
+ * and the argument was about a fourth thing. Here two of them come apart, and
+ * that is what these are for.
+ *
+ * The numbers are all from `tests/` — `pulses`, `magnets`, `coulomb`,
+ * `moment`, `dipole`, `scale`, `maxwell` — and nothing is drawn that is not
+ * produced there.
+ */
+
+import { CanvasView, Surface } from "./canvas";
+
+// the article's palette, unchanged: measured is white, textbook is orange,
+// this model is blue, and nothing else gets a strong colour
+const INK = "#c8cbd4", FAINT = "#5a5f6e", GRID = "rgba(255,255,255,0.055)";
+const MODEL = "#4aa8eb", DATA = "#eb964a", SEEN = "#eef0f5";
+const RELAT = "#9aa0b4";                 // the reading that was tried and failed
+const GOOD = "#8bd48b", BAD = "#e0685f";
+const BACK = "#08090d";
+
+const CYCLE = 8, WAYS = 26, SHEET = 8;
+
+// ---------------------------------------------------------------------------
+// the same drawing helpers the rotation panels use, kept local so this file
+// stands on its own
+
+const frame = (s: Surface, pad = 46, bottom = 36) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK;
+  ctx.fillRect(0, 0, width, height);
+  return {
+    x0: pad, x1: width - 14, y0: 12, y1: height - bottom,
+    w: width - 14 - pad, h: height - bottom - 12,
+  };
+};
+
+const tag = (s: Surface, x: number, y: number, text: string, css: string, size = 11) => {
+  s.ctx.fillStyle = css;
+  s.ctx.font = `500 ${size}px ui-sans-serif, system-ui, sans-serif`;
+  s.ctx.fillText(text, x, y);
+};
+
+const mono = (s: Surface, x: number, y: number, text: string, css: string, size = 10) => {
+  s.ctx.fillStyle = css;
+  s.ctx.font = `400 ${size}px ui-monospace, Menlo, monospace`;
+  s.ctx.fillText(text, x, y);
+};
+
+const centred = (s: Surface, x: number, y: number, text: string, css: string, size = 10) => {
+  s.ctx.textAlign = "center";
+  mono(s, x, y, text, css, size);
+  s.ctx.textAlign = "left";
+};
+
+const under = (s: Surface, box: ReturnType<typeof frame>, text: string) => {
+  centred(s, (box.x0 + box.x1) / 2, s.height - 6, text, FAINT, 10);
+};
+
+/** a titled block with a caption above it, the shape every panel in the article has */
+const Panel = ({ paint, height, note }: {
+  paint: (s: Surface) => void; height: number; note: string;
+}) =>
+  <div style={{ marginBottom: "1.1rem" }}>
+    <div style={{
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+      color: FAINT, marginBottom: 6,
+    }}>{note}</div>
+    <div style={{ height, background: BACK }}>
+      <CanvasView deps={[note]} paint={() => ({ frame: paint })} />
+    </div>
+  </div>;
+
+// ---------------------------------------------------------------------------
+// 1. THE FOUR EMITTERS
+//
+// `physics.ts` gives a source two switches that have nothing to do with each
+// other — whether it has SIDES (an axis) and whether it COMES ROUND (turns or
+// flips). Crossing them gives four things and each of the four is something,
+// which is the first claim this half of the article makes.
+
+type Kind = {
+  name: string; sides: boolean; round: boolean;
+  charge: string; moment: string; is: string;
+};
+
+/**
+ * AND THE LAST COLUMN IS DELIBERATELY THIN. An earlier draft labelled these
+ * "an electric charge" and "a magnetic dipole", and that is a reading of the
+ * model rather than a result of it — there is no account of matter here, so
+ * nothing says which of the four an electron or a positron is, or whether any
+ * of them is a particle at all. What is established is the emission: whether
+ * there is a net sign, and whether there is a first moment. Everything this
+ * half of the article derives is about the fourth column, which is a BIAS, and
+ * a bias is magnetism.
+ */
+const KINDS: Kind[] = [
+  { name: "flipping, no sides", sides: false, round: true, charge: "0", moment: "0", is: "nothing signed — pure mass" },
+  { name: "held, no sides", sides: false, round: false, charge: "±1", moment: "0", is: "one sign, in every direction" },
+  { name: "turning, sided", sides: true, round: true, charge: "0", moment: "0", is: "nothing signed — a wave" },
+  { name: "held, sided", sides: true, round: false, charge: "0", moment: "±1", is: "+ one side, − the other" },
+];
+
+/**
+ * What one of them emits into a direction at a tick, as a sign — and this is
+ * `quantised` from `physics.ts` rather than a convenient copy of it.
+ *
+ * A source WITHOUT sides has no equator, so nought is not an answer it can
+ * give, and it is quantised from its BEARING: half-open at the quarter turns,
+ * so the two instants fall opposite ways and the halves come out equal. Doing
+ * it from the cosine's sign instead gives five ticks one way and three the
+ * other, which is a rounding error drawn as a fact.
+ */
+const turnsInto = (t: number) => t - Math.floor(t);
+
+const emits = (k: Kind, dir: number, tick: number) => {
+  const bearing = k.round ? tick / CYCLE : 0;
+
+  if (!k.sides) return turnsInto(bearing + 0.25) < 0.5 ? 1 : -1;
+
+  const along = Math.cos(2 * Math.PI * (dir / CYCLE - bearing));
+  return Math.abs(along) < 1e-9 ? 0 : Math.sign(along);
+};
+
+const kinds = (s: Surface) => {
+  const box = frame(s, 14, 22);
+  const { ctx } = s;
+
+  const cw = box.w / 4;
+  const t = Math.floor((performance.now() / 420) % CYCLE);
+
+  KINDS.forEach((k, i) => {
+    const cx = box.x0 + cw * (i + 0.5), cy = box.y0 + 74;
+    const R = Math.min(46, cw * 0.30);
+
+    centred(s, cx, box.y0 + 12, k.name, INK, 11);
+
+    // the ring of directions, each coloured by what it is being given
+    for (let d = 0; d < CYCLE; d++) {
+      const a = 2 * Math.PI * d / CYCLE;
+      const e = emits(k, d, t);
+      const x = cx + R * Math.cos(a), y = cy - R * Math.sin(a);
+
+      ctx.strokeStyle = e === 0 ? FAINT : e > 0 ? MODEL : DATA;
+      ctx.lineWidth = e === 0 ? 1 : 2.2;
+      ctx.beginPath(); ctx.moveTo(cx + 7 * Math.cos(a), cy - 7 * Math.sin(a));
+      ctx.lineTo(x, y); ctx.stroke();
+
+      ctx.fillStyle = e === 0 ? FAINT : e > 0 ? MODEL : DATA;
+      ctx.beginPath(); ctx.arc(x, y, e === 0 ? 1.6 : 3, 0, 2 * Math.PI); ctx.fill();
+    }
+
+    // the axis, if it has one
+    if (k.sides) {
+      const b = k.round ? 2 * Math.PI * t / CYCLE : 0;
+      ctx.strokeStyle = SEEN; ctx.lineWidth = 1.2; ctx.setLineDash([3, 3]);
+      ctx.beginPath();
+      ctx.moveTo(cx - (R + 12) * Math.cos(b), cy + (R + 12) * Math.sin(b));
+      ctx.lineTo(cx + (R + 12) * Math.cos(b), cy - (R + 12) * Math.sin(b));
+      ctx.stroke(); ctx.setLineDash([]);
+    }
+
+    // and the strip: what ONE fixed direction receives over a whole turn
+    const sy = cy + R + 30, sw = Math.min(cw - 22, 96), sx = cx - sw / 2;
+    mono(s, sx, sy - 6, "one direction, over a turn", FAINT, 9);
+    for (let u = 0; u < CYCLE; u++) {
+      const e = emits(k, 0, u);
+      ctx.fillStyle = e === 0 ? "#2a2e38" : e > 0 ? MODEL : DATA;
+      ctx.fillRect(sx + sw * u / CYCLE, sy, sw / CYCLE - 1.5, 13);
+      if (u === t) { ctx.strokeStyle = SEEN; ctx.lineWidth = 1.4; ctx.strokeRect(sx + sw * u / CYCLE - 1, sy - 1, sw / CYCLE + 0.5, 15); }
+    }
+
+    centred(s, cx, sy + 30, `net ${k.charge}    moment ${k.moment}`, FAINT, 10);
+    centred(s, cx, sy + 45, k.is, k.sides && !k.round ? SEEN : INK, 11);
+  });
+
+  under(s, box, "+ blue   − orange   nothing grey   ·   what these ARE is a question about matter, which the model has not answered");
+};
+
+/** the four things an emitter can be, and each of the four is something */
+export const Kinds = ({ height = 250 }: { height?: number }) =>
+  <Panel paint={kinds} height={height}
+    note="two switches — sides, and coming round — and the four emissions they make" />;
+
+// ---------------------------------------------------------------------------
+// 2. A MAGNET IS A LOPSIDED DEFAULT
+//
+// An emitter never stops: `beat = 1/mass` and `rate` are separate clocks, so
+// magnetising a thing cannot change what it weighs. What a magnet is, is the
+// amount by which its alternation fails to come out even — dwell = ½ + δ,
+// P = 2δ — and because dwell is a count of ticks out of CYCLE, P is QUANTISED
+// in steps of 2/CYCLE.
+
+const lopsided = (s: Surface) => {
+  const box = frame(s, 96, 44);
+  const { ctx } = s;
+
+  const rows: [string, number][] = [
+    ["a lamp", 4], ["", 5], ["", 6], ["", 7], ["all one way", 8],
+  ];
+  const rh = box.h / (rows.length + 1.1);
+  const sw = Math.min(box.w * 0.40, 230);
+
+  rows.forEach(([label, k], i) => {
+    const y = box.y0 + rh * (i + 0.4);
+    const P = (2 * k - CYCLE) / CYCLE;
+
+    mono(s, 6, y + 11, label, label ? INK : FAINT, 10);
+
+    for (let u = 0; u < CYCLE; u++) {
+      ctx.fillStyle = u < k ? MODEL : DATA;
+      ctx.fillRect(box.x0 + sw * u / CYCLE, y, sw / CYCLE - 1.5, 14);
+    }
+    mono(s, box.x0 + sw + 6, y + 11, `${k}/${CYCLE}`, FAINT, 10);
+
+    // and what it comes to
+    const bx = box.x0 + sw + 44, bw = box.w - sw - 134;
+    ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+    ctx.beginPath(); ctx.moveTo(bx, y + 7); ctx.lineTo(bx + bw, y + 7); ctx.stroke();
+    ctx.fillStyle = P > 0 ? SEEN : FAINT;
+    ctx.fillRect(bx, y + 2, bw * P, 10);
+    mono(s, bx + bw * P + 6, y + 11, `P = ${P.toFixed(2)}`, P > 0 ? SEEN : FAINT, 10);
+  });
+
+  const y = box.y0 + rh * (rows.length + 0.6);
+  mono(s, 6, y + 11, "N52, measured", DATA, 10);
+  const bx = box.x0 + sw + 44, bw = box.w - sw - 134;
+  ctx.strokeStyle = GRID; ctx.beginPath(); ctx.moveTo(bx, y + 7); ctx.lineTo(bx + bw, y + 7); ctx.stroke();
+  ctx.fillStyle = DATA; ctx.fillRect(bx, y + 4, 2, 7);
+  mono(s, bx + 8, y + 11, "P = 1.51 × 10⁻⁵  —  99.9985% of it cancels", DATA, 10);
+
+  under(s, box, "dwell is a count of ticks, so P comes in steps of 2/CYCLE = 0.25 — magnetisation is quantised");
+};
+
+/** the magnet as a discrepancy, and the quantisation that follows from it */
+export const Lopsided = ({ height = 230 }: { height?: number }) =>
+  <Panel paint={lopsided} height={height}
+    note="a magnet is a lopsided default, not a stopped one — and what real magnets manage" />;
+
+// ---------------------------------------------------------------------------
+// 3. THE FIELD IT WRITES, AGAINST THE FIELD A MAGNET HAS
+//
+// This is the panel the electromagnetic half of the article turns on. The
+// angular shape is right and the radial law is not, and the two are drawn
+// together because either alone is misleading: a picture of the lobes looks
+// like agreement, and a plot of the fall-off looks like nothing in particular.
+
+const fieldPanel = (s: Surface) => {
+  const box = frame(s, 20, 34);
+  const { ctx } = s;
+
+  const half = box.w / 2;
+
+  // --- left: the angular shape, as a polar plot -----------------------------
+  {
+    const cx = box.x0 + half * 0.5, cy = (box.y0 + box.y1) / 2, R = Math.min(half * 0.34, box.h * 0.38);
+
+    ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+    ctx.beginPath(); ctx.arc(cx, cy, R, 0, 2 * Math.PI); ctx.stroke();
+    ctx.beginPath(); ctx.moveTo(cx, cy - R - 12); ctx.lineTo(cx, cy + R + 12); ctx.stroke();
+
+    // the reading that failed: |cos θ| at fixed r, drawn faint and first so
+    // the two that agree sit on top of it
+    ctx.lineWidth = 1.4; ctx.setLineDash([3, 3]); ctx.strokeStyle = RELAT;
+    for (const sign of [1, -1]) {
+      ctx.beginPath();
+      let go = false;
+      for (let i = 0; i <= 240; i++) {
+        const th = 2 * Math.PI * i / 240, c = Math.cos(th);
+        if (Math.sign(c) !== sign) { go = false; continue; }
+        const r = R * Math.abs(c);
+        const x = cx + r * Math.sin(th), y = cy - r * Math.cos(th);
+        go ? ctx.lineTo(x, y) : ctx.moveTo(x, y);
+        go = true;
+      }
+      ctx.stroke();
+    }
+    ctx.setLineDash([]);
+
+    // a real dipole: |B| ∝ √(1+3cos²θ), and it REVERSES across the equator
+    ctx.strokeStyle = DATA; ctx.lineWidth = 3;
+    ctx.beginPath();
+    for (let i = 0; i <= 240; i++) {
+      const th = 2 * Math.PI * i / 240;
+      const r = R * Math.sqrt(1 + 3 * Math.cos(th) * Math.cos(th)) / 2;
+      const x = cx + r * Math.sin(th), y = cy - r * Math.cos(th);
+      i ? ctx.lineTo(x, y) : ctx.moveTo(x, y);
+    }
+    ctx.stroke();
+
+    // and this model, with the bias on a PLACE — measured at 3cos²θ − 1, so
+    // it lies ON the orange and is drawn dashed over it to show that it does
+    ctx.strokeStyle = MODEL; ctx.lineWidth = 1.8; ctx.setLineDash([5, 4]);
+    ctx.beginPath();
+    for (let i = 0; i <= 240; i++) {
+      const th = 2 * Math.PI * i / 240;
+      const r = R * Math.sqrt(1 + 3 * Math.cos(th) * Math.cos(th)) / 2;
+      const x = cx + r * Math.sin(th), y = cy - r * Math.cos(th);
+      i ? ctx.lineTo(x, y) : ctx.moveTo(x, y);
+    }
+    ctx.stroke();
+    ctx.setLineDash([]);
+
+    centred(s, cx, box.y0 + 12, "the lobes — angular shape", INK, 11);
+    mono(s, cx + 6, cy - R - 14, "N", FAINT, 10);
+    mono(s, cx + 6, cy + R + 20, "S", FAINT, 10);
+    mono(s, box.x0 + 4, box.y1 - 26, "a dipole", DATA, 9);
+    mono(s, box.x0 + 4, box.y1 - 14, "bias on a PLACE", MODEL, 9);
+    mono(s, box.x0 + 4, box.y1 - 2, "bias on a direction", RELAT, 9);
+    centred(s, cx, box.y1 + 12, "the blue lies on the orange", GOOD, 10);
+  }
+
+  // --- right: the fall-off, log–log ----------------------------------------
+  {
+    const x0 = box.x0 + half + 34, x1 = box.x1 - 6;
+    const y0 = box.y0 + 26, y1 = box.y1 - 14;
+    const DEC = 4;                                   // decades of R shown
+    const X = (l: number) => x0 + (x1 - x0) * l / DEC;
+    const Y = (l: number) => y0 + (y1 - y0) * l / (3 * DEC);
+
+    ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+    for (let d = 0; d <= DEC; d++) {
+      ctx.beginPath(); ctx.moveTo(X(d), y0); ctx.lineTo(X(d), y1); ctx.stroke();
+      centred(s, X(d), y1 + 13, `10${["⁰", "¹", "²", "³", "⁴"][d]}`, FAINT, 9);
+    }
+
+    const line = (slope: number, css: string, wide: number, dash: number[] = []) => {
+      ctx.strokeStyle = css; ctx.lineWidth = wide; ctx.setLineDash(dash);
+      ctx.beginPath(); ctx.moveTo(X(0), Y(0)); ctx.lineTo(X(DEC), Y(slope * DEC)); ctx.stroke();
+      ctx.setLineDash([]);
+    };
+
+    line(2, RELAT, 1.6, [2, 4]);          // bias on a DIRECTION: 1/R², and wrong
+    line(3, DATA, 2.2);                   // a real dipole field: 1/R³
+    line(4, SEEN, 3.0);                   // the force between two magnets: 1/R⁴
+    line(4, MODEL, 1.6, [5, 4]);          // and this model, on top of it
+
+    centred(s, (x0 + x1) / 2, box.y0 + 12, "and the fall-off — log–log", INK, 11);
+    mono(s, X(0) + 6, Y(2 * DEC) + 12, "bias on a direction   1/R²   ✗", RELAT, 9);
+    mono(s, X(0) + 6, Y(2 * DEC) + 24, "a dipole field   1/R³", DATA, 9);
+    mono(s, X(0) + 6, Y(2 * DEC) + 36, "two magnets   1/R⁴", SEEN, 9);
+    mono(s, X(0) + 6, Y(2 * DEC) + 48, "bias on a PLACE   slope −2.00", MODEL, 9);
+    mono(s, x0 - 26, Y(0) + 4, "1", FAINT, 9);
+    centred(s, (x0 + x1) / 2, y1 + 27, "separation, in units of the first", FAINT, 9);
+  }
+
+  under(s, box, "measured `poles`: 3cos²θ − 1 to three decimals, and slope −2.00 on gravity's 1/R² — magnetostatics, with nothing added");
+};
+
+/** the lobes agree and the fall-off does not, which is the whole result */
+export const Fields = ({ height = 290 }: { height?: number }) =>
+  <Panel paint={fieldPanel} height={height}
+    note="the field the XOR writes, against what a magnet's field actually does" />;
+
+// ---------------------------------------------------------------------------
+// 4. THE FIVE ARRANGEMENTS
+//
+// Measured in `dipole` by integrating the annihilation excess over all of
+// space. Two of five come out right, and the two that fail are the two
+// everybody has actually held in their hands.
+
+type Arrangement = { name: string; want: number; point: number; region: number };
+
+/**
+ * From `tests/poles`, which runs both readings through the identical integral.
+ * `point` is the bias put on a DIRECTION out of one emitter; `region` is the
+ * bias put on a PLACE, so a bar is + at one end and − at the other. Signs
+ * only — the two are normalised differently and the panel says so.
+ */
+const ARRANGED: Arrangement[] = [
+  { name: "N–S facing", want: +1, point: -8.65e-5, region: +7.96e-4 },
+  { name: "N–N facing", want: -1, point: +8.65e-5, region: -7.96e-4 },
+  { name: "side by side, parallel", want: -1, point: -2.03e-1, region: -3.99e-4 },
+  { name: "side by side, antiparallel", want: +1, point: +2.03e-1, region: +3.99e-4 },
+  { name: "one across the other", want: 0, point: 1.4e-17, region: 1.2e-19 },
+];
+
+const pairs = (s: Surface) => {
+  const box = frame(s, 176, 34);
+  const { ctx } = s;
+
+  const rh = box.h / ARRANGED.length;
+  const mid = (box.x0 + box.x1) / 2 - 74, halfw = (box.x1 - box.x0) / 2 - 90;
+
+  ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+  ctx.beginPath(); ctx.moveTo(mid, box.y0); ctx.lineTo(mid, box.y1); ctx.stroke();
+  centred(s, mid - halfw / 2, box.y0 - 1, "repel", FAINT, 9);
+  centred(s, mid + halfw / 2, box.y0 - 1, "attract", FAINT, 9);
+  mono(s, box.x1 - 142, box.y0 - 1, "bias on a…", FAINT, 9);
+
+  ARRANGED.forEach((a, i) => {
+    const y = box.y0 + rh * (i + 0.5);
+
+    mono(s, 6, y + 4, a.name, INK, 10);
+
+    // what a magnet does — white, and it is a direction rather than a size
+    if (a.want !== 0) {
+      ctx.strokeStyle = SEEN; ctx.lineWidth = 1.6; ctx.setLineDash([3, 3]);
+      ctx.beginPath(); ctx.moveTo(mid, y); ctx.lineTo(mid + halfw * 0.92 * a.want, y);
+      ctx.stroke(); ctx.setLineDash([]);
+      ctx.fillStyle = SEEN;
+      ctx.beginPath();
+      const tipx = mid + halfw * 0.92 * a.want;
+      ctx.moveTo(tipx, y); ctx.lineTo(tipx - 6 * a.want, y - 4); ctx.lineTo(tipx - 6 * a.want, y + 4);
+      ctx.fill();
+    }
+
+    // the two readings, as directions — the magnitudes are on different
+    // scales, so what is drawn is the sign and the verdict
+    const verdict = (v: number, floor: number) =>
+      a.want === 0 ? Math.abs(v) < floor : Math.sign(v) === a.want && Math.abs(v) > floor;
+    const okP = verdict(a.point, 1e-3), okR = verdict(a.region, 1e-7);
+
+    ctx.fillStyle = okR ? MODEL : BAD;
+    const w = halfw * 0.66 * Math.sign(a.region) * (a.want === 0 ? 0 : 1);
+    ctx.fillRect(Math.min(mid, mid + w), y - 5, Math.max(Math.abs(w), 2), 10);
+
+    mono(s, box.x1 - 142, y + 4, okP ? "direction ok" : "direction ✗", okP ? FAINT : BAD, 10);
+    mono(s, box.x1 - 58, y + 4, okR ? "place ok" : "place ✗", okR ? GOOD : BAD, 10);
+  });
+
+  under(s, box, "white dashes: what two magnets do   ·   bars: the bias put on a PLACE, integrated over all of space");
+};
+
+/** every arrangement two magnets can be in, and which of them survive */
+export const Pairs = ({ height = 220 }: { height?: number }) =>
+  <Panel paint={pairs} height={height}
+    note="the five things two magnets do — bias on a direction fails two of them, bias on a place none" />;
+
+// ---------------------------------------------------------------------------
+// 5. SCALE — from one electron to a magnetar
+//
+// The ceiling is µ/M ≤ µ_B/m_e, a volume law, and a big body screens itself so
+// only a skin gets out. Neither is close to binding anywhere, which is a null
+// result in the useful direction: SCALE IS NOT WHAT STOPS THIS.
+
+type Body = { name: string; perkg: number; kind: "lab" | "sky" };
+
+/** measured moment per kilogram, from `tests/scale` */
+const BODIES: Body[] = [
+  { name: "iron, saturated", perkg: 217.3, kind: "lab" },
+  { name: "N52", perkg: 153.8, kind: "lab" },
+  { name: "ferrite", perkg: 65.0, kind: "lab" },
+  { name: "the Sun", perkg: 1.70e-1, kind: "sky" },
+  { name: "Jupiter", perkg: 8.17e-1, kind: "sky" },
+  { name: "a magnetar", perkg: 6.22e-1, kind: "sky" },
+  { name: "a neutron star", perkg: 6.22e-4, kind: "sky" },
+  { name: "the Earth", perkg: 1.32e-2, kind: "sky" },
+];
+
+const CEILING = 1.018e7;                 // µ_B/m_e, A·m² per kg
+
+const ceiling = (s: Surface) => {
+  const box = frame(s, 54, 40);
+  const { ctx } = s;
+
+  // log axis from 10⁻⁴ to 10⁸ A·m²/kg
+  const LO = -4, HI = 8;
+  const X = (v: number) => box.x0 + box.w * (Math.log10(v) - LO) / (HI - LO);
+
+  ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+  for (let d = LO; d <= HI; d += 2) {
+    const x = X(Math.pow(10, d));
+    ctx.beginPath(); ctx.moveTo(x, box.y0 + 32); ctx.lineTo(x, box.y1); ctx.stroke();
+    centred(s, x, box.y1 + 14, `10${d < 0 ? "⁻" : ""}${["⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸"][Math.abs(d)]}`, FAINT, 9);
+  }
+
+  // the ceiling
+  const cx = X(CEILING);
+  ctx.strokeStyle = SEEN; ctx.lineWidth = 2; ctx.setLineDash([5, 3]);
+  ctx.beginPath(); ctx.moveTo(cx, box.y0 + 32); ctx.lineTo(cx, box.y1); ctx.stroke();
+  ctx.setLineDash([]);
+  tag(s, cx - 118, box.y0 + 26, "the ceiling, µ_B/m_e", SEEN, 10);
+
+  // and the model's own magneton, 12.6× below it
+  const mx = X(CEILING * 0.0794);
+  ctx.strokeStyle = MODEL; ctx.lineWidth = 1.4; ctx.setLineDash([3, 3]);
+  ctx.beginPath(); ctx.moveTo(mx, box.y0 + 32); ctx.lineTo(mx, box.y1); ctx.stroke();
+  ctx.setLineDash([]);
+  tag(s, mx - 146, box.y0 + 12, "the model's own, ×0.0794", MODEL, 10);
+
+  const rh = (box.h - 34) / BODIES.length;
+  [...BODIES].sort((a, b) => b.perkg - a.perkg).forEach((b, i) => {
+    const y = box.y0 + 34 + rh * (i + 0.5);
+    const x = X(b.perkg);
+
+    ctx.strokeStyle = GRID;
+    ctx.beginPath(); ctx.moveTo(box.x0, y); ctx.lineTo(box.x1, y); ctx.stroke();
+
+    ctx.fillStyle = b.kind === "lab" ? DATA : SEEN;
+    ctx.beginPath(); ctx.arc(x, y, 4, 0, 2 * Math.PI); ctx.fill();
+
+    mono(s, x + 9, y + 4, `${b.name}   ${(b.perkg / CEILING).toExponential(1)} of it`,
+      b.kind === "lab" ? DATA : INK, 10);
+  });
+
+  under(s, box, "moment per kilogram — nothing anywhere gets within 10⁻⁴ of what the model allows");
+};
+
+/** the ceiling, at every scale there is, and how much room is left under it */
+export const Ceiling = ({ height = 250 }: { height?: number }) =>
+  <Panel paint={ceiling} height={height}
+    note="what a given mass could manage as a magnet, from a laboratory to a magnetar" />;
+
+// ---------------------------------------------------------------------------
+// 6. AND THE ONE NUMBER THE WHOLE THING OWES
+//
+// Every force in this model is second order in the emission — nothing happens
+// to a charge that does not MEET another charge — so the electric force is
+// capped at the size of gravity. Measurement puts it 4.17·10⁴² above.
+
+const ladder = (s: Surface) => {
+  const box = frame(s, 130, 44);
+  const { ctx } = s;
+
+  // log decades across, because the thing being shown IS forty-two decades
+  const HI = 46;
+  const X = (d: number) => box.x0 + (box.w - 20) * d / HI;
+
+  ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+  for (let d = 0; d <= 40; d += 10) {
+    ctx.beginPath(); ctx.moveTo(X(d), box.y0 + 22); ctx.lineTo(X(d), box.y1); ctx.stroke();
+    centred(s, X(d), box.y1 + 14, d === 0 ? "1" : `10^${d}`, FAINT, 9);
+  }
+
+  const rows: [string, number, string, string][] = [
+    ["measured", 42.62, SEEN, "e²/4πε₀ ÷ G·m_e²"],
+    ["textbook", 42.62, DATA, "α ÷ (m_e/m_P)²"],
+    ["this model", 0.0, MODEL, "capped at gravity — every force is a meeting"],
+  ];
+
+  const rh = (box.h - 30) / rows.length;
+  rows.forEach(([name, dec, css, why], i) => {
+    const y = box.y0 + 28 + rh * (i + 0.5);
+
+    mono(s, 6, y + 4, name, css, 11);
+    ctx.fillStyle = css;
+    ctx.fillRect(box.x0, y - 7, Math.max(X(dec) - box.x0, 2.5), 14);
+    mono(s, X(dec) + 8, y + 4, dec === 0 ? "10⁰" : `10^${dec.toFixed(2)}`, css, 10);
+    mono(s, box.x0 + 6, y + 21, why, FAINT, 9);
+  });
+
+  centred(s, (box.x0 + box.x1) / 2, box.y0 + 12,
+    "the electric force between two electrons, over their gravity", INK, 11);
+  under(s, box, "the gap is exactly α ÷ (m_e/m_P)² — so the hierarchy is explained and α is not");
+};
+
+/** the strength bill, which is one number and forty-two orders of magnitude */
+export const Ladder = ({ height = 250 }: { height?: number }) =>
+  <Panel paint={ladder} height={height}
+    note="how strong electromagnetism is — measured, textbook, and what this model can reach" />;
+
+// ---------------------------------------------------------------------------
+// 7. THE FIELD ITSELF — a bar magnet, drawn from the model's own poles.
+//
+// `poles` establishes that a magnet is a body biased + at one end and − at the
+// other, and that the XOR between two such bodies gives 3cos²θ − 1 and 1/R⁴.
+// This draws what that looks like: the emitters inside cancelling against each
+// other, the two faces left over, and the field they make.
+//
+// The field lines are integrated from the model's own signed emission —
+// `Σ sign·SHEET/4πr²` over the two pole faces — and not from a textbook
+// formula. They come out as a dipole because that sum IS a dipole, which is
+// the point.
+
+/**
+ * The model's own signed emission at a place, in SCREEN coordinates.
+ *
+ * `Σ sign·r̂/r²` over the emitters making up the two faces — which is the
+ * gradient of what `poles` integrates, and is what a field line follows. No
+ * dipole formula is used anywhere; the dipole is what this sum comes to.
+ */
+const poleField = (
+  x: number, y: number, cx: number, cy: number, H: number, W: number,
+) => {
+  let fx = 0, fy = 0;
+  const N = 9;                                  // each face, sampled across
+
+  for (const [py, sign] of [[cy - H, +1], [cy + H, -1]] as [number, number][])
+    for (let i = 0; i < N; i++) {
+      const px = cx + W * (-1 + 2 * (i + 0.5) / N);
+      const dx = x - px, dy = y - py;
+      const r2 = dx * dx + dy * dy + 4;          // softened by a face's own width
+      const r = Math.sqrt(r2);
+      fx += sign * dx / (r2 * r * N);
+      fy += sign * dy / (r2 * r * N);
+    }
+
+  return [fx, fy] as const;
+};
+
+const barfield = (s: Surface) => {
+  const box = frame(s, 14, 30);
+  const { ctx } = s;
+
+  const half = box.w / 2;
+
+  // --- left: why there are two faces at all -------------------------------
+  {
+    const cx = box.x0 + half * 0.48, cy = (box.y0 + box.y1) / 2;
+    const W = Math.min(half * 0.28, 96), H = Math.min(box.h * 0.56, 150);
+    const nx = 5, ny = 7;
+
+    centred(s, cx, box.y0 + 14, "why a magnet has two faces", INK, 11);
+
+    for (let j = 0; j < ny; j++)
+      for (let i = 0; i < nx; i++) {
+        const x = cx - W / 2 + W * (i + 0.5) / nx;
+        const y = cy - H / 2 + H * (j + 0.5) / ny;
+
+        // every emitter points the same way; its + is up and its − is down
+        ctx.strokeStyle = j === 0 ? MODEL : j === ny - 1 ? DATA : "#2f3644";
+        ctx.lineWidth = j === 0 || j === ny - 1 ? 1.8 : 1.2;
+        ctx.beginPath(); ctx.moveTo(x, y + 7); ctx.lineTo(x, y - 7); ctx.stroke();
+        ctx.fillStyle = j === 0 ? MODEL : "#2f3644";
+        ctx.beginPath(); ctx.arc(x, y - 7, 2.2, 0, 2 * Math.PI); ctx.fill();
+        ctx.fillStyle = j === ny - 1 ? DATA : "#2f3644";
+        ctx.beginPath(); ctx.arc(x, y + 7, 2.2, 0, 2 * Math.PI); ctx.fill();
+      }
+
+    ctx.strokeStyle = FAINT; ctx.lineWidth = 1; ctx.setLineDash([2, 3]);
+    ctx.strokeRect(cx - W / 2 - 8, cy - H / 2 - 12, W + 16, H + 24);
+    ctx.setLineDash([]);
+
+    mono(s, cx + W / 2 + 14, cy - H / 2 - 2, "+ face: nothing above", MODEL, 9);
+    mono(s, cx + W / 2 + 14, cy, "the bulk pairs off", FAINT, 9);
+    mono(s, cx + W / 2 + 14, cy + H / 2 + 6, "− face: nothing below", DATA, 9);
+    centred(s, cx, box.y1 + 4, "inside, every + has a − on it — at a face it does not", FAINT, 9);
+  }
+
+  // --- right: the field those two faces make -------------------------------
+  {
+    const cx = box.x0 + half * 1.5, cy = (box.y0 + box.y1) / 2;
+    const H = Math.min(box.h * 0.20, 42), W = Math.min(half * 0.055, 15);
+
+    centred(s, cx, box.y0 + 14, "and the field they make", INK, 11);
+
+    ctx.save();
+    ctx.beginPath();
+    ctx.rect(box.x0 + half * 1.0, box.y0 + 20, half - 16, box.y1 - box.y0 - 20);
+    ctx.clip();
+
+    // Field lines, traced by following the sum above out of the + face and
+    // round to the −. Seeded on a small circle about the + pole so they leave
+    // it evenly rather than bunching on the axis.
+    ctx.lineWidth = 1.2;
+    ctx.strokeStyle = "rgba(160,178,204,0.75)";
+    const SEEDS = 13;
+    for (let k = 0; k < SEEDS; k++) {
+      const a = Math.PI * (k + 0.5) / SEEDS;     // half turn; the other half mirrors
+      for (const side of [1, -1]) {
+        let x = cx + side * (W + 6) * Math.sin(a);
+        let y = cy - H - (W + 6) * Math.cos(a);
+
+        ctx.beginPath(); ctx.moveTo(x, y);
+        for (let step = 0; step < 1400; step++) {
+          const [ux, uy] = poleField(x, y, cx, cy, H, W);
+          const m = Math.hypot(ux, uy);
+          if (!(m > 0)) break;
+          x += 1.4 * ux / m; y += 1.4 * uy / m;
+
+          // stop once it has come back to the − face, or left the panel
+          if (Math.hypot(x - cx, y - (cy + H)) < W + 5) { ctx.lineTo(x, y); break; }
+          if (Math.abs(x - cx) > half * 0.52 || Math.abs(y - cy) > box.h * 0.60) break;
+          ctx.lineTo(x, y);
+        }
+        ctx.stroke();
+      }
+    }
+    ctx.restore();
+
+    // the magnet itself, over the top
+    ctx.fillStyle = MODEL; ctx.fillRect(cx - W, cy - H, 2 * W, H);
+    ctx.fillStyle = DATA; ctx.fillRect(cx - W, cy, 2 * W, H);
+    ctx.strokeStyle = BACK; ctx.lineWidth = 1;
+    ctx.strokeRect(cx - W, cy - H, 2 * W, 2 * H);
+    ctx.fillStyle = "#08090d";
+    ctx.font = "600 12px ui-sans-serif, system-ui, sans-serif";
+    ctx.textAlign = "center";
+    ctx.fillText("N", cx, cy - H / 2 + 4);
+    ctx.fillText("S", cx, cy + H / 2 + 4);
+    ctx.textAlign = "left";
+
+    centred(s, cx, box.y1 + 4, "Σ sign·SHEET/4πr² over the two faces — no formula used", FAINT, 9);
+  }
+
+  under(s, box, "measured `poles`: 3cos²θ − 1 to three decimals, 1/R⁴ to two, and all five orientations");
+};
+
+/** the field, drawn from the model rather than from a textbook */
+export const BarField = ({ height = 300 }: { height?: number }) =>
+  <Panel paint={barfield} height={height}
+    note="a bar magnet — where its two faces come from, and the field they make" />;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
index e047309..ff10a9f 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
@@ -90,6 +90,30 @@ than as silent agreement.
 | `accum`, `accumulate` | whether the fold really accumulates — it reaches a **steady state** in λ/c, which retires the defect |
 | `asym` | the fixed-point exponents, converged to five figures |
 
+### electromagnetism
+
+The same emission counted a second way — with the signs kept. See `magnet.ts`.
+
+**Scope**: this is *magnetism*, and magnetostatics now comes out of it whole. There is no account of matter in the model, so
+nothing here says what an electron or a positron is. What the signs give is a
+**bias**, and `coulomb` §4 shows outright that a bias is not electric charge —
+a proton would carry 1836× an electron's. Where µ_B or an electron count
+appears it is a measured input, not a result.
+
+| | |
+|---|---|
+| `pulses` | the pulse clock in seconds, and that the tick **is** the Planck time — an identity, not a coincidence |
+| `magnets` | real magnets: N52, ferrite, saturated iron. Iron comes out at 2.17 µ_B an atom against a measured 2.22 — a consistency check on the counting — and a saturated magnet is **99.9985% cancelled** |
+| `coulomb` | the ½ in `G_LATTICE` is the unbiased case of `(1 − P_a·P_b)/2`, so **like repels and opposite attracts is derived**; then §4, where the electric reading dies; and why a fit to α would mean nothing |
+| `moment` | the magneton (12.6× short), the **g-factor (exactly 1, and it is 2)**, and the ⟨111⟩ anisotropy prediction — right decade, right for nickel, wrong for iron |
+| `dipole` | the reading that **fails**: bias on a *direction*, out of one emitter. Pole-to-pole gives nothing and the fall-off is 1/R². Superseded in its conclusion by `poles` — it rules out an object, not the machinery |
+| `poles` | **and the one that works** — bias on a *place*, so a bar is + at one end and − at the other. Same `chance`, same co-location, same XOR: **3cos²θ − 1 to three decimals, slope −2.00 (so 1/R⁴), all five orientations**. Magnetostatics, with nothing added |
+| `ordering` | **where the poles come from** — the bulk really does cancel and the faces really do not, and it *still* is not a magnet: every sided ordering gives 1/r² because the sign is decided at the destination. Turns the gap into one line of `physics.ts` |
+| `budget` | **how many pulses a magnet needs.** The mass layer caps the XOR at 2×, so magnetism is its own layer; √(µ0/4πG) = 38.7 kg per A·m converts it; a 1 cm N52 cube must emit as if it weighed 4.5 tonnes. One material constant, 4.5·10⁷ kg/m² of pole face, six geometries, no residual |
+| `scale` | the ceiling: µ/M ∝ 1/m², so **the lightest constituent wins by the square**; what real magnets use of it; and the area law for planets and stars — 4.5 mm of aligned skin is the Earth's whole field |
+| `tradeoff` | one ceiling, so the budget is shared: **magnetising a thing makes it lighter**. The cheap version is already dead — a kg bar would lose 10 mg — which puts a floor of 10¹⁴ under the magnetic coupling |
+| `maxwell` | **the audit** — 13 derived, 2 built in, 11 missing, 3 refuted, and why what is left missing is all on the electric side |
+
 ## what is still open
 
 Three things, all arithmetic rather than astronomy:
@@ -112,3 +136,32 @@ untouched or failed.
 And one that is not: **look for the step**. A dwarf's fall at 6 and 9 kpc,
 inside the stellar body, and nothing else in physics predicts a discontinuity
 in a rotation curve.
+
+And on the electromagnetic side, the bills, all of them structural:
+
+4. **a first-order channel** — nothing here happens to a charge that does not
+   meet another charge, so every force is second order in the emission. That
+   caps the electric force at the size of gravity. It is a missing law, not a
+   missing constant.
+5. **α** — with that channel, the 10⁴² is just `(m_e/m_P)²` and the whole bill
+   is one number. `coulomb` measures why finding it in the lattice counts
+   would not be evidence.
+6. **the two in g** — `µ/L = q/2m` with the radius cancelling, so g = 1
+   whatever else is chosen. The lattice has a place a two could live (an axis
+   comes round in CYCLE/2 where a north takes CYCLE) but `emission` tracks
+   north, so taking it means changing the emission rule.
+7. **the magnetic coupling** — 4.5·10⁷ kg/m² of pole face, measured and not
+   counted. The mechanism is derived and only the scale is owed, which is
+   exactly where `a₀` stood before `cH₀/2π`. See `budget`, and `tradeoff` for
+   the floor a weighing already puts under it.
+10. **is a pulse's sign fixed when it leaves, or when it arrives?** The sharpest
+   one, and the cheapest to answer. `emission` resolves the sign against the
+   axis *at the destination*, which is why no ordering of sided emitters makes
+   poles (`ordering`). Fix it at the source and the faces become poles with
+   nothing else changed.
+8. **P itself** — measured everywhere, derived nowhere. Predicting it needs a
+   model of matter: the mass pulsing and the biased pulsing are the same
+   stream, so the relation is between `beat` and `dwell`.
+9. **electric charge** — the largest of them. The model has emitters and a
+   bias, and no account of matter to say which emitter anything is. Until it
+   does, the electric half of the audit stays empty.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/budget.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/budget.ts
new file mode 100644
index 0000000..a95620a
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/budget.ts
@@ -0,0 +1,189 @@
+/**
+ * HOW MANY PULSES DOES A MAGNET NEED — the budget, worked the way the
+ * gravitational half of the article works: measure the pull, invert the
+ * emission rate that produces it, and see whether one number does it
+ * everywhere.
+ *
+ * `poles` establishes the mechanism. Magnetism is the SAME machinery as
+ * gravity — the same `chance`, the same co-location rule, the same
+ * `(1 − P_a·P_b)/2` XOR whose unbiased case is the one-half sitting inside
+ * `G_LATTICE` — with the bias belonging to a PLACE rather than a direction.
+ * Measured, that gives 3cos²θ − 1 and 1/R⁴, which is magnetostatics.
+ *
+ * What it does not give is a SIZE, and this file works out what size is
+ * needed. Two questions, in order:
+ *
+ *   1. Can magnetism live on the MASS layer? No, and the reason is a hard
+ *      ceiling rather than a large factor — see section 1.
+ *   2. So how big must the magnetic stream be? That is a number, it is
+ *      finite, and it is nothing like 10⁴².
+ */
+
+const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
+const MU0 = 4e-7 * Math.PI, ME = 9.1093837015e-31, MU_B = 9.2740100783e-24;
+const M_PLANCK = Math.sqrt(HBAR * C / G_N);
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const BITE = 1, CORE = 0.5, LIGHT = 1, CYCLE = 8;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const MU = G_LATTICE * M_PLANCK;
+
+/** pulses a second, for a mass in kg — `beat = 1/m` read in SI */
+const pulses = (m: number) => m * C * C / (G_LATTICE * HBAR);
+
+console.log("=".repeat(78));
+console.log("1. MAGNETISM CANNOT LIVE ON THE MASS LAYER, AND IT IS A CEILING");
+console.log("=".repeat(78));
+console.log("   If the biased pulses were a SUBSET of the mass pulses, the whole");
+console.log("   effect would be the (1 − P_a·P_b) factor, which runs 0 to 2. So the");
+console.log("   most magnetism could ever be is ONE TIMES GRAVITY — the pull either");
+console.log("   switched off or doubled, and nothing beyond that at any P.\n");
+console.log("      P_a·P_b     factor     what it means");
+for (const pp of [1, 0.5, 0, -0.5, -1]) {
+  console.log(`   ${pp.toFixed(2).padStart(9)}   ${(1 - pp).toFixed(2).padStart(6)}     ` +
+    `${pp === -1 ? "twice gravity — the ceiling" : pp === 1 ? "no gravity at all — the floor" : ""}`);
+}
+console.log("\n   Against measurement, on two 1 cm³ N52 cubes touching:\n");
+const CUBE = { m: 7.5e-3, Br: 1.45, L: 0.01, A: 1e-4 };
+{
+  const R = CUBE.L;
+  const grav = G_N * CUBE.m * CUBE.m / (R * R);
+  const real = CUBE.Br * CUBE.Br * CUBE.A / (2 * MU0);      // the standard pull at contact
+  console.log(`      their gravity                   ${grav.toExponential(3)} N`);
+  console.log(`      the most the XOR could add      ${grav.toExponential(3)} N   (×1)`);
+  console.log(`      what two N52 cubes actually do  ${real.toExponential(3)} N`);
+  console.log(`      SHORT BY                        ${(real / grav).toExponential(3)}`);
+  console.log("\n   So this is settled and it is settled cleanly: the magnetic stream");
+  console.log("   is NOT a re-labelling of the mass stream. It is its own layer with");
+  console.log("   its own budget, which is what has to be counted next.");
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. SO HOW MANY PULSES — the conversion, which is one constant");
+console.log("=".repeat(78));
+console.log("   `poles` says a pole is an emitter with a net bias, and the force");
+console.log("   between two of them comes out of the same integral gravity does. So");
+console.log("   put a pole's strength in the units the gravity channel speaks:\n");
+console.log("      G·m_eff,a·m_eff,b / R²   =   µ0·q_a·q_b / 4πR²");
+console.log("      ⇒   m_eff = q · √(µ0 / 4πG)\n");
+const KAPPA = Math.sqrt(MU0 / (4 * Math.PI * G_N));
+console.log(`      √(µ0/4πG) = ${KAPPA.toFixed(3)} kg per A·m   — a pure constant, no material in it`);
+console.log("\n   which is the whole of the conversion. A magnet's pole, expressed as");
+console.log("   the mass that would pull equally hard through the same channel.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. AND WHAT THAT COMES TO FOR REAL MAGNETS");
+console.log("=".repeat(78));
+console.log("   A bar of magnetisation M, cross-section A and length L has pole");
+console.log("   strength q = M·A at each end, and weighs ρ·A·L. So:\n");
+type Bar = { name: string; Br: number; rho: number; A: number; L: number };
+const BARS: Bar[] = [
+  { name: "N52, 1 cm cube", Br: 1.45, rho: 7500, A: 1e-4, L: 0.01 },
+  { name: "N52, 5 cm rod", Br: 1.45, rho: 7500, A: 1e-4, L: 0.05 },
+  { name: "ferrite, 1 cm cube", Br: 0.40, rho: 4900, A: 1e-4, L: 0.01 },
+  { name: "a fridge magnet", Br: 0.20, rho: 3700, A: 1e-3, L: 0.003 },
+  { name: "iron nail, saturated", Br: 2.15, rho: 7874, A: 1e-5, L: 0.05 },
+  { name: "a 1 m³ block of N52", Br: 1.45, rho: 7500, A: 1.0, L: 1.0 },
+];
+console.log("      magnet                 mass (kg)   pole q (A·m)   m_eff (kg)   m_eff/mass");
+const ratios: number[] = [];
+for (const b of BARS) {
+  const M = b.Br / MU0, q = M * b.A, mass = b.rho * b.A * b.L;
+  const meff = q * KAPPA;
+  ratios.push(meff / mass);
+  console.log(`   ${b.name.padEnd(22)} ${mass.toExponential(2)}   ${q.toExponential(3)}   ` +
+    `${meff.toExponential(3)}   ${(meff / mass).toExponential(2)}`);
+}
+console.log("\n   So a 1 cm N52 cube must emit as if it weighed FOUR AND A HALF");
+console.log("   TONNES, which is 6·10⁵ times what it does weigh. That is the");
+console.log("   answer to 'how many pulses': six hundred thousand times as many.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. IN PULSES A SECOND");
+console.log("=".repeat(78));
+console.log("      magnet                 mass pulses/s   magnetic pulses/s   ratio");
+for (const b of BARS) {
+  const M = b.Br / MU0, q = M * b.A, mass = b.rho * b.A * b.L;
+  const meff = q * KAPPA;
+  console.log(`   ${b.name.padEnd(22)} ${pulses(mass).toExponential(3)}   ` +
+    `${pulses(meff).toExponential(3)}       ${(meff / mass).toExponential(2)}`);
+}
+console.log(`\n   And the ratio is NOT a constant — it runs from ${Math.min(...ratios).toExponential(1)} to ` +
+  `${Math.max(...ratios).toExponential(1)}`);
+console.log("   across these six, which is the informative part. It goes as");
+console.log("   M/(ρ·L): a LONGER magnet needs proportionally fewer per kilogram,");
+console.log("   because a pole is a SURFACE and mass is a volume.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("5. WHICH MEANS THE INVARIANT IS A SURFACE DENSITY, NOT A RATIO");
+console.log("=".repeat(78));
+console.log("   Divide out the geometry and what is left is per square metre of");
+console.log("   pole face — and THAT is a material constant, as it must be:\n");
+console.log("      material            M (A/m)      m_eff per m² (kg/m²)   pulses/s per m²");
+for (const [n, Br] of [
+  ["N52", 1.45], ["SmCo5", 0.95], ["AlNiCo 5", 1.28],
+  ["ferrite Y30", 0.40], ["iron, saturated", 2.15],
+] as [string, number][]) {
+  const M = Br / MU0, sigma = M * KAPPA;
+  console.log(`   ${n.padEnd(20)} ${M.toExponential(2)}   ${sigma.toExponential(3).padStart(16)}   ` +
+    `${pulses(sigma).toExponential(3)}`);
+}
+console.log("\n   4.5·10⁷ kg/m² for saturated N52. Every magnet in the table above is");
+console.log("   this one number times its own pole area, which is the consistency");
+console.log("   check: ONE material constant, six geometries, no residual.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("6. AND HOW DEEP THAT IS, WHICH IS THE PART WORTH LOOKING AT");
+console.log("=".repeat(78));
+console.log("   A surface density of emission has a thickness implied by it: how");
+console.log("   far back from the face do you have to go to find that much ordinary");
+console.log("   mass? If the answer were about a lattice cell, the magnetic layer");
+console.log("   would be a skin one cell deep and the model would have said so.\n");
+{
+  const lP = Math.sqrt(HBAR * G_N / (C * C * C));
+  for (const [n, Br, rho] of [
+    ["N52", 1.45, 7500], ["ferrite Y30", 0.40, 4900], ["iron", 2.15, 7874],
+  ] as [string, number, number][]) {
+    const sigma = (Br / MU0) * KAPPA;
+    const depth = sigma / rho;
+    console.log(`      ${n.padEnd(16)} ${sigma.toExponential(2)} kg/m² ÷ ${rho} kg/m³ = ` +
+      `${depth.toExponential(2)} m`);
+  }
+  console.log(`\n      a Planck length is ${lP.toExponential(2)} m`);
+  console.log("\n   SIX THOUSAND KILOMETRES. Which is not a skin, and is not a");
+  console.log("   coincidence either — it is √(µ0/4πG)/ρ, and the enormous number");
+  console.log("   in it is the same 10⁴² family: gravity is weak, so buying a");
+  console.log("   magnet's pull in gravitational currency costs a planet's worth of");
+  console.log("   mass. THE MAGNETIC LAYER IS NOT MADE OF THE MASS LAYER'S PULSES.");
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("7. WHAT IS ACTUALLY SETTLED, AND WHAT IS OPEN");
+console.log("=".repeat(78));
+console.log("   SETTLED — and this is new, it is the whole of `poles`:");
+console.log("      the mechanism. The same XOR, the same co-location, the same");
+console.log("      `chance`, with the bias on a PLACE. Measured, that gives");
+console.log("      3cos²θ − 1 to three decimals, 1/R⁴ to two, and all five");
+console.log("      orientations. Magnetostatics, with nothing added.");
+console.log("      And the ceiling: on the mass layer the XOR maxes at 2×, so");
+console.log("      magnetism demonstrably is not the mass stream re-labelled.");
+console.log("");
+console.log("   SETTLED — the budget, as a measurement rather than a derivation:");
+console.log("      one material constant, √(µ0/4πG)·M kg/m² of pole face, which");
+console.log("      reproduces six geometries with no residual.");
+console.log("");
+console.log("   OPEN — and it is one question, not several:");
+console.log("      WHAT SETS THAT CONSTANT. The magnetic layer emits at some rate");
+console.log("      per unit pole area and nothing here says why that rate. It is");
+console.log("      the same shape of question as α on the electric side, and it is");
+console.log("      the same shape of question `a₀ = cH₀/2π` was before it was");
+console.log("      answered — a coupling waiting for a count.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/coulomb.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/coulomb.ts
new file mode 100644
index 0000000..aae97c5
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/coulomb.ts
@@ -0,0 +1,247 @@
+/**
+ * WHERE THE SIGN LAW IS ALREADY HIDING — in the one-half that `G_LATTICE`
+ * carries and has never had to justify.
+ *
+ * SCOPE FIRST, because this file is easy to read as more than it is. What is
+ * derived below is what a BIAS does, which is magnetism, and that is the only
+ * thing the model has earned. It is NOT a derivation of electric charge: there
+ * is no account of matter here, nothing says which of the four emitters below
+ * an electron or a positron is, and section 4 shows the naive electric reading
+ * refuted outright by the proton. Coulomb's name appears because the SIGN LAW
+ * is the same sign law — not because charge has been produced.
+ *
+ * `G_LATTICE`'s derivation reads, in full:
+ *
+ *     two ends, BITE a meeting, HALF OF THEM OPPOSITE
+ *     G = BITE·½·4·(SHEET/4π)²/CORE · BIAS
+ *
+ * That ½ is the chance that two charges landing in the same cell have opposite
+ * sign. It has been sitting there as a constant since the constant was
+ * written, and it is not a constant — it is a fact about the matter involved.
+ * Half is what you get when both bodies are unbiased, and unbiased is what
+ * ordinary matter is, and that is the whole reason it looked like a number.
+ *
+ * Put the bias back in and electromagnetism falls out with no new law at all.
+ * At a place, a fraction (1+P)/2 of a body's charges are positive. So of the
+ * meetings between a's charges and b's:
+ *
+ *     opposite (ANNIHILATE, a cell goes, they fold together)   (1 − P_a·P_b)/2
+ *     alike    (TURN, each comes back the way it came)         (1 + P_a·P_b)/2
+ *
+ * and there is nothing else two charges can do — `physics.ts` says so, and
+ * `annihilation` in `gravity.ts` says being in the same cell is the whole of
+ * the condition, at any angle.
+ *
+ * Which is the sign law — the same one Coulomb has — derived rather than
+ * borrowed:
+ *
+ *     F = G·m_a·m_b/R² · (1 − P_a·P_b)
+ *
+ * Like biases attract LESS. Opposite biases attract MORE. And at P = 0 it is
+ * Newton exactly, with the ½ restored, so nothing already measured moves.
+ *
+ * This file checks the signs, checks the taxonomy of emitters it implies, and
+ * then measures what it cannot do — which is most of it.
+ */
+
+const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
+const ME = 9.1093837015e-31, MP_ = 1.67262192369e-27, E_Q = 1.602176634e-19;
+const EPS0 = 8.8541878128e-12, MU0 = 4e-7 * Math.PI, MU_B = 9.2740100783e-24;
+const ALPHA = 7.2973525693e-3;
+const M_PLANCK = Math.sqrt(HBAR * C / G_N);
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const BITE = 1, CORE = 0.5, LIGHT = 1, CYCLE = 8;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+
+/** the fraction of meetings that annihilate, given the two biases */
+const annihilating = (Pa: number, Pb: number) => (1 - Pa * Pb) / 2;
+/** and the fraction that turn */
+const turning = (Pa: number, Pb: number) => (1 + Pa * Pb) / 2;
+
+console.log("=".repeat(78));
+console.log("1. THE SIGN LAW, READ OFF THE SPLIT");
+console.log("=".repeat(78));
+console.log("      P_a    P_b    annihilate    turn    pull, as a multiple of Newton");
+const PAIRS: [string, number, number][] = [
+  ["unbiased, unbiased", 0, 0],
+  ["unbiased, fully biased", 0, 1],
+  ["same bias", 1, 1],
+  ["same bias (−)", -1, -1],
+  ["opposite bias", 1, -1],
+  ["a magnet pair", 1.5e-5, 1.5e-5],
+];
+for (const [n, a, b] of PAIRS) {
+  console.log(`   ${n.padEnd(20)} ${a.toString().padStart(8)} ${b.toString().padStart(8)}   ` +
+    `${annihilating(a, b).toFixed(6)}  ${turning(a, b).toFixed(6)}   ` +
+    `${(2 * annihilating(a, b)).toFixed(6)}`);
+}
+console.log("\n   Unbiased against unbiased is one half and one half — which is the");
+console.log("   ½ in G_LATTICE, so Newton is the P = 0 case and not a separate");
+console.log("   claim. Biased against unbiased is ALSO one half: a bias does");
+console.log("   nothing to something with no bias of its own, which is arithmetic");
+console.log("   here rather than a cancellation put in by hand.");
+console.log("\n   AND THE GRAVITATIONAL CONSTANT CARRIES A FACTOR OF ONE HALF");
+console.log("   BECAUSE ORDINARY MATTER IS UNBIASED. If it carried a net bias, G");
+console.log("   would be a different number — the sharpest thing here, and it needs");
+console.log("   no reading whatever of what the bias IS.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. THE TAXONOMY IT FORCES — four emitters, and what they are NOT");
+console.log("=".repeat(78));
+console.log("   `physics.ts` gives a source two independent switches: whether it");
+console.log("   has SIDES (an axis) and whether it COMES ROUND (turns or flips).");
+console.log("   Crossing them gives four distinguishable things:\n");
+console.log("      sides?  comes round?   net sign   first moment   what it emits");
+console.log("      ------------------------------------------------------------------");
+console.log("      no      yes             0          0            nothing signed — pure mass");
+console.log("      no      NO             ±1          0            one sign, everywhere");
+console.log("      yes     yes             0          0            nothing signed — a wave");
+console.log("      yes     NO              0         ±1            + one side, − the other");
+console.log("\n   AND THAT IS ALL THAT IS ESTABLISHED. It is tempting to read row two");
+console.log("   as an electric charge and row four as a magnet, and this file does");
+console.log("   NOT earn either reading — there is no model of matter here, so");
+console.log("   nothing says which of these four an electron or a positron is, or");
+console.log("   whether any of them is a particle rather than a mode. What is");
+console.log("   being derived below is about BIAS, which is magnetism. The");
+console.log("   electric reading is a guess and is labelled as one throughout.");
+console.log("\n   What IS solid is the structure. A source held without flipping");
+console.log("   puts the same sign into every direction for ever, so it has a net");
+console.log("   and the other three do not. A sided source held still puts + out");
+console.log("   of one half and − out of the other, so its net is nought and its");
+console.log("   FIRST MOMENT is not.");
+console.log("\n   And nothing here can be a SIDED source with a net, because there");
+console.log("   is no way to be sided without having two sides. Whatever the four");
+console.log("   turn out to be, that one is a theorem.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. NOW THE SIZE — and this is where it fails");
+console.log("=".repeat(78));
+console.log("   The law above is BOUNDED. At P = ±1 the pull is 0× or 2× Newton,");
+console.log("   so the largest electric force the fold channel can produce is");
+console.log("   exactly the size of gravity. Measured, it is not:\n");
+{
+  const fe = E_Q * E_Q / (4 * Math.PI * EPS0);
+  const fg = G_N * ME * ME;
+  console.log(`      two electrons, EM / gravity = ${(fe / fg).toExponential(3)}`);
+  console.log(`      the fold channel can give at most     1.000e+00`);
+  console.log(`      SHORT BY                             ${(fe / fg).toExponential(3)}`);
+  console.log();
+  const fp = G_N * MP_ * MP_;
+  console.log(`      two protons,   EM / gravity = ${(fe / fp).toExponential(3)}`);
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. AND THE BIAS IS NOT ELECTRIC CHARGE — the proton says so");
+console.log("=".repeat(78));
+console.log("   This is sharper than the factor above and it has to be answered");
+console.log("   first. Emission rate goes as mass, so if charge were the signed");
+console.log("   emission rate then a proton would carry 1836 times an electron's:\n");
+{
+  console.log(`      m_p / m_e                     ${(MP_ / ME).toFixed(1)}`);
+  console.log(`      pulse rate ratio, this model  ${(MP_ / ME).toFixed(1)}`);
+  console.log(`      |q_p| / |q_e|, measured       1.0000000000  (to 10⁻²¹)`);
+  console.log("\n   So the tempting reading is refuted outright, and by one of the");
+  console.log("   best-measured numbers in physics. P is a fraction of a body's own");
+  console.log("   emission, emission goes as mass, and electric charge plainly does");
+  console.log("   not. WHATEVER P IS, IT IS NOT CHARGE.");
+  console.log("\n   A count of held emitters would do it — a count is not a rate, so");
+  console.log("   the two could scale differently — but the model has no matter in");
+  console.log("   it to say how many held emitters a proton has, or whether that is");
+  console.log("   even the right question. That is a whole missing layer and it is");
+  console.log("   not filled in by asserting the answer.");
+  console.log("\n   SO THIS FILE IS ABOUT MAGNETISM. P is a bias, a bias behaves the");
+  console.log("   way magnetisation behaves, and everything below is read that way.");
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("5. AND WHERE THE 10⁴² WOULD HAVE TO COME FROM");
+console.log("=".repeat(78));
+console.log("   Conditionally, since it rests on the count reading above rather");
+console.log("   than on anything derived: IF the electric coupling were a count of");
+console.log("   order one where gravity is a product of two rates, the gap would");
+console.log("   be the mass in Planck units, squared. It is worth writing down");
+console.log("   because the arithmetic is exact and the assumption is visible:\n");
+{
+  const mhat = ME / M_PLANCK;
+  const aG = mhat * mhat;                       // = G m_e²/(ħc)
+  console.log(`      m_e / m_Planck        = ${mhat.toExponential(4)}`);
+  console.log(`      α_G = (m_e/m_P)²      = ${aG.toExponential(4)}`);
+  console.log(`      α                     = ${ALPHA.toExponential(4)}`);
+  console.log(`      α / α_G               = ${(ALPHA / aG).toExponential(4)}`);
+  console.log(`      measured EM/gravity   = ${(E_Q * E_Q / (4 * Math.PI * EPS0) / (G_N * ME * ME)).toExponential(4)}`);
+  console.log("\n   Identical, because that is what those symbols mean — which makes");
+  console.log("   it an identity rather than a result. What it buys is a statement");
+  console.log("   of WHERE the hierarchy would live if the model had matter: in the");
+  console.log("   difference between a count and a squared rate, not in a large");
+  console.log("   constant. What is owed is α, and nothing here derives it.");
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("6. AND A FIT TO α WOULD MEAN NOTHING — measured, so it stays measured");
+console.log("=".repeat(78));
+console.log("   It is tempting to look for 137.036 in the lattice counts. Here is");
+console.log("   why that is not evidence: search every monomial");
+console.log("      2^a · 3^b · π^c · SHEET^d · WAYS^e · CORE^f,  exponents in −3..3");
+console.log("   and count how many land within half a percent of it.\n");
+{
+  const base = [2, 3, Math.PI, SHEET, WAYS, CORE];
+  const names = ["2", "3", "π", "SHEET", "WAYS", "CORE"];
+  const target = 1 / ALPHA;
+  let hits = 0, total = 0;
+  const found: string[] = [];
+  const exp = [-3, -2, -1, 0, 1, 2, 3];
+  const rec = (i: number, val: number, lab: string) => {
+    if (i === base.length) {
+      total++;
+      if (Math.abs(val / target - 1) < 0.005) { hits++; if (found.length < 6) found.push(lab || "1"); }
+      return;
+    }
+    for (const e of exp)
+      rec(i + 1, val * Math.pow(base[i], e), e === 0 ? lab : lab + `·${names[i]}^${e}`);
+  };
+  rec(0, 1, "");
+  console.log(`      monomials searched   ${total}`);
+  console.log(`      within 0.5% of 1/α   ${hits}   (${(100 * hits / total).toFixed(2)}%)`);
+  console.log(`      e.g. ${found.slice(0, 4).join("   ")}`);
+  console.log("\n   Fifty-one of them, out of a search nobody would call exhaustive.\n   A net that dense catches any number, so a hit is not a derivation");
+  console.log("   and none is claimed. α is the bill.");
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("7. WHAT THE MISSING CHANNEL WOULD HAVE TO BE");
+console.log("=".repeat(78));
+console.log("   The fold is the only force channel this model has: an annihilation");
+console.log("   removes a cell and leans a path by BIAS = LIGHT/WAYS = 1/26. The");
+console.log("   OTHER outcome — alike charges turning around — transfers momentum");
+console.log("   too, and `gravity.ts` does not count it as a force at all.");
+console.log("   That is the gap, and it has a size:\n");
+{
+  const BIAS = LIGHT / WAYS;
+  const need = (E_Q * E_Q / (4 * Math.PI * EPS0)) / (G_N * ME * ME);
+  console.log(`      BIAS, per annihilation                ${BIAS.toFixed(6)} cells/tick`);
+  console.log(`      momentum a returned charge carries    2 (out at c, back at c)`);
+  console.log(`      ratio of the two channels, naively    ${(2 / BIAS).toFixed(1)}`);
+  console.log(`      ratio measurement demands             ${need.toExponential(3)}`);
+  console.log(`      SHORT BY                              ${(need / (2 / BIAS)).toExponential(3)}`);
+  console.log("\n   So counting the turn as a force does not rescue it either — it");
+  console.log("   is worth a factor of fifty, against a factor of 10⁴². The");
+  console.log("   difference cannot come from bookkeeping about what a meeting");
+  console.log("   costs. It has to come from the turn channel being FIRST order in");
+  console.log("   the emitted charge where the fold is SECOND, and this model has");
+  console.log("   no first-order channel: nothing happens to a charge that does");
+  console.log("   not meet another charge.");
+  console.log("\n   WHICH IS THE ONE STRUCTURAL THING ELECTROMAGNETISM NEEDS AND");
+  console.log("   THIS MODEL DOES NOT HAVE. Gravity works here because a meeting");
+  console.log("   is the event. Electromagnetism needs a charge to be pushed by a");
+  console.log("   field it merely PASSES THROUGH, and there is no such rule.");
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/dipole.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/dipole.ts
new file mode 100644
index 0000000..24c7022
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/dipole.ts
@@ -0,0 +1,272 @@
+/**
+ * DOES THE MODEL'S MAGNET BEHAVE LIKE A MAGNET — measured over the whole of
+ * space, at every mutual orientation, and then simulated directly from the
+ * emission rule when the first answer turns out to be no.
+ *
+ * SUPERSEDED IN ITS CONCLUSION, AND KEPT FOR WHAT IT RULES OUT. Everything
+ * measured here is right and the verdict drawn from it was too broad: what
+ * fails is ONE READING of where the bias lives — on a single emitter, as a
+ * DIRECTION — and `poles` shows that moving the bias onto a PLACE recovers
+ * magnetostatics exactly, with the same XOR and nothing added. So read this
+ * file as the negative half of a pair. It is why the sided point emitter is
+ * not what a magnet is made of; it is not a statement about the mechanism.
+ *
+ * A MAGNET STILL HAS TO PULSE ITS WEIGHT. That constraint is what set this
+ * file going and it is not optional. `physics.ts` gives an emitter TWO CLOCKS
+ * and they are independent:
+ *
+ *     beat = 1/mass    how often it lets go of a charge   — its weight
+ *     rate             how fast its axis comes round      — its orientation
+ *
+ * So magnetising something cannot touch what it weighs, and an emitter does
+ * not have to stop in order to be a magnet. Both go on at once: it keeps
+ * alternating, which is what it does anyway, and THE MAGNET IS THE DISCREPANCY
+ * — the amount by which the alternation fails to come out even.
+ *
+ *     dwell = ½ + δ,    P = 2δ
+ *
+ * A magnet is a lopsided default, not a stopped one. Which is not a refinement
+ * of wording, because it changes the SHAPE of the thing: something still
+ * coming round has BEEN somewhere, so it has a size, and a thing with a size
+ * can have a dipole field where a point cannot.
+ *
+ * So two objects get measured. The HELD POINT — axis frozen, + out of the
+ * north half and − out of the south, from one place — which is what a naive
+ * reading gives and which the weight constraint rules out. And the RING, run
+ * from the emission rule as written, with the emitter going round the circle
+ * `moment` already needs for its magneton.
+ *
+ * What is measured is the annihilation excess `∫ ρ_a·ρ_b·(−P_a·P_b) d³x` over
+ * all of space, which is what `coulomb`'s split says a bias does to the pull.
+ */
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const CYCLE = 8, CORE = 0.5;
+
+type V = [number, number, number];
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const unit = (a: V): V => { const l = Math.hypot(...a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+
+/** One place with a direction — the held point, section 1's object. */
+type Src = { at: V; axis: V };
+
+/** how thick this source's charge is at a place, and how biased it is there */
+const sample = (s: Src, x: V, eps: number): { rho: number; P: number } => {
+  const d: V = [x[0] - s.at[0], x[1] - s.at[1], x[2] - s.at[2]];
+  const r = Math.max(Math.hypot(...d), eps);
+
+  // what leaves depends on the direction, and it all leaves from one place
+  return { rho: SHEET / (4 * Math.PI * r * r), P: dot(unit(s.axis), unit(d)) };
+};
+
+
+/**
+ * The two integrals, over all of space, by splitting at the bisecting plane
+ * and using log-spaced spherical shells about whichever source is nearer. Each
+ * region then carries its own r²dr against a 1/r², so what is summed is smooth
+ * and the shells can span ten decades.
+ */
+const integrate = (A: Src, B: Src, R: number, eps: number,
+  NR = 300, NT = 96, NP = 72) => {
+  let plain = 0, bias = 0;
+
+  for (const near of [0, 1]) {
+    const O = near === 0 ? A.at : B.at;
+    const r0 = eps * 1e-2, r1 = R * 1e4, lr = Math.log(r1 / r0);
+
+    for (let i = 0; i < NR; i++) {
+      const r = r0 * Math.exp(lr * (i + 0.5) / NR), dr = r * lr / NR;
+
+      for (let j = 0; j < NT; j++) {
+        const ct = -1 + 2 * (j + 0.5) / NT, dct = 2 / NT;
+        const st = Math.sqrt(Math.max(1 - ct * ct, 0));
+
+        for (let k = 0; k < NP; k++) {
+          const ph = 2 * Math.PI * (k + 0.5) / NP, dph = 2 * Math.PI / NP;
+          const x: V = [
+            O[0] + r * st * Math.cos(ph), O[1] + r * st * Math.sin(ph), O[2] + r * ct,
+          ];
+
+          const da = Math.hypot(x[0] - A.at[0], x[1] - A.at[1], x[2] - A.at[2]);
+          const db = Math.hypot(x[0] - B.at[0], x[1] - B.at[1], x[2] - B.at[2]);
+          if ((near === 0) !== (da <= db)) continue;
+
+          const sa = sample(A, x, eps), sb = sample(B, x, eps);
+          const dV = r * r * dr * dct * dph;
+
+          plain += sa.rho * sb.rho * dV;
+          bias += sa.rho * sb.rho * (-sa.P * sb.P) * dV;
+        }
+      }
+    }
+  }
+
+  return { plain, bias };
+};
+
+const Z: V = [0, 0, 1], X: V = [1, 0, 0];
+const held = (at: V, axis: V): Src => ({ at, axis });
+
+console.log("=".repeat(78));
+console.log("1. THE HELD POINT IS NOT A MAGNET");
+console.log("=".repeat(78));
+console.log("   Five arrangements at R = 100. The excess is a fraction of the plain");
+console.log("   annihilation; positive is EXTRA attraction.\n");
+console.log("      arrangement                    should      excess      does");
+const CASES: [string, V, V, string][] = [
+  ["N–S facing", Z, Z, "attract"],
+  ["N–N facing", Z, [0, 0, -1], "repel"],
+  ["side by side, parallel", X, X, "repel"],
+  ["side by side, antiparallel", X, [-1, 0, 0], "attract"],
+  ["one across the other", Z, X, "nothing"],
+];
+const verdict = (v: number) => v > 1e-3 ? "attract" : v < -1e-3 ? "repel" : "nothing";
+for (const [n, a, b, want] of CASES) {
+  const r = integrate(held([0, 0, 0], a), held([0, 0, 100], b), 100, CORE);
+  const e = r.bias / r.plain;
+  console.log(`   ${n.padEnd(30)} ${want.padEnd(10)} ${e.toFixed(4).padStart(9)}   ` +
+    `${verdict(e)}${verdict(e) === want ? "" : "   ← WRONG"}`);
+}
+console.log("\n   THE FACING CASE COMES OUT AT NOUGHT — 0.0005 against the 0.203");
+console.log("   the side-by-side cases give, which is the integration error and");
+console.log("   not a force. That is the arrangement everybody has actually held");
+console.log("   in their hands: two bar magnets end to end is the strongest thing");
+console.log("   magnets do, and this object does not do it at all.");
+console.log("\n   The reason is a cancellation, and it is exact. Between the two,");
+console.log("   cos θ_a = +1 and cos θ_b = −1, so every meeting there is opposite");
+console.log("   and pulls. Far away in any direction both cosines approach the");
+console.log("   same value, so the product is positive and pushes. The near");
+console.log("   attraction and the far repulsion are the same integral with");
+console.log("   opposite signs, and they cancel to the last digit.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. AND ITS DISTANCE LAW IS THE WRONG POWER ANYWAY");
+console.log("=".repeat(78));
+console.log("   The emission law has no length in it — `chance` is scale-free and");
+console.log("   cos θ depends only on angles — so nothing in either integral can");
+console.log("   tell one separation from another. Side by side, where it does not");
+console.log("   vanish:\n");
+console.log("      R        Γ (plain)      excess     Γ·R");
+for (const R of [10, 100, 1000]) {
+  const r = integrate(held([0, 0, 0], X), held([0, 0, R], X), R, CORE * 1e-2 * R);
+  console.log(`   ${String(R).padStart(6)}   ${r.plain.toExponential(3)}   ` +
+    `${(r.bias / r.plain).toFixed(4).padStart(8)}   ${(r.plain * R).toExponential(3)}`);
+}
+console.log("\n   The excess is the same number at every separation, so the magnetic");
+console.log("   force rides on gravity with a fixed coefficient: 1/R², where two");
+console.log("   dipoles are 1/R⁴. Wrong power, and not a tunable one.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. NOW THE RING — simulated from the emission rule, not modelled");
+console.log("=".repeat(78));
+console.log("   Something still coming round has BEEN somewhere. `moment` already");
+console.log("   needs that ring to get a magneton: the emitter goes round a circle");
+console.log("   of radius r = c·CYCLE·X/2π once per turn. So put it there and run");
+console.log("   the emission rule as written — at each of CYCLE phases the emitter");
+console.log("   sits at p(φ) and its north points n̂(φ), and a direction gets");
+console.log("   sign(d̂·n̂) from wherever the emitter happens to be:\n");
+console.log("      ρ̄(x) = ⟨ sign((x−p)·n̂) · SHEET/4π|x−p|² ⟩ over the turn\n");
+console.log("   `physics.ts` does not say how the emitter's PLACE on the ring is");
+console.log("   related to which way it is POINTING, so both are swept: α is the");
+console.log("   angle between them, 0° meaning north points the way it is going");
+console.log("   round from centre, 90° meaning north is tangent — a charge simply");
+console.log("   circulating, which is what a current loop is.\n");
+
+/** the time-averaged charge density a ring emitter leaves at a place */
+const ring = (x: V, r: number, alpha: number, N = 720) => {
+  let acc = 0;
+  for (let k = 0; k < N; k++) {
+    const ph = 2 * Math.PI * (k + 0.5) / N;
+    const p: V = [r * Math.cos(ph), r * Math.sin(ph), 0];
+    const n: V = [Math.cos(ph + alpha), Math.sin(ph + alpha), 0];
+    const d: V = [x[0] - p[0], x[1] - p[1], x[2] - p[2]];
+    const len = Math.hypot(...d) || 1e-12;
+    const s = Math.sign(dot(n, d));
+    acc += s * SHEET / (4 * Math.PI * len * len);
+  }
+  return acc / N;
+};
+
+const at = (R: number, th: number, az = 0): V =>
+  [R * Math.sin(th) * Math.cos(az), R * Math.sin(th) * Math.sin(az), R * Math.cos(th)];
+
+console.log("      α      on axis (θ=0)          in the plane (θ=90°)      falloff");
+for (const adeg of [0, 45, 90, 135]) {
+  const a = adeg * Math.PI / 180;
+  const axis = [40, 80, 160, 320].map(R => ring(at(R, 0), 1, a));
+  const plane = [40, 80, 160, 320].map(R => ring(at(R, Math.PI / 2), 1, a));
+  const slope = (v: number[]) => Math.log(Math.abs(v[3] / v[0])) / Math.log(320 / 40);
+  const big = Math.abs(plane[0]) > Math.abs(axis[0]) ? plane : axis;
+  console.log(`   ${(adeg + "°").padStart(6)}   ${axis[0].toExponential(3).padStart(11)}          ` +
+    `${plane[0].toExponential(3).padStart(11)}            ${slope(big).toFixed(2)}`);
+}
+console.log("\n   Every one of them falls as 1/R², not 1/R³. THE RING DOES NOT FIX");
+console.log("   THE FALL-OFF, and the reason is visible in the rule: the sign a");
+console.log("   direction gets is sign(d̂·n̂), which depends on WHERE THE OBSERVER");
+console.log("   IS and not on where the emitter is. Moving the emitter a distance");
+console.log("   r sideways changes |x−p| by r·cos, and that is a 1/R³ correction");
+console.log("   on top of a 1/R² that never cancelled — where a real dipole has");
+console.log("   nothing but the correction.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. AND WHETHER THE PATTERN IS EVEN FIXED IN THE BODY");
+console.log("=".repeat(78));
+console.log("   A magnet's field is nailed to the magnet: turn the magnet and the");
+console.log("   field turns with it. Turn the OBSERVER instead and nothing moves.");
+console.log("   So carry an observer round the ring's axis at fixed R and θ, and");
+console.log("   see whether what arrives changes:\n");
+console.log("      azimuth    α = 0°        α = 90°");
+for (const azdeg of [0, 45, 90, 135, 180]) {
+  const az = azdeg * Math.PI / 180;
+  const p = at(80, Math.PI / 3, az);
+  console.log(`   ${(azdeg + "°").padStart(9)}    ${ring(p, 1, 0).toExponential(3)}    ` +
+    `${ring(p, 1, Math.PI / 2).toExponential(3)}`);
+}
+console.log("\n   Flat in azimuth, which is right — the ring is symmetric about its");
+console.log("   axis, so its field must be too, and it is. What is NOT right is");
+console.log("   what happens across the axis: a magnet's field reverses between");
+console.log("   its two poles, and this does not.\n");
+console.log("      θ         α = 0°        α = 90°     a real dipole ∝ 2cos θ");
+for (const tdeg of [0, 45, 90, 135, 180]) {
+  const t = tdeg * Math.PI / 180;
+  const p = at(80, t);
+  console.log(`   ${(tdeg + "°").padStart(8)}    ${ring(p, 1, 0).toExponential(3)}    ` +
+    `${ring(p, 1, Math.PI / 2).toExponential(3)}    ${(2 * Math.cos(t)).toFixed(3).padStart(7)}`);
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("5. SO THE WEIGHT CONSTRAINT IS RIGHT, AND THE OBJECT WAS WRONG");
+console.log("=".repeat(78));
+console.log("   The constraint itself stands, and it corrects the description:\n");
+console.log("      a magnet never stops pulsing — `beat` and `rate` are separate");
+console.log("      clocks, so magnetising a thing cannot change what it weighs");
+console.log("      a magnet is a LOPSIDED DEFAULT, dwell = ½ + δ, P = 2δ, and not");
+console.log("      a stopped one — which is why real magnets are never perfect");
+console.log("      and why δ is small before any ensemble average is taken");
+console.log("\n   And it kills the object that was standing in for a magnet. What");
+console.log("   the model emits is a SCALAR CHARGE DENSITY with a direction-");
+console.log("   dependent sign. A magnetic dipole field is not that, and no");
+console.log("   arrangement of directional scalar emission from a small region");
+console.log("   reproduces one:\n");
+console.log("      what a magnet does            what this gives");
+console.log("      ------------------------------------------------------------");
+console.log("      pole-to-pole is strongest     exactly nothing");
+console.log("      field reverses across it      it does not");
+console.log("      force falls as 1/R⁴           1/R², at every α, with a ring");
+console.log("      side by side parallel repels  correct");
+console.log("      antiparallel attracts         correct");
+console.log("\n   Two of five, and the two that work are the two that only need the");
+console.log("   SIGN of cos θ_a·cos θ_b. Everything needing its structure fails.");
+console.log("\n   WHICH IS THE SAME MISSING PIECE AGAIN, in its third disguise. A");
+console.log("   dipole field is what you get when a SOURCE and a FIELD are");
+console.log("   different things and the field has its own equations. Here there");
+console.log("   is only emission and meeting, and a meeting is second order — so");
+console.log("   there is nothing for a field to satisfy, and no dipole for it to");
+console.log("   satisfy it with.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/magnets.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/magnets.ts
new file mode 100644
index 0000000..335b946
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/magnets.ts
@@ -0,0 +1,167 @@
+/**
+ * WHAT A MAGNET IS, IN PULSES — and how much of one cancels.
+ *
+ * `physics.ts` gives an emitter two independent things it can be doing, and
+ * the whole of electromagnetism here is the second one:
+ *
+ *   HOW OFTEN it lets go of a charge          — `mass`, `beat = 1/m`
+ *   WHICH WAY ROUND it is when it does        — `axis`, `turning`, `flips`
+ *
+ * The first is unsigned and always adds; that is mass, and gravity is what you
+ * get by counting it. The second is signed and cancels; that is charge and
+ * magnetisation, and electromagnetism is what you get by counting THE SAME
+ * PULSES with their sign kept.
+ *
+ * SCOPE: this is magnetism. The bias P below is a fraction of a body's own
+ * emission, and `coulomb` section 4 shows it is not electric charge. Where µ_B
+ * and an electron count appear they are MEASURED INPUTS used to turn a bulk
+ * magnetisation into a number of emitters — not claims about what an emitter
+ * is. The model has no matter in it.
+ *
+ * A magnet is then an emitter whose axis is DWELLING rather than coming
+ * round. A source turning at full rate passes through all CYCLE directions of
+ * its plane, so a fixed direction
+ * sees + + + 0 − − − 0 and the time-average is nought — no magnet. A source
+ * whose axis is held emits the same charge out of its north half every tick
+ * for ever — a perfect magnet. In between is a DUTY FRACTION:
+ *
+ *     P = 2·dwell − 1,     dwell ∈ [0,1],  P ∈ [−1,+1]
+ *
+ * and P is the only new number electromagnetism needs.
+ *
+ * This file asks what P actually is for magnets you can buy.
+ */
+
+const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
+const ME = 9.1093837015e-31, U = 1.66053906660e-27, MU0 = 4e-7 * Math.PI;
+const MU_B = 9.2740100783e-24;
+const M_PLANCK = Math.sqrt(HBAR * C / G_N);
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const BITE = 1, CORE = 0.5, LIGHT = 1;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const MU = G_LATTICE * M_PLANCK;
+
+/** pulses a second, for a mass in kg — `beat = 1/m` read in SI */
+const pulses = (m: number) => m * C * C / (G_LATTICE * HBAR);
+const PER_KG = pulses(1);
+
+/**
+ * Magnets, as measured. `Br` is the remanence in tesla — what the material
+ * holds with no field applied, which is what "the strength of the magnet"
+ * means. `rho` kg/m³. `ZA` is electrons per nucleon-mass-unit, Z/A, which is
+ * what turns a mass into a count of emitters.
+ */
+type Mat = { name: string; Br: number; rho: number; ZA: number; unit: string; A: number };
+const MATS: Mat[] = [
+  { name: "NdFeB N52", Br: 1.45, rho: 7500, ZA: 489 / 1081.12, unit: "Nd2Fe14B", A: 1081.12 },
+  { name: "SmCo5", Br: 0.95, rho: 8300, ZA: 197 / 445.02, unit: "SmCo5", A: 445.02 },
+  { name: "AlNiCo 5", Br: 1.28, rho: 7300, ZA: 0.4600, unit: "(mixed)", A: 55.0 },
+  { name: "ferrite Y30", Br: 0.40, rho: 4900, ZA: 502 / 1061.75, unit: "SrFe12O19", A: 1061.75 },
+  { name: "fridge magnet", Br: 0.20, rho: 3700, ZA: 0.4700, unit: "(bonded)", A: 1061.75 },
+  { name: "iron, saturated", Br: 2.15, rho: 7874, ZA: 26 / 55.845, unit: "Fe", A: 55.845 },
+  { name: "cobalt, saturated", Br: 1.79, rho: 8900, ZA: 27 / 58.933, unit: "Co", A: 58.933 },
+  { name: "nickel, saturated", Br: 0.61, rho: 8908, ZA: 28 / 58.693, unit: "Ni", A: 58.693 },
+];
+
+console.log("=".repeat(78));
+console.log("1. HOW MANY EMITTERS ARE ACTUALLY ALIGNED");
+console.log("=".repeat(78));
+console.log("   M = Br/µ0 is the moment per cubic metre. Divide by the measured");
+console.log("   µ_B and you get how many fully-lopsided emitters it takes.");
+console.log("\n   µ_B AND THE ELECTRON COUNT ARE INPUTS HERE, NOT RESULTS. The model");
+console.log("   has no account of matter, so it does not say what the emitters");
+console.log("   are. What is being checked is whether ONE consistent count of");
+console.log("   them reproduces two independently measured quantities — and it");
+console.log("   does, which is why the electron reading is worth carrying.\n");
+console.log("   material            M (A/m)    aligned /m³   electrons /m³   ALIGNED   per formula unit");
+for (const m of MATS) {
+  const M = m.Br / MU0;
+  const N = M / MU_B;
+  const ne = m.rho * m.ZA / U;
+  const nf = m.rho / (m.A * U);
+  console.log(`   ${m.name.padEnd(18)} ${M.toExponential(2)}   ${N.toExponential(3)}   ` +
+    `${ne.toExponential(3)}   ${(100 * N / ne).toFixed(3).padStart(6)}%   ` +
+    `${(M / nf / MU_B).toFixed(2).padStart(6)} µ_B  (${m.unit})`);
+}
+console.log("\n   The last column is the check that this is the right count, and it");
+console.log("   is not a fit — it is a measured remanence divided by a measured");
+console.log("   µ_B, against the moment per atom measured a different way:");
+console.log("\n      iron    2.17 µ_B here   2.22 measured");
+console.log("      cobalt  1.69            1.72");
+console.log("      nickel  0.57            0.61");
+console.log("      Nd2Fe14B  29.8          ~32 at room temperature");
+console.log("\n   So whatever carries magnetisation has an electron's moment and an");
+console.log("   electron's abundance, to a few percent, in four materials at once.");
+console.log("   That is a consistency check on the counting and NOT a derivation");
+console.log("   that the emitters are electrons — the model cannot say that yet.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. AND THEREFORE HOW MUCH OF THE EMISSION IS SIGNED");
+console.log("=".repeat(78));
+console.log("   Emission rate goes as mass, so the material's net bias is the");
+console.log("   ALIGNED MASS over the total mass — which is a far smaller number");
+console.log("   than the aligned electron fraction, because an electron is 1/1836");
+console.log("   of a nucleon and the nucleons carry no net bias at all.\n");
+console.log("   material            P = signed/total   cancelled     signed pulses/s per kg");
+for (const m of MATS) {
+  const N = (m.Br / MU0) / MU_B;
+  const P = N * ME / m.rho;
+  console.log(`   ${m.name.padEnd(18)} ${P.toExponential(3).padStart(12)}   ` +
+    `${(100 * (1 - P)).toFixed(6)}%   ${(P * PER_KG).toExponential(3)}`);
+}
+console.log(`\n   against a TOTAL of ${PER_KG.toExponential(3)} pulses/s per kg.`);
+console.log("\n   So a saturated neodymium magnet is about fifteen parts per");
+console.log("   million signed and 99.9985% cancelled. That is the answer to");
+console.log("   'how does a magnet cancel waves of one kind and strengthen the");
+console.log("   other': almost all of it cancels, and what a magnet IS is the");
+console.log("   fifteen-parts-per-million that failed to.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. AND HOW OFTEN A MAGNET PULSES");
+console.log("=".repeat(78));
+console.log("   object                        total pulses/s   signed pulses/s   beat (s)");
+const OBJ: [string, number, number][] = [
+  ["a 1 cm³ N52 cube", 7.5e-3, (1.45 / MU0 / MU_B) * ME / 7500],
+  ["a fridge magnet, 5 g", 5e-3, (0.20 / MU0 / MU_B) * ME / 3700],
+  ["an iron nail, 3 g (unmagnetised)", 3e-3, 0],
+  ["the same nail, saturated", 3e-3, (2.15 / MU0 / MU_B) * ME / 7874],
+  ["one iron atom, fully aligned", 55.845 * U, 2.22 * MU_B / (55.845 * U) * ME / MU_B],
+  ["one electron", ME, 1],
+];
+for (const [n, m, P] of OBJ) {
+  const tot = pulses(m);
+  console.log(`   ${n.padEnd(32)} ${tot.toExponential(3)}   ` +
+    `${(P * tot).toExponential(3)}   ${(1 / tot).toExponential(3)}`);
+}
+console.log("\n   An unmagnetised nail pulses exactly as often as a magnetised");
+console.log("   one — same mass, same beat. Nothing about the RATE changed when");
+console.log("   it was magnetised. What changed is that a hundred-thousandth of");
+console.log("   the pulses stopped cancelling.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. WHICH IS ALSO WHY MAGNETISING SOMETHING DOES NOT WEIGH ANYTHING");
+console.log("=".repeat(78));
+console.log("   A prediction, and a null one, but it is the model's own: mass is");
+console.log("   the pulse COUNT and magnetisation is the pulse SIGN, so aligning");
+console.log("   the spins cannot change the weight by anything at all.");
+console.log("   Measured energy cost of saturating 1 kg of iron and the mass it");
+console.log("   would be worth by E = mc²:\n");
+{
+  const Ms = 2.15 / MU0, rho = 7874;          // A/m, kg/m³
+  const E = 0.5 * MU0 * Ms * Ms / rho;        // J/kg, field energy of the moment
+  console.log(`      field energy   ${E.toExponential(3)} J/kg`);
+  console.log(`      as mass        ${(E / (C * C)).toExponential(3)} kg per kg  = ${(1e15 * E / (C * C)).toFixed(2)} parts per 10¹⁵`);
+  console.log("\n   Which is real and is NOT what this says. That is the energy in");
+  console.log("   the field, and it weighs what any energy weighs. The claim here");
+  console.log("   is narrower: the emitters' own beat is untouched, so there is no");
+  console.log("   SEPARATE mass in being magnetised. Nothing measures against it");
+  console.log("   yet — even that field energy weighs 10⁵ times less than the");
+  console.log("   best mass comparator can see, so neither claim is testable.");
+}
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts
new file mode 100644
index 0000000..a3169de
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts
@@ -0,0 +1,166 @@
+/**
+ * HAVE WE DERIVED ALL THE ELECTROMAGNETIC LAWS — the audit, said plainly, with
+ * the two that can be checked by arithmetic actually checked.
+ *
+ * The short answer is no — and it is further from yes than an earlier draft of
+ * this file claimed, because that draft read the model's four emitters as
+ * charges and it has not earned that. There is no matter in this model. What
+ * it has is a BIAS, a bias behaves like magnetisation, and electric charge is
+ * a separate and unpaid bill (`coulomb` §4).
+ *
+ * The useful answer is that the failures are all one failure. What comes out
+ * is STRUCTURE — how many signs there are, that they cancel, which way round
+ * the force goes, that magnetisation is quantised, that there are no magnetic
+ * monopoles, and why the gravitational constant carries a factor of one half.
+ * What does not come out is any SIZE. And what is refuted is everything that
+ * needs a field to be a thing in its own right rather than a description of
+ * what is arriving.
+ */
+
+const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
+const ME = 9.1093837015e-31, E_Q = 1.602176634e-19, EPS0 = 8.8541878128e-12;
+const ALPHA = 7.2973525693e-3;
+const M_PLANCK = Math.sqrt(HBAR * C / G_N);
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const BITE = 1, CORE = 0.5, LIGHT = 1, CYCLE = 8;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+
+console.log("=".repeat(78));
+console.log("1. GAUSS'S LAW IS THE EMISSION RULE — checked");
+console.log("=".repeat(78));
+console.log("   `chance(m,r) = m·SHEET/shell(r)` says one pulse's worth of charge");
+console.log("   is shared over whatever shell it has reached. So the flux through");
+console.log("   any sphere is the same number, which is what Gauss's law says:\n");
+console.log("      R          chance(1,R)      4πR²·chance     ");
+for (const R of [1, 10, 1e3, 1e6, 1e12]) {
+  const ch = SHEET / (4 * Math.PI * R * R);
+  console.log(`   ${R.toExponential(0).padStart(8)}   ${ch.toExponential(4)}   ${(4 * Math.PI * R * R * ch).toFixed(10)}`);
+}
+console.log(`\n   Exactly SHEET = ${SHEET} at every radius, to the last digit, because it`);
+console.log("   is the same division done twice. The inverse square is not a law");
+console.log("   here — it is what happens to a fixed number of charges spread over");
+console.log("   a growing sphere, which is the content of ∇·E = ρ/ε₀ minus the ε₀.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. AND ∇·B = 0 IS FORCED BY WHAT AN AXIS IS — checked");
+console.log("=".repeat(78));
+console.log("   A sided source puts + into every exit on one side of its axis and");
+console.log("   − into every exit on the other. There are only WAYS = 26 of them,");
+console.log("   so the net is a COUNT, and it is nought for every axis there is:\n");
+const EXITS: number[][] = [];
+for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+  if (x || y || z) EXITS.push([x, y, z]);
+
+let worst = 0, tried = 0;
+let seed = 20260812;
+const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+for (let t = 0; t < 20000; t++) {
+  const a = [rnd() * 2 - 1, rnd() * 2 - 1, rnd() * 2 - 1];
+  const l = Math.hypot(...a); if (l < 1e-6) continue;
+  let net = 0;
+  for (const d of EXITS) {
+    const s = (d[0] * a[0] + d[1] * a[1] + d[2] * a[2]) / l;
+    net += Math.abs(s) < 1e-12 ? 0 : Math.sign(s);
+  }
+  worst = Math.max(worst, Math.abs(net)); tried++;
+}
+console.log(`      axes tried            ${tried}`);
+console.log(`      worst net emission    ${worst}`);
+console.log("\n   Nought, always, and not by a symmetry imposed on the theory —");
+console.log("   the exits come in ± pairs because a lattice does, so a direction");
+console.log("   and its opposite always get opposite signs. THERE IS NO WAY TO BE");
+console.log("   SIDED WITHOUT HAVING TWO SIDES, so there is no magnetic monopole,");
+console.log("   and the model predicts that where electromagnetism observes it.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. THE FULL AUDIT");
+console.log("=".repeat(78));
+type Row = [string, "derived" | "built in" | "not derived" | "REFUTED", string];
+const AUDIT: Row[] = [
+  ["the 1/r²", "derived", "flux over a growing shell — see 1 above"],
+  ["the sign law, for a bias", "derived", "(1 − P_a·P_b)/2 — `coulomb`"],
+  ["two signs, and they cancel", "derived", "polarity is ±1 and sums"],
+  ["the ± ledger balances", "derived", "BITE = 1 exists exactly for this"],
+  ["magnetisation is quantised", "derived", "dwell is a count of ticks — `scale`"],
+  ["∇·B = 0", "derived", "no way to be sided without two sides"],
+  ["no magnetic monopoles", "derived", "the same statement"],
+  ["the lightest constituent wins", "derived", "µ/M ∝ 1/m² — `scale`"],
+  ["densities superpose", "derived", "they simply add"],
+  ["Gauss, ∇·E = ρ/ε₀", "not derived", "the SHAPE is; there is no charge here"],
+  ["electric charge at all", "not derived", "P is not charge — `coulomb` §4"],
+  ["charge quantisation", "not derived", "needs matter to say what is held"],
+  ["c finite and universal", "built in", "LIGHT = 1 is the axiom, not a result"],
+  ["radiation exists", "built in", "a flipping source lays down bands at c"],
+  ["ε₀, µ0, α", "not derived", "the one number owed — `coulomb`"],
+  ["Faraday, ∇×E = −∂B/∂t", "not derived", "needs E and B as separate fields"],
+  ["Ampère–Maxwell", "not derived", "same; no field equations here at all"],
+  ["Lorentz force qE", "not derived", "no first-order channel"],
+  ["Lorentz force qv×B", "not derived", "nothing deflects a moving charge"],
+  ["transverse polarisation", "not derived", "emission is a scalar sign"],
+  ["gauge invariance", "not derived", "there are no potentials to be free of"],
+  ["the dipole angular law", "derived", "3cos²θ − 1 to 3 dp — `poles`"],
+  ["dipole–dipole force, 1/R⁴", "derived", "slope −2.00 on gravity's 1/R² — `poles`"],
+  ["all five orientations", "derived", "including pole-to-pole — `poles`"],
+  ["cutting a magnet halves it", "derived", "the sign is a region's boundary"],
+  ["the magnetic coupling", "not derived", "√(µ0/4πG)·M kg/m² — measured — `budget`"],
+  ["force linear in the field", "REFUTED", "it is bilinear — meetings, not fields"],
+  ["g = 2", "REFUTED", "µ/L = q/2m with r cancelling, so g = 1"],
+  ["magnetocrystalline anisotropy", "REFUTED", "predicts ⟨111⟩ by 11.1% everywhere"],
+];
+const tally: Record<string, number> = {};
+for (const [what, how, why] of AUDIT) {
+  tally[how] = (tally[how] ?? 0) + 1;
+  console.log(`   ${how === "REFUTED" ? "✗" : how === "derived" ? "✓" : "·"} ` +
+    `${what.padEnd(32)} ${how.padEnd(12)} ${why}`);
+}
+console.log();
+for (const k of ["derived", "built in", "not derived", "REFUTED"])
+  console.log(`      ${k.padEnd(14)} ${String(tally[k] ?? 0).padStart(3)}`);
+console.log(`      ${"TOTAL".padEnd(14)} ${String(AUDIT.length).padStart(3)}`);
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. AND WHAT IS LEFT MISSING IS ONE THING, ON THE ELECTRIC SIDE");
+console.log("=".repeat(78));
+console.log("   Read the REFUTED and the not-derived rows together and they say");
+console.log("   the same sentence. Every one of them needs a FIELD — something");
+console.log("   that exists between the sources, carries its own state, obeys its");
+console.log("   own equations, and acts on a charge that merely passes through it.");
+console.log("\n   This model has no such thing. It has emission and it has MEETING,");
+console.log("   and a meeting is second order: nothing whatever happens to a charge");
+console.log("   that does not run into another charge. From that one fact:\n");
+console.log("      · the force is bilinear, so it cannot be linear in a field");
+console.log("      · there is no ∂B/∂t for a curl of E to equal");
+console.log("      · a moving charge feels no v×B, because it feels nothing");
+console.log("      · a dipole cannot cancel at distance, because what a distant");
+console.log("        body receives is decided by where IT is, not where the");
+console.log("        poles are");
+console.log("      · and the coupling is capped at gravity's size, which is the");
+console.log(`        10⁴² — measured, ${(E_Q * E_Q / (4 * Math.PI * EPS0) / (G_N * ME * ME)).toExponential(3)}`);
+console.log("\n   THAT IS THE WHOLE BILL, and it is one item: a first-order channel.");
+console.log("   Gravity did not need one — a shortage of space is exactly the kind");
+console.log("   of thing that only happens where two things meet — which is why");
+console.log("   the gravitational half of this article works and this half does");
+console.log("   not.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("5. SO THE ANSWER IS NO, AND HERE IS THE HONEST SENTENCE");
+console.log("=".repeat(78));
+console.log("   What is derived is a set of statements about a BIAS — how many");
+console.log("   signs there are, that they cancel, which way the force goes, that");
+console.log("   magnetisation is quantised, that there are no monopoles. That is");
+console.log("   magnetism, and it is real.");
+console.log("\n   What is NOT derived is electric charge. P is a fraction of a");
+console.log("   body's own emission and a proton says that is not what charge is,");
+console.log("   so the electric column is empty until there is a model of matter");
+console.log("   to fill it. And what is refuted is every statement about what a");
+console.log("   field does once it has left.");
+console.log("\n   SO: A PARTIAL MODEL OF MAGNETISM. Not of electromagnetism, and");
+console.log("   not yet of charge.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/moment.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/moment.ts
new file mode 100644
index 0000000..0c920c6
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/moment.ts
@@ -0,0 +1,170 @@
+/**
+ * HOW BIG IS ONE EMITTER'S MOMENT — and the one prediction here that does not
+ * depend on any choice, which is the g-factor, and it is wrong by exactly two.
+ *
+ * `magnets.ts` counted aligned emitters by dividing a measured magnetisation
+ * by a measured µ_B. That is fine for counting and it derives nothing: µ_B
+ * went in. This file asks whether the model produces µ_B on its own.
+ *
+ * The model has everything a current loop needs. An emitter pulses every
+ * X = G·ħ/(mc²) seconds and its axis comes round through CYCLE = 8 directions
+ * of a plane, so a full turn takes CYCLE·X and, at LIGHT, the loop's radius is
+ *
+ *     r = c·CYCLE·X / 2π  =  (CYCLE·G/2π)·λ̄_Compton
+ *
+ * and a charge q going round that loop at c is a current qc/2πr through an
+ * area πr², so
+ *
+ *     µ = q·c·r/2  =  (CYCLE·G/2π) · qħ/2m  =  (CYCLE·G/2π) · µ_B
+ *
+ * That is the derivation. Below is what it comes to, and then the part that
+ * survives whatever r turns out to be.
+ */
+
+const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
+const ME = 9.1093837015e-31, E_Q = 1.602176634e-19, MU_B = 9.2740100783e-24;
+const MU0 = 4e-7 * Math.PI, U = 1.66053906660e-27;
+const ALPHA = 7.2973525693e-3;
+const G_MEASURED = 2.00231930436256;
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const BITE = 1, CORE = 0.5, LIGHT = 1, CYCLE = 8;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+
+console.log("=".repeat(78));
+console.log("1. THE MAGNETON THE MODEL ACTUALLY GIVES");
+console.log("=".repeat(78));
+{
+  const X = G_LATTICE * HBAR / (ME * C * C);
+  const r = C * CYCLE * X / (2 * Math.PI);
+  const mu = E_Q * C * r / 2;
+  const lam = HBAR / (ME * C);
+  console.log(`      pulse period X        ${X.toExponential(4)} s`);
+  console.log(`      turn period CYCLE·X   ${(CYCLE * X).toExponential(4)} s`);
+  console.log(`      loop radius r         ${r.toExponential(4)} m   = ${(r / lam).toFixed(6)} λ̄_C`);
+  console.log(`      µ = q·c·r/2           ${mu.toExponential(4)} A·m²`);
+  console.log(`      µ_B                   ${MU_B.toExponential(4)} A·m²`);
+  console.log(`      RATIO                 ${(mu / MU_B).toFixed(6)}   = CYCLE·G/2π`);
+  console.log(`      short by              ${(MU_B / mu).toFixed(4)}`);
+  console.log(`\n      and 4π =              ${(4 * Math.PI).toFixed(4)}   — ${(100 * Math.abs(MU_B / mu / (4 * Math.PI) - 1)).toFixed(2)}% away`);
+  console.log("\n   Which is noted and NOT claimed. 4π is the shell factor `chance`");
+  console.log("   already carries, so there is a place for it to have come from,");
+  console.log("   and having a place is not having a derivation. If it were the");
+  console.log("   right factor the count would read:\n");
+  const alt = 2 * SHEET * G_LATTICE;
+  console.log(`      2·SHEET·G = 2·SHEET³/(8π²·CORE·WAYS) = 1024/(104π²) = ${alt.toFixed(6)} µ_B`);
+  console.log(`      measured µ_e/µ_B                                    = ${(G_MEASURED / 2).toFixed(6)} µ_B`);
+  console.log(`      off by                                              ${(100 * (alt / (G_MEASURED / 2) - 1)).toFixed(3)}%`);
+  console.log("\n   A near miss, in the wrong direction: the measured anomaly is");
+  console.log(`   +${(100 * (G_MEASURED / 2 - 1)).toFixed(4)}% and this is ${(100 * (1 - alt)).toFixed(3)}% BELOW one, so the model does not`);
+  console.log("   even have the sign of the anomaly to spend. Written down as a");
+  console.log("   near miss and left there.");
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. BUT THE g-FACTOR DOES NOT DEPEND ON r — AND IT IS WRONG BY TWO");
+console.log("=".repeat(78));
+console.log("   Whatever the loop's radius is, the emitter's angular momentum is");
+console.log("   L = m·c·r on the same loop, so the gyromagnetic ratio is");
+console.log("\n      γ = µ/L = (q c r/2)/(m c r) = q/2m\n");
+console.log("   and r cancels completely. That is the CLASSICAL ratio, g = 1.");
+{
+  const X = G_LATTICE * HBAR / (ME * C * C);
+  const r = C * CYCLE * X / (2 * Math.PI);
+  const mu = E_Q * C * r / 2, L = ME * C * r;
+  console.log(`\n      L                     ${L.toExponential(4)} J·s   = ${(L / HBAR).toFixed(6)} ħ`);
+  console.log(`      γ = µ/L               ${(mu / L).toExponential(6)} C/kg`);
+  console.log(`      q/2m                  ${(E_Q / (2 * ME)).toExponential(6)} C/kg`);
+  console.log(`      g, this model         1.000000`);
+  console.log(`      g, measured           ${G_MEASURED.toFixed(6)}`);
+  console.log(`      SHORT BY              ${G_MEASURED.toFixed(4)}`);
+}
+console.log("\n   This is the sharpest failure in the electromagnetic half of the");
+console.log("   model, because it survives every choice. A spinning charged loop");
+console.log("   gives g = 1; the electron gives 2, and has since 1928.");
+console.log("\n   WHERE A TWO COULD COME FROM, and why taking it would be cheating:");
+console.log("   the lattice's ring has CYCLE = 8 directions, so an undirected AXIS");
+console.log("   comes back to itself in 4 steps while a directed NORTH takes 8 —");
+console.log("   the observable turning twice as fast as the state, which is what a");
+console.log("   spinor is. But `emission` in `physics.ts` is `d·n̂`, and that");
+console.log("   tracks north, not the axis. So the model as written has period 8");
+console.log("   on both and gives g = 1. The two is available only by changing the");
+console.log("   emission rule, and that is a change, not a consequence.");
+console.log(`\n   (And the anomaly is a separate bill: g/2 − 1 = ${(G_MEASURED / 2 - 1).toExponential(4)},`);
+console.log(`   against α/2π = ${(ALPHA / (2 * Math.PI)).toExponential(4)}. There is no loop expansion here to`);
+console.log("   produce it, and no α either — see `coulomb`.)");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. AND THE LATTICE QUANTISES WHICH WAY A MAGNET CAN POINT");
+console.log("=".repeat(78));
+console.log("   A held emitter puts + into every exit whose projection on its axis");
+console.log("   is positive, − into every negative one, and nothing into the ones");
+console.log("   exactly across. There are only WAYS = 26 exits, so the split is a");
+console.log("   COUNT and it depends on which way the axis points:\n");
+
+const EXITS: number[][] = [];
+for (let x = -1; x <= 1; x++)
+  for (let y = -1; y <= 1; y++)
+    for (let z = -1; z <= 1; z++)
+      if (x || y || z) EXITS.push([x, y, z]);
+
+const split = (axis: number[]) => {
+  let p = 0, n = 0, e = 0;
+  for (const d of EXITS) {
+    const s = d[0] * axis[0] + d[1] * axis[1] + d[2] * axis[2];
+    if (s > 1e-9) p++; else if (s < -1e-9) n++; else e++;
+  }
+  return { p, n, e };
+};
+
+console.log("      axis        exits +    equator    exits −    biased fraction");
+const AXES: [string, number[]][] = [
+  ["⟨100⟩ face", [1, 0, 0]],
+  ["⟨110⟩ edge", [1, 1, 0]],
+  ["⟨111⟩ corner", [1, 1, 1]],
+];
+const frac: Record<string, number> = {};
+for (const [n, a] of AXES) {
+  const s = split(a);
+  frac[n] = s.p / WAYS;
+  console.log(`   ${n.padEnd(14)} ${String(s.p).padStart(6)}     ${String(s.e).padStart(6)}     ` +
+    `${String(s.n).padStart(6)}     ${(s.p / WAYS).toFixed(4)}`);
+}
+console.log(`\n   Note the equator of a face axis is exactly SHEET = ${SHEET}, which is`);
+console.log("   what one pulse is. So a face-aligned magnet wastes a whole pulse's");
+console.log("   worth of directions on its own equator and a corner-aligned one");
+console.log(`   wastes only ${split([1, 1, 1]).e}.`);
+console.log(`\n   ⟨111⟩ / ⟨100⟩ = ${(frac["⟨111⟩ corner"] / frac["⟨100⟩ face"]).toFixed(4)}  — so THE MODEL PREDICTS A BODY`);
+console.log("   DIAGONAL IS THE EASY AXIS, by 11.1%, in any cubic material.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. WHICH IS MEASURABLE, AND IT IS HALF RIGHT");
+console.log("=".repeat(78));
+console.log("   Magnetocrystalline anisotropy is exactly this quantity. As a");
+console.log("   fraction of the magnetostatic energy ½µ0·M_s², K1 comes to:\n");
+console.log("      material   easy axis   K1 (J/m³)    K1/(½µ0 M_s²)   model says");
+const ANIS: [string, string, number, number][] = [
+  ["iron", "⟨100⟩", 4.8e4, 2.15 / MU0],
+  ["nickel", "⟨111⟩", -4.5e3, 0.61 / MU0],
+  ["cobalt", "c-axis", 4.1e5, 1.79 / MU0],
+];
+for (const [n, easy, K1, Ms] of ANIS) {
+  const rel = Math.abs(K1) / (0.5 * MU0 * Ms * Ms);
+  console.log(`      ${n.padEnd(10)} ${easy.padEnd(11)} ${K1.toExponential(1).padStart(9)}    ` +
+    `${(100 * rel).toFixed(2).padStart(8)}%      11.11%, ⟨111⟩`);
+}
+console.log("\n   So the SIZE is right to within a factor of a few — a lattice");
+console.log("   count of 10 against 9 predicts a percents-level anisotropy and");
+console.log("   percents-level is what is measured, which is not nothing given");
+console.log("   that nothing was fitted.");
+console.log("\n   The DIRECTION is right for nickel and wrong for iron, and iron is");
+console.log("   the one everybody quotes. And the model has no material dependence");
+console.log("   at all — it says 11.1% for every cubic crystal, where measurement");
+console.log("   runs from 2.6% to 32%. So this is a prediction that exists, lands");
+console.log("   in the right decade, and is refuted in detail.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts
new file mode 100644
index 0000000..faf0e2a
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts
@@ -0,0 +1,235 @@
+/**
+ * THE SAME THEORY WITH THE XOR TURNED OFF — no polarity, no signs, no
+ * opposites. Just discrete directions, and a meeting is a meeting when two
+ * charges come at each other HEAD ON.
+ *
+ * The point of asking is that it makes the model a one-parameter family rather
+ * than a single thing, and the parameter is where the XOR sits. So the honest
+ * question is not "does it still work" but "which line of the account notices".
+ *
+ * WHAT CHANGES IN THE RULES:
+ *
+ *              WITH POLARITY                      WITHOUT
+ *   a charge   ±1                                 no sign, just a direction
+ *   meeting    co-location, AT ANY ANGLE          head-on only
+ *   outcome    opposite annihilate, alike turn    it annihilates
+ *   share      half of them are opposite, so ½    all of them, so 1
+ *
+ * Those two changes pull opposite ways and the file measures which wins where.
+ * Everything else — `chance`, `SHEET`, `WAYS`, `BITE`, `MADE`, `SPREAD`,
+ * `BIAS`, the accumulation, the ceiling — never mentions a sign and is
+ * untouched by construction.
+ */
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const BITE = 1, CORE = 0.5, LIGHT = 1;
+const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
+const M_PLANCK = Math.sqrt(HBAR * C / G_N);
+const MPC = 3.0856775814913673e22, KPC = 3.0857e19, MSUN = 1.98847e30;
+
+/** THE SWITCH. `share` is the only thing polarity decides. */
+const SHARE = { xor: 0.5, plain: 1.0 };
+
+const G_OF = (share: number) =>
+  BITE * SHEET * SHEET * LIGHT * share / (4 * Math.PI * Math.PI * CORE * WAYS);
+
+console.log("=".repeat(78));
+console.log("1. THE CONSTANTS — which move and which do not");
+console.log("=".repeat(78));
+const Gx = G_OF(SHARE.xor), Gp = G_OF(SHARE.plain);
+console.log("      quantity                  with polarity     without         moves?");
+const rows: [string, number, number][] = [
+  ["SHEET", SHEET, SHEET],
+  ["WAYS", WAYS, WAYS],
+  ["BITE", BITE, BITE],
+  ["BIAS = LIGHT/WAYS", LIGHT / WAYS, LIGHT / WAYS],
+  ["MADE = 3·BITE·SHEET/πWAYS", 3 * BITE * SHEET / (Math.PI * WAYS), 3 * BITE * SHEET / (Math.PI * WAYS)],
+  ["SPREAD", Math.PI * WAYS * LIGHT / (3 * BITE * SHEET), Math.PI * WAYS * LIGHT / (3 * BITE * SHEET)],
+  ["G_LATTICE", Gx, Gp],
+  ["MU = G·m_Planck (kg)", Gx * M_PLANCK, Gp * M_PLANCK],
+  ["REACHES", Math.sqrt(8 * Math.PI * Gx / (3 * BITE * SHARE.xor * SHEET)),
+    Math.sqrt(8 * Math.PI * Gp / (3 * BITE * SHARE.plain * SHEET))],
+  ["tick = ħ/(m_P c²) (s)", HBAR / (M_PLANCK * C * C), HBAR / (M_PLANCK * C * C)],
+];
+for (const [n, a, b] of rows) {
+  const same = Math.abs(a / b - 1) < 1e-12;
+  console.log(`   ${n.padEnd(26)} ${a.toExponential(4)}   ${b.toExponential(4)}   ` +
+    `${same ? "no" : "×" + (b / a).toFixed(3)}`);
+}
+console.log("\n   Only two move, and they move together: G doubles because every");
+console.log("   meeting now annihilates instead of half of them, and MU doubles");
+console.log("   with it because MU is defined as G·m_Planck. REACHES does not");
+console.log("   move at all — it carries G on top and the share underneath, and");
+console.log("   the two cancel exactly.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. AND THE FACTOR OF TWO IS NOT OBSERVABLE");
+console.log("=".repeat(78));
+console.log("   `models.ts` divides every mass by GRAVITY, so a body of physical");
+console.log("   mass M carries lattice mass M/G. Anything the dynamics computes");
+console.log("   is G·(M/G) = M, and the constant is gone before it is used:\n");
+for (const [n, G] of [["with polarity", Gx], ["without", Gp]] as [string, number][]) {
+  const M = 1.98847e30, lattice = M / G;
+  console.log(`      ${n.padEnd(16)} G = ${G.toFixed(6)}   the Sun is ${lattice.toExponential(4)} units` +
+    `   G·m = ${(G * lattice).toExponential(4)}`);
+}
+console.log("\n   Identical. So doubling G is a change of the MASS UNIT and not of");
+console.log("   any prediction — the same statement `BITE` already carries, and");
+console.log("   for the same reason.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. THE FORCE LAW ITSELF — measured on the line, both ways");
+console.log("=".repeat(78));
+console.log("   `shortfall` integrates chance(a,x)·chance(b,R−x) along the line");
+console.log("   between the two. Without polarity there is also an angular gate,");
+console.log("   `closing = max(−d̂_a·d̂_b, 0)` — and ON THE LINE that is exactly 1,");
+console.log("   because the two arrive dead head-on. So only the share differs:\n");
+const chance = (m: number, r: number) => m * SHEET / (4 * Math.PI * Math.pow(Math.max(r, CORE), 2));
+const online = (R: number, share: number, N = 200000) => {
+  let acc = 0;
+  for (let i = 0; i < N; i++) {
+    const x = R * (i + 0.5) / N;
+    acc += share * chance(1, x) * chance(1, R - x) * (R / N);
+  }
+  return acc;
+};
+console.log("      R        with polarity    without         ratio     ×R²");
+for (const R of [24, 48, 100, 400]) {
+  const a = online(R, SHARE.xor), b = online(R, SHARE.plain);
+  console.log(`   ${String(R).padStart(6)}   ${a.toExponential(3)}   ${b.toExponential(3)}   ` +
+    `${(b / a).toFixed(4)}   ${(a * R * R).toExponential(3)}`);
+}
+console.log("\n   Exactly two, at every separation, and ×R² is flat in both — so");
+console.log("   the SHAPE of the law is untouched and only its unit moved. Which");
+console.log("   is section 2 again, arrived at from the integral instead of from");
+console.log("   the definition.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. OFF THE LINE IT IS NOT THE SAME — and this is the real difference");
+console.log("=".repeat(78));
+console.log("   `gravity.ts` retired `closing` on the discrete model's own");
+console.log("   authority: two shells sweeping through each other converge on the");
+console.log("   same cell from ALL angles, never pointed at each other, and with");
+console.log("   polarity the outcome is decided by sign with no angular factor.");
+console.log("   Without polarity there is nothing left to decide it BUT the angle,");
+console.log("   so the gate comes back — and it bounds the folding to a lens.\n");
+{
+  // ∫ over all space of ρ_a·ρ_b, with and without the angular gate
+  const R = 40;
+  const A: [number, number, number] = [0, 0, 0], B: [number, number, number] = [0, 0, R];
+  let both = 0, gated = 0;
+  const NR = 220, NT = 90, NP = 72;
+  for (const near of [0, 1]) {
+    const O = near === 0 ? A : B;
+    const r0 = CORE * 1e-2, r1 = R * 1e3, lr = Math.log(r1 / r0);
+    for (let i = 0; i < NR; i++) {
+      const r = r0 * Math.exp(lr * (i + 0.5) / NR), dr = r * lr / NR;
+      for (let j = 0; j < NT; j++) {
+        const ct = -1 + 2 * (j + 0.5) / NT, dct = 2 / NT;
+        const st = Math.sqrt(Math.max(1 - ct * ct, 0));
+        for (let k = 0; k < NP; k++) {
+          const ph = 2 * Math.PI * (k + 0.5) / NP, dph = 2 * Math.PI / NP;
+          const x = O[0] + r * st * Math.cos(ph), y = O[1] + r * st * Math.sin(ph), z = O[2] + r * ct;
+          const ax = x - A[0], ay = y - A[1], az = z - A[2];
+          const bx = x - B[0], by = y - B[1], bz = z - B[2];
+          const ra = Math.hypot(ax, ay, az), rb = Math.hypot(bx, by, bz);
+          if ((near === 0) !== (ra <= rb)) continue;
+          if (ra < 1e-9 || rb < 1e-9) continue;
+          const dotp = (ax * bx + ay * by + az * bz) / (ra * rb);
+          const rho = chance(1, ra) * chance(1, rb), dV = r * r * dr * dct * dph;
+          both += 0.5 * rho * dV;
+          gated += 1.0 * rho * Math.max(-dotp, 0) * dV;
+        }
+      }
+    }
+  }
+  console.log(`      ∫ over all space, with polarity   ${both.toExponential(4)}`);
+  console.log(`      ∫ over all space, without         ${gated.toExponential(4)}`);
+  console.log(`      ratio                             ${(gated / both).toFixed(4)}`);
+  console.log("\n   So the two agree on the line and disagree everywhere else: the");
+  console.log("   no-polarity version folds only inside the sphere having the two");
+  console.log("   bodies as a diameter, and puts about a quarter as much folding");
+  console.log("   into space altogether.");
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("5. BUT NOTHING IN THE ARTICLE READS THAT NUMBER");
+console.log("=".repeat(78));
+console.log("   The dynamics read `shortfall`, which is the LINE integral, and the");
+console.log("   metric reads `foldAt = G·m/(r c²)` — a fact about one body at one");
+console.log("   place, with no pair in it and no angle to gate. So every measured");
+console.log("   prediction in the article is computed from quantities section 3");
+console.log("   showed are identical:\n");
+const PRED: [string, string][] = [
+  ["Mercury's perihelion, the 1/6", "BIAS and relativistic momentum — no share"],
+  ["the other five sixths", "slowing, thickness, carry — read foldAt"],
+  ["light's deflection", "the same metric"],
+  ["a₀ = cH₀/2π", "the expansion — no share anywhere in it"],
+  ["the Milky Way to 1.1% rms", "a₀ and the transport route"],
+  ["the transport turnover", "n/n_c and flux — no sign"],
+  ["blocking → the interpolation", "`through` = 1 − chance — no sign"],
+  ["the ⟨111⟩ / step anisotropy", "26 exits and three cosines — no sign"],
+  ["the frontier cosmology, H₀ = 1/t₀", "counting the frontier — no sign"],
+];
+for (const [p, why] of PRED) console.log(`      ${p.padEnd(36)} ${why}`);
+console.log("\n   Every one of them is unchanged, to every digit quoted.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("6. WHERE IT DOES DEVIATE, IN FULL");
+console.log("=".repeat(78));
+const lam = (share: number) => LIGHT / Math.sqrt(BITE * share * SHEET * 1e-58);
+console.log("   Three things, and only the first is a number anyone could measure:\n");
+console.log(`      reach, λ = c/√(BITE·share·SHEET·Φ)`);
+console.log(`         with polarity   ${(lam(SHARE.xor) / 1e0).toExponential(3)} in lattice units`);
+console.log(`         without         ${(lam(SHARE.plain) / 1e0).toExponential(3)}   — shorter by √2`);
+console.log("         and at 30 kpc that moves the pull by 1.9·10⁻¹⁰ → 3.8·10⁻¹⁰,");
+console.log("         which is nothing anyone will ever weigh.\n");
+console.log("      MU, the largest elementary mass");
+console.log(`         ${(Gx * M_PLANCK * 1e9).toFixed(3)} µg  →  ${(Gp * M_PLANCK * 1e9).toFixed(3)} µg`);
+console.log("         a statement about the unit, not about a body.\n");
+console.log("      the Compton identity X·c = G·λ̄_C");
+console.log(`         ratio ${Gx.toFixed(6)}  →  ${Gp.toFixed(6)}`);
+console.log("         still exact at every mass, at a different constant.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("7. AND WHAT IS LOST");
+console.log("=".repeat(78));
+console.log("   Everything the XOR was for, which is a short list and does not");
+console.log("   touch gravity:\n");
+console.log("      · MAGNETISM ENTIRELY. `poles`, the sign law, 3cos²θ − 1, 1/R⁴,");
+console.log("        ∇·B = 0, the quantised magnetisation. With no signs there is");
+console.log("        no bias to have, and a magnet is not a thing this model can");
+console.log("        be asked about.");
+console.log("      · THE EXPLANATION OF THE ONE-HALF. With polarity the ½ in G is");
+console.log("        derived — it is the chance two charges disagree — and it is");
+console.log("        why G would be different if matter were charged. Without, the");
+console.log("        share is 1 by fiat and there is nothing to explain.");
+console.log("      · AND ANY ROUTE TO CHARGE. Which was never started, so it costs");
+console.log("        nothing that had been paid for.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("8. SO THE ANSWER");
+console.log("=".repeat(78));
+console.log("   GRAVITY IS THE SAME THEORY. Not approximately — the force law's");
+console.log("   shape, the metric, the perihelion, the deflection, the rotation");
+console.log("   curve, a₀ and the cosmology are all computed from quantities that");
+console.log("   never mention a sign, and the one constant that moves is a unit");
+console.log("   that cancels before it is used.");
+console.log("");
+console.log("   So the XOR is a TUNABLE PARAMETER, and it is free on the");
+console.log("   gravitational side. Turning it on costs nothing and buys");
+console.log("   magnetism; turning it off costs magnetism and buys nothing. That");
+console.log("   is a better position than the article was in before this was");
+console.log("   asked, because it means the magnetic half cannot break the");
+console.log("   gravitational one — there is no shared number for it to get");
+console.log("   wrong.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ordering.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ordering.ts
new file mode 100644
index 0000000..b33e2d6
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ordering.ts
@@ -0,0 +1,167 @@
+/**
+ * WHERE DO THE POLES COME FROM — does an ordering of ordinary sided emitters
+ * produce the region-bias that `poles` shows is what a magnet needs?
+ *
+ * `poles` settled the mechanism: put the bias on a PLACE — a body + at one end
+ * and − at the other — and the same XOR gives 3cos²θ − 1, 1/R⁴ and every
+ * orientation. What it did not say is how a lump of matter comes to be like
+ * that.
+ *
+ * The proposal is rotation: emitters point outward more often, spinning holds
+ * them there, the middle averages out to nothing but gravity, and what is left
+ * over shows up ON THE OUTSIDE. That is the right shape of answer, because it
+ * is the same "unpaired at the boundary" argument that makes the bulk cancel:
+ * inside, every emitter's + has a neighbour's − sitting on it; at a face, the
+ * outermost + has nothing to pair with.
+ *
+ * So this file takes each ordering an emitter population could have and
+ * measures what the far field actually does. The test is a multipole one: a
+ * magnet's field must fall as 1/r³ and reverse between the poles. Anything
+ * falling as 1/r² has a net and is not a magnet.
+ */
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1;
+
+type V = [number, number, number];
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const unit = (a: V): V => { const l = Math.hypot(...a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+
+/** how each emitter in the body is pointed */
+type Order = "axial" | "radial" | "cylindrical" | "region";
+
+/** a cylinder of emitters, sampled on a grid */
+const body = (R: number, H: number, n = 15) => {
+  const out: { at: V; w: number }[] = [];
+  const dz = H / n, dr = R / n;
+  for (let i = 0; i < n; i++) {
+    const z = -H / 2 + dz * (i + 0.5);
+    for (let j = 0; j < n; j++) {
+      const s = dr * (j + 0.5);
+      const np = Math.max(4, Math.round(2 * Math.PI * s / dr));
+      for (let k = 0; k < np; k++) {
+        const ph = 2 * Math.PI * (k + 0.5) / np;
+        out.push({ at: [s * Math.cos(ph), s * Math.sin(ph), z], w: s * dr * dz * (2 * Math.PI / np) });
+      }
+    }
+  }
+  return out;
+};
+
+const Z: V = [0, 0, 1];
+
+/** the axis a given emitter is pointed along, under a given ordering */
+const axisOf = (o: Order, at: V): V => {
+  if (o === "axial") return Z;
+  if (o === "radial") return unit(at);
+  if (o === "cylindrical") return unit([at[0], at[1], 1e-12]);
+  return Z;                                    // unused for "region"
+};
+
+/**
+ * The signed emission a body leaves at a place.
+ *
+ * For the three ORDERINGS this is `sign(d̂·n̂)/r²` summed over emitters, which
+ * is `physics.ts`'s emission rule with the sign kept. For "region" it is the
+ * pole model — a net + in the top half and a net − in the bottom — which is
+ * what `poles` measured and is here as the control.
+ */
+const signedAt = (o: Order, B: ReturnType<typeof body>, x: V) => {
+  let acc = 0;
+  for (const e of B) {
+    const d: V = [x[0] - e.at[0], x[1] - e.at[1], x[2] - e.at[2]];
+    const r2 = d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
+    if (r2 < 1e-12) continue;
+    const s = o === "region"
+      ? Math.sign(e.at[2])                     // net + above the middle, − below
+      : Math.sign(dot(axisOf(o, e.at), unit(d)));
+    acc += s * e.w * SHEET / (4 * Math.PI * r2);
+  }
+  return acc;
+};
+
+const at = (R: number, th: number): V => [R * Math.sin(th), 0, R * Math.cos(th)];
+
+console.log("=".repeat(78));
+console.log("1. THE BULK REALLY DOES CANCEL, AND THE FACES REALLY DO NOT");
+console.log("=".repeat(78));
+console.log("   A cylinder of radius 6, height 12, all emitters pointed along z.");
+console.log("   Signed emission on the axis, walking from the middle out:\n");
+console.log("      z        inside/outside   signed emission");
+{
+  const B = body(6, 12);
+  for (const z of [0, 2, 4, 5.5, 6.5, 8, 12, 24]) {
+    console.log(`   ${z.toFixed(1).padStart(6)}   ${(Math.abs(z) < 6 ? "inside" : "outside").padEnd(14)}   ` +
+      `${signedAt("axial", B, [0, 0, z]).toExponential(3)}`);
+  }
+  console.log("\n   Nought in the middle by symmetry and growing outward, which is");
+  console.log("   the proposal exactly: gravity in the middle, the signed part on");
+  console.log("   the outside. So far so good.");
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. BUT THE FAR FIELD IS WHAT DECIDES IT");
+console.log("=".repeat(78));
+console.log("   A magnet's field falls as 1/r³ and REVERSES between its poles.");
+console.log("   Anything falling as 1/r² has a net and is not a magnet.\n");
+console.log("      ordering       slope, on axis    θ=0        θ=90°      θ=180°    verdict");
+{
+  const B = body(6, 12);
+  for (const o of ["axial", "radial", "cylindrical", "region"] as Order[]) {
+    const f = (R: number, th: number) => signedAt(o, B, at(R, th));
+    const a1 = f(60, 0), a2 = f(240, 0);
+    const slope = Math.log(Math.abs(a2 / a1)) / Math.log(240 / 60);
+    const p0 = f(120, 0), p9 = f(120, Math.PI / 2), p18 = f(120, Math.PI);
+    const reverses = Math.sign(p0) !== Math.sign(p18) && Math.abs(p18) > 1e-14;
+    const ok = slope < -2.7 && reverses;
+    console.log(`   ${o.padEnd(14)} ${slope.toFixed(2).padStart(9)}      ` +
+      `${p0.toExponential(1).padStart(9)}  ${p9.toExponential(1).padStart(9)}  ` +
+      `${p18.toExponential(1).padStart(9)}   ${ok ? "A MAGNET" : "not a magnet"}`);
+  }
+}
+console.log("\n   Only the region reading passes, and the three orderings fail the");
+console.log("   same way: at a distant point EVERY emitter in the body agrees");
+console.log("   about which sign that direction gets, because the sign is decided");
+console.log("   by where the OBSERVER is. So they add instead of cancelling, and");
+console.log("   what comes out is a net — a 1/r² with a preferred direction.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. WHICH IS A SHARP STATEMENT AND NOT A VAGUE ONE");
+console.log("=".repeat(78));
+console.log("   The bulk-cancels-faces-don't argument is RIGHT — section 1 shows");
+console.log("   it happening. What it produces is not a magnet, and the reason is");
+console.log("   specific: cancellation between neighbours is a NEAR-FIELD fact, and");
+console.log("   a distant body does not see neighbours cancelling. It sees every");
+console.log("   emitter's chosen side at once.");
+console.log("");
+console.log("   For the faces to be POLES, an emitter's sign has to be fixed when");
+console.log("   it is emitted rather than decided by who is looking. That is the");
+console.log("   whole difference between the two readings:\n");
+console.log("      bias on a DIRECTION   sign = f(observer)   → adds, gives a net");
+console.log("      bias on a PLACE       sign = f(emitter)    → cancels, gives a dipole");
+console.log("");
+console.log("   So rotation can order the emitters — and something has to, or the");
+console.log("   body has no axis at all — but ordering alone does not make poles.");
+console.log("   What is needed is an emitter whose SIGN travels with the pulse.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. AND THAT IS A CONCRETE THING TO ASK OF `physics.ts`");
+console.log("=".repeat(78));
+console.log("   `emission` is `sided ? along() : cos(2πβ)`, and `along()` is the");
+console.log("   direction resolved against the axis — computed AT THE DESTINATION.");
+console.log("   That is what makes the sign a function of the observer.");
+console.log("");
+console.log("   A charge that carried its polarity with it would be quantised at");
+console.log("   the source instead: the emitter picks a sign per pulse, sends it,");
+console.log("   and what arrives is what was sent. Then a body's + and − come from");
+console.log("   WHERE its emitters are, the near-field cancellation survives to");
+console.log("   infinity, and the faces are poles.");
+console.log("");
+console.log("   Which is not a new mechanism — it is the same XOR, the same");
+console.log("   `chance`, the same co-location. It is a question about one line:");
+console.log("   IS A PULSE'S SIGN FIXED WHEN IT LEAVES, OR WHEN IT ARRIVES?");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/poles.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/poles.ts
new file mode 100644
index 0000000..1b1f9cf
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/poles.ts
@@ -0,0 +1,196 @@
+/**
+ * MAGNETISM THROUGH THE SAME MACHINERY AS GRAVITY — and the one change that
+ * makes it work, which is where the bias LIVES.
+ *
+ * `dipole` measured a magnet as ONE emitter with a direction: + out of the
+ * north half, − out of the south, from a single place. That object failed
+ * everything a magnet has to do — pole to pole gave exactly nothing and the
+ * fall-off was 1/R² where two magnets are 1/R⁴.
+ *
+ * But there is a second reading and it was never tested. It uses exactly the
+ * same annihilation arithmetic — the same `chance`, the same XOR of signs, the
+ * same `(1 − P_a·P_b)/2` split — and changes only one thing:
+ *
+ *     A. THE POINT.  One emitter, biased BY DIRECTION. Net zero because its
+ *        two halves emit opposite signs from the same place.
+ *
+ *     B. THE REGION. Bias belongs to a PLACE rather than to a direction, so a
+ *        bar magnet is a lump biased + at one end and − at the other. Net zero
+ *        because the two ends cancel — SEPARATED IN SPACE, not in direction.
+ *
+ * B is what magnetostatics has always called the pole model, and it is exact
+ * there. The question this file asks is whether the lattice's own XOR
+ * reproduces it, with nothing added.
+ *
+ * Everything below is `annihilation` from `gravity.ts` with the signs kept:
+ * being in the same cell is the event, opposite cancel, alike turn.
+ */
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const CORE = 0.5;
+
+type V = [number, number, number];
+const unit = (a: V): V => { const l = Math.hypot(...a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+
+/**
+ * A body, as whatever is emitting. `spots` is a list of places with a sign
+ * each — reading B — and `axis`, if given, makes it reading A instead.
+ */
+type Body = { spots: { at: V; sign: number }[]; axis?: V; at: V };
+
+/** the charge density and the bias this body leaves at a place */
+const sample = (b: Body, x: V, eps: number) => {
+  if (b.axis) {
+    const d: V = [x[0] - b.at[0], x[1] - b.at[1], x[2] - b.at[2]];
+    const r = Math.max(Math.hypot(...d), eps);
+    return { rho: SHEET / (4 * Math.PI * r * r), P: dot(unit(b.axis), unit(d)) };
+  }
+
+  let rho = 0, signed = 0;
+  for (const s of b.spots) {
+    const r = Math.max(Math.hypot(x[0] - s.at[0], x[1] - s.at[1], x[2] - s.at[2]), eps);
+    const d = SHEET / (4 * Math.PI * r * r);
+    rho += d; signed += s.sign * d;
+  }
+  return { rho, P: rho > 0 ? signed / rho : 0 };
+};
+
+/** ∫ρ_a·ρ_b over all space, and the part the biases add to it */
+const integrate = (A: Body, B: Body, R: number, eps: number,
+  NR = 260, NT = 80, NP = 64) => {
+  let plain = 0, bias = 0;
+
+  for (const near of [0, 1]) {
+    const O = near === 0 ? A.at : B.at;
+    const r0 = eps * 1e-2, r1 = R * 1e4, lr = Math.log(r1 / r0);
+
+    for (let i = 0; i < NR; i++) {
+      const r = r0 * Math.exp(lr * (i + 0.5) / NR), dr = r * lr / NR;
+      for (let j = 0; j < NT; j++) {
+        const ct = -1 + 2 * (j + 0.5) / NT, dct = 2 / NT;
+        const st = Math.sqrt(Math.max(1 - ct * ct, 0));
+        for (let k = 0; k < NP; k++) {
+          const ph = 2 * Math.PI * (k + 0.5) / NP, dph = 2 * Math.PI / NP;
+          const x: V = [
+            O[0] + r * st * Math.cos(ph), O[1] + r * st * Math.sin(ph), O[2] + r * ct,
+          ];
+          const da = Math.hypot(x[0] - A.at[0], x[1] - A.at[1], x[2] - A.at[2]);
+          const db = Math.hypot(x[0] - B.at[0], x[1] - B.at[1], x[2] - B.at[2]);
+          if ((near === 0) !== (da <= db)) continue;
+
+          const sa = sample(A, x, eps), sb = sample(B, x, eps);
+          const dV = r * r * dr * dct * dph;
+          plain += sa.rho * sb.rho * dV;
+          bias += sa.rho * sb.rho * (-sa.P * sb.P) * dV;
+        }
+      }
+    }
+  }
+  return { plain, bias };
+};
+
+/** reading B: a bar of length L centred at `at`, poles along `dir` */
+const bar = (at: V, dir: V, L: number): Body => {
+  const u = unit(dir);
+  return {
+    at,
+    spots: [
+      { at: [at[0] + u[0] * L / 2, at[1] + u[1] * L / 2, at[2] + u[2] * L / 2], sign: +1 },
+      { at: [at[0] - u[0] * L / 2, at[1] - u[1] * L / 2, at[2] - u[2] * L / 2], sign: -1 },
+    ],
+  };
+};
+
+/** reading A: one point, biased by direction */
+const point = (at: V, dir: V): Body => ({ at, spots: [{ at, sign: 0 }], axis: unit(dir) });
+
+const Z: V = [0, 0, 1], X: V = [1, 0, 0];
+
+console.log("=".repeat(78));
+console.log("1. THE FIVE ARRANGEMENTS, BOTH READINGS, AT R = 100");
+console.log("=".repeat(78));
+console.log("   The excess as a fraction of the plain annihilation. Positive is");
+console.log("   EXTRA attraction. Bars are 4 long, so R/L = 25 — well separated.\n");
+console.log("      arrangement                    should      A: the point     B: the region");
+const CASES: [string, V, V, string][] = [
+  ["N–S facing", Z, Z, "attract"],
+  ["N–N facing", Z, [0, 0, -1], "repel"],
+  ["side by side, parallel", X, X, "repel"],
+  ["side by side, antiparallel", X, [-1, 0, 0], "attract"],
+  ["one across the other", Z, X, "nothing"],
+];
+const says = (v: number, scale: number) =>
+  v > scale ? "attract" : v < -scale ? "repel" : "nothing";
+for (const [n, a, b, want] of CASES) {
+  const A = integrate(point([0, 0, 0], a), point([0, 0, 100], b), 100, CORE);
+  const B = integrate(bar([0, 0, 0], a, 4), bar([0, 0, 100], b, 4), 100, CORE);
+  const ea = A.bias / A.plain, eb = B.bias / B.plain;
+  const va = says(ea, 1e-3), vb = says(eb, 1e-7);
+  console.log(`   ${n.padEnd(30)} ${want.padEnd(10)} ${ea.toExponential(2).padStart(10)} ` +
+    `${(va === want ? "  ok  " : " WRONG").padEnd(8)} ${eb.toExponential(2).padStart(10)} ` +
+    `${vb === want ? "  ok" : " WRONG"}`);
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. AND THE DISTANCE LAW");
+console.log("=".repeat(78));
+console.log("   Bars of length 4, facing pole to pole, separation swept. For a");
+console.log("   dipole the excess must fall as (L/R)², so the slope is −2 and the");
+console.log("   force — which rides on gravity's 1/R² — comes out 1/R⁴.\n");
+console.log("      R        A: the point    slope      B: the region   slope");
+let pa: [number, number] | null = null, pb: [number, number] | null = null;
+for (const R of [40, 80, 160, 320]) {
+  const A = integrate(point([0, 0, 0], Z), point([0, 0, R], Z), R, CORE);
+  const B = integrate(bar([0, 0, 0], Z, 4), bar([0, 0, R], Z, 4), R, CORE);
+  const ea = Math.abs(A.bias / A.plain), eb = B.bias / B.plain;
+  const sa = pa ? Math.log(ea / pa[1]) / Math.log(R / pa[0]) : NaN;
+  const sb = pb ? Math.log(eb / pb[1]) / Math.log(R / pb[0]) : NaN;
+  console.log(`   ${String(R).padStart(6)}   ${ea.toExponential(2).padStart(11)}   ` +
+    `${isNaN(sa) ? "    —" : sa.toFixed(2).padStart(6)}   ${eb.toExponential(2).padStart(11)}   ` +
+    `${isNaN(sb) ? "    —" : sb.toFixed(2).padStart(6)}`);
+  pa = [R, ea]; pb = [R, eb];
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. AND WHETHER IT IS REALLY THE DIPOLE ANGULAR LAW");
+console.log("=".repeat(78));
+console.log("   Two bars, one carried round the other at fixed R, both moments");
+console.log("   held along z. Magnetostatics says the force goes as (3cos²θ − 1),");
+console.log("   so it must change sign at 54.7° and come back at 125.3°.\n");
+console.log("      θ        3cos²θ − 1      B: the region, normalised");
+{
+  const R = 120, L = 4;
+  const ref = integrate(bar([0, 0, 0], Z, L), bar([0, 0, R], Z, L), R, CORE);
+  const at0 = ref.bias / ref.plain;
+  for (const tdeg of [0, 30, 54.7, 70, 90, 125.3, 180]) {
+    const t = tdeg * Math.PI / 180;
+    const other: V = [R * Math.sin(t), 0, R * Math.cos(t)];
+    const B = { ...bar(other, Z, L) };
+    const r = integrate(bar([0, 0, 0], Z, L), B, R, CORE);
+    const c = Math.cos(t);
+    console.log(`   ${(tdeg + "°").padStart(8)}   ${(3 * c * c - 1).toFixed(3).padStart(9)}      ` +
+      `${((r.bias / r.plain) / at0 * 2).toFixed(3).padStart(9)}`);
+  }
+  console.log("\n   (normalised so the on-axis value reads 2, which is what 3cos²θ−1");
+  console.log("   is at θ = 0.)");
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. SO THE XOR DOES GIVE MAGNETISM — IF THE BIAS BELONGS TO A PLACE");
+console.log("=".repeat(78));
+console.log("   Nothing was added. Same `chance`, same co-location rule, same");
+console.log("   (1 − P_a·P_b)/2 split that `G_LATTICE`'s one-half is the unbiased");
+console.log("   case of. The ONLY change is that a magnet's + and − are in two");
+console.log("   PLACES rather than in two DIRECTIONS from one place.");
+console.log("\n   Which is also why cutting a magnet gives two magnets rather than");
+console.log("   two monopoles: the sign is a property of a region's boundary, so a");
+console.log("   new cut makes a new pair of faces. And it is why ∇·B = 0 survives —");
+console.log("   the two poles of any body are equal and opposite by construction,");
+console.log("   because they are the same emitters counted at both ends.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pulses.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pulses.ts
new file mode 100644
index 0000000..cd0c833
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pulses.ts
@@ -0,0 +1,101 @@
+/**
+ * THE PULSE CLOCK — how often a thing of a given mass lets go of a charge.
+ *
+ * `physics.ts` already says it: mass on the emitting side is a PERIOD, not a
+ * strength. A heavier thing does not write more charge onto the space around
+ * it in one go; it writes just as much, more often. `beat = 1/mass`, with
+ * `mass ≤ 1` because once a tick is the ceiling.
+ *
+ * Everything electromagnetic below rests on that one number, so it is worth
+ * pinning down in seconds before anything is built on it. Three things are
+ * checked here and the third is the one that matters:
+ *
+ *   1. the period in SI, from `X·c = G·λ_Compton`
+ *   2. that the tick is the Planck time — an identity, not a coincidence
+ *   3. what a real magnet's worth of matter actually pulses at
+ */
+
+const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
+const ME = 9.1093837015e-31, MP_ = 1.67262192369e-27, U = 1.66053906660e-27;
+const M_PLANCK = Math.sqrt(HBAR * C / G_N);
+const T_PLANCK = Math.sqrt(HBAR * G_N / (C * C * C * C * C));
+
+// the lattice's own constants, recomputed rather than imported
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1;      // 8  — charges in one pulse
+const WAYS = Math.pow(3, DIMS) - 1;           // 26 — ways out of a point
+const BITE = 1, CORE = 0.5, LIGHT = 1;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+
+// the largest thing that can pulse on its own: once a tick is the ceiling
+const MU = G_LATTICE * M_PLANCK;
+
+/** Ticks between pulses, in the lattice's units. */
+const beat = (mLattice: number) => 1 / mLattice;
+
+/** And the same in seconds: X = G·λ̄_Compton/c = G·ħ/(mc²). */
+const period = (m: number) => G_LATTICE * HBAR / (m * C * C);
+const pulses = (m: number) => 1 / period(m);
+
+console.log("=".repeat(78));
+console.log("1. THE CONSTANTS");
+console.log("=".repeat(78));
+console.log(`   SHEET ${SHEET}   WAYS ${WAYS}   BITE ${BITE}   CORE ${CORE}`);
+console.log(`   G_LATTICE = SHEET²/(8π²·CORE·WAYS) = ${G_LATTICE.toFixed(8)}`);
+console.log(`   1/G_LATTICE = ${(1 / G_LATTICE).toFixed(4)}   (2·SHEET = ${2 * SHEET}, off by ` +
+  `${(100 * (1 / G_LATTICE / (2 * SHEET) - 1)).toFixed(2)}% — noted, not derived)`);
+console.log(`   MU = G·m_Planck = ${(MU * 1e9).toFixed(3)} µg   — the largest elementary mass`);
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. THE TICK IS THE PLANCK TIME, AND IT IS AN IDENTITY");
+console.log("=".repeat(78));
+console.log("   At the ceiling m = MU the beat is one tick, so a tick is");
+console.log("   period(MU) = G·ħ/(G·m_P·c²) = ħ/(m_P c²), and that is exactly");
+console.log("   what the Planck time is defined to be. G_LATTICE cancels.\n");
+console.log(`      period(MU)  = ${period(MU).toExponential(6)} s`);
+console.log(`      t_Planck    = ${T_PLANCK.toExponential(6)} s`);
+console.log(`      ratio       = ${(period(MU) / T_PLANCK).toFixed(9)}`);
+console.log("\n   So the lattice's tick is not a free scale — fixing mass as a");
+console.log("   period fixes it, and it lands on the Planck time with nothing");
+console.log("   chosen. Which also means the beat count and the second count are");
+console.log("   the same statement: beat(m̂) ticks = period(m) seconds.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. WHAT PULSES HOW OFTEN");
+console.log("=".repeat(78));
+console.log("      thing                  mass (kg)      m̂ = m/MU      beat (ticks)      pulses/s");
+const THINGS: [string, number][] = [
+  ["electron", ME],
+  ["proton", MP_],
+  ["iron atom (55.845 u)", 55.845 * U],
+  ["neodymium atom", 144.242 * U],
+  ["1 µg", 1e-9],
+  ["MU (the ceiling)", MU],
+  ["1 gram", 1e-3],
+  ["1 cm³ of N52 (7.5 g)", 7.5e-3],
+];
+for (const [n, m] of THINGS) {
+  const mh = m / MU;
+  console.log(`   ${n.padEnd(22)} ${m.toExponential(3)}   ${mh.toExponential(3)}   ` +
+    `${beat(mh).toExponential(3).padStart(10)}      ${pulses(m).toExponential(3)}`);
+}
+console.log("\n   Heavier pulses FASTER, which is the whole content of mass here,");
+console.log("   and a gram is already 10⁶ times over the elementary ceiling — so");
+console.log("   a gram is not an emitter, it is 7×10²⁰ of them.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. AND THE COMPTON IDENTITY IT CAME FROM, RE-CHECKED");
+console.log("=".repeat(78));
+console.log("      thing            X·c (m)        λ̄_Compton (m)     ratio");
+for (const [n, m] of THINGS.slice(0, 4)) {
+  const xc = period(m) * C, lc = HBAR / (m * C);
+  console.log(`   ${n.padEnd(16)} ${xc.toExponential(3)}   ${lc.toExponential(3)}      ${(xc / lc).toFixed(6)}`);
+}
+console.log(`\n   The ratio is G_LATTICE = ${G_LATTICE.toFixed(6)} at every mass, exactly, because`);
+console.log("   m_P·l_P = ħ/c. Nothing quantum was put in; 'period = 1/mass' in");
+console.log("   the lattice's units IS the Compton relation.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
index bd5e943..c27dc45 100755
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
@@ -17,7 +17,8 @@ OPTS='{"module":"commonjs","target":"es2020"}'
 
 [ -x "$TS" ] || { echo "ts-node not found at $TS"; exit 1; }
 
-# rough order: the force law, then the cosmology, then dark matter, then closure
+# rough order: the force law, the cosmology, dark matter, closure, then
+# electromagnetism
 ORDER=(
   three combined
   frontcheck sne
@@ -28,6 +29,7 @@ ORDER=(
   genzel empty spacing
   blocking redo shape quant steps joint
   recon which138 accum accumulate asym
+  pulses magnets coulomb moment dipole poles ordering budget tradeoff scale maxwell
 )
 
 if [ "${1:-}" = "--list" ]; then printf '%s\n' "${ORDER[@]}"; exit 0; fi
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/scale.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/scale.ts
new file mode 100644
index 0000000..10bdb66
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/scale.ts
@@ -0,0 +1,213 @@
+/**
+ * WHAT A GIVEN MASS CAN MANAGE AS A MAGNET — the ceiling, at every scale from
+ * one electron to a magnetar, and how much of it anything actually uses.
+ *
+ * Three things get settled here, and they are the three that turn "a magnet is
+ * a lopsided default" into numbers.
+ *
+ * AN EMITTER DOES NOT HAVE TO EMIT. It can skip, and skipping is not free:
+ * `beat = 1/mass` means the pulses ARE the mass, so an emitter letting go on a
+ * fraction φ of its ticks weighs φ of the ceiling. Emission frequency and
+ * weight are one quantity said twice, which is why nothing here has to choose
+ * between them — and which is what makes the next question well posed.
+ *
+ * SO HOW MUCH MAGNET CAN A GIVEN MASS BUY. The signed pulses are a subset of
+ * the pulses, so the bias P = signed/total is at most one, and the moment of a
+ * body is bounded by the moment of its constituents times how many it has.
+ * That bound turns out to depend on WHAT the constituents are and not only how
+ * much they weigh, and the dependence goes the useful way.
+ *
+ * SCOPE: magnetism. Wherever µ_B or an electron count appears it is a measured
+ * input standing in for a model of matter the article does not have.
+ *
+ * AND THEN SCALE. A big body screens itself — `shows` in `gravity.ts` — so
+ * only a skin of it can emit anything that gets out, and the aggregate goes as
+ * an AREA rather than a volume. Which is how a planet or a star gets a field
+ * at all, and the question is whether the area law leaves enough.
+ */
+
+const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
+const ME = 9.1093837015e-31, MP_ = 1.67262192369e-27, E_Q = 1.602176634e-19;
+const MU0 = 4e-7 * Math.PI, MU_B = 9.2740100783e-24, MU_N = 5.0507837461e-27;
+const M_PLANCK = Math.sqrt(HBAR * C / G_N);
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const BITE = 1, CORE = 0.5, LIGHT = 1, CYCLE = 8;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const MU = G_LATTICE * M_PLANCK;
+
+/** the model's own magneton, from `moment`: CYCLE·G/2π, in units of µ_B */
+const MAGNETON = CYCLE * G_LATTICE / (2 * Math.PI);
+
+/** pulses a second */
+const pulses = (m: number) => m * C * C / (G_LATTICE * HBAR);
+
+console.log("=".repeat(78));
+console.log("1. SKIPPING IS LOSING WEIGHT — so there is nothing to trade");
+console.log("=".repeat(78));
+console.log("   An emitter letting go on a fraction φ of its ticks weighs φ of");
+console.log("   the ceiling, because the pulses are the mass. So a magnet cannot");
+console.log("   buy strength by pulsing more — it is already pulsing as often as");
+console.log("   its weight says. What it can do is fail to CANCEL.\n");
+console.log("      φ (ticks used)   mass (of MU)      pulses/s        weight");
+for (const phi of [1, 0.5, 1e-6, 6.713e-22]) {
+  const m = phi * MU;
+  console.log(`   ${phi.toExponential(2).padStart(14)}   ${phi.toExponential(2).padStart(10)}   ` +
+    `${pulses(m).toExponential(3)}   ${m.toExponential(3)} kg`);
+}
+console.log(`\n   The last row is an electron's mass: one tick in 1.5×10²¹, and`);
+console.log("   that IS what being light means here.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. THE CEILING, AND WHY IT PICKS THE LIGHTEST THING");
+console.log("=".repeat(78));
+console.log("   One emitter's ring has radius r = (CYCLE·G/2π)·λ̄_C, and λ̄_C goes");
+console.log("   as 1/m, so a HEAVIER emitter is a SMALLER loop:");
+console.log("\n      µ_one = (CYCLE·G/2π)·qħ/2m     ∝ 1/m");
+console.log("\n   A body of mass M made of them has M/m of them, so\n");
+console.log("      µ_max/M = (CYCLE·G/2π)·qħ/2m²   ∝ 1/m²\n");
+console.log("   — and the moment per kilogram goes as the INVERSE SQUARE of what");
+console.log("   the body is made of. The lightest thing wins by a mile, and that");
+console.log("   is a scaling law rather than a claim about what emitters are:\n");
+console.log("      constituent   µ_one (model)    µ_one (measured)    µ_max/M (A·m²/kg)");
+for (const [n, m, meas] of [
+  ["electron", ME, MU_B],
+  ["proton", MP_, MU_N],
+] as [string, number, number][]) {
+  const one = MAGNETON * E_Q * HBAR / (2 * m);
+  console.log(`      ${n.padEnd(12)}  ${one.toExponential(3)}      ${meas.toExponential(3)}       ` +
+    `${(meas / m).toExponential(3)}`);
+}
+console.log(`\n      ratio, electron over proton:  model ${(MP_ / ME).toFixed(1)}   ` +
+  `measured µ_B/µ_N ${(MU_B / MU_N).toFixed(1)}`);
+console.log("\n   SO THE LIGHTEST CONSTITUENT DOMINATES, BY THE SQUARE OF ITS MASS —");
+console.log("   the derived statement, and it is about scaling, not about electrons.");
+console.log("   The model has no matter in it and does not say what its emitters");
+console.log("   are. What the 1/m² buys is that IF a body has light and heavy\n   charged constituents, the light ones carry the magnetism — which is\n   the fact that µ_B/µ_N = 1836 records.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. HOW MUCH OF THE CEILING ANYTHING ACTUALLY USES");
+console.log("=".repeat(78));
+// A·m² per kg with every electron fully lopsided. THE ELECTRON IS AN INPUT:
+// the model does not say what its emitters are, so this is "the ceiling on the
+// electron reading" rather than "the model's ceiling".
+const CEIL = MU_B / ME;
+const CEIL_MODEL = MAGNETON * CEIL;
+console.log(`      ceiling, measured µ_B    ${CEIL.toExponential(3)} A·m²/kg`);
+console.log(`      ceiling, model's own     ${CEIL_MODEL.toExponential(3)} A·m²/kg   (×${MAGNETON.toFixed(4)})\n`);
+console.log("      material               µ/M (A·m²/kg)    P = used/ceiling");
+const MATS: [string, number, number][] = [
+  ["NdFeB N52", 1.45, 7500],
+  ["SmCo5", 0.95, 8300],
+  ["ferrite Y30", 0.40, 4900],
+  ["iron, saturated", 2.15, 7874],
+  ["cobalt, saturated", 1.79, 8900],
+  ["nickel, saturated", 0.61, 8908],
+];
+for (const [n, Br, rho] of MATS) {
+  const perkg = (Br / MU0) / rho;
+  console.log(`   ${n.padEnd(22)} ${perkg.toFixed(1).padStart(11)}      ${(perkg / CEIL).toExponential(3)}`);
+}
+console.log("\n   A few parts in a hundred thousand, everywhere. So the ceiling is");
+console.log("   nowhere near binding for a laboratory magnet — what limits a");
+console.log("   magnet is how much of its matter can be made to agree, and that");
+console.log("   is chemistry, which this model does not have.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. AND HOW MANY PULSES THAT IS");
+console.log("=".repeat(78));
+console.log("      object                total pulses/s   signed pulses/s   P");
+for (const [n, M, Br, rho] of [
+  ["a 1 cm³ N52 cube", 7.5e-3, 1.45, 7500],
+  ["an iron nail, 3 g", 3e-3, 2.15, 7874],
+  ["a 1 kg magnet", 1.0, 1.45, 7500],
+] as [string, number, number, number][]) {
+  const P = ((Br / MU0) / rho) / CEIL;
+  console.log(`   ${n.padEnd(22)} ${pulses(M).toExponential(3)}   ${(P * pulses(M)).toExponential(3)}   ${P.toExponential(2)}`);
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("5. SCALE — a big body can only emit from its skin");
+console.log("=".repeat(78));
+console.log("   `shows` in `gravity.ts` is exactly this: past a size, a body's");
+console.log("   own emission is absorbed on the way out and only a skin escapes,");
+console.log("   with `SKIN = √2/5` setting the surface term. So the aggregate");
+console.log("   ceiling for a planet or a star is an AREA law:\n");
+console.log("      µ_max = (4πR²·δ·ρ / m_e) · µ_B\n");
+console.log("   which is the point of asking about it: a big body is not limited");
+console.log("   by its mass, it is limited by its surface. So run it backwards —");
+console.log("   given what is measured, how deep a FULLY ALIGNED skin would do?\n");
+console.log("      body           R (m)      B_surf (T)    µ (A·m²)     skin needed");
+const BODIES: [string, number, number, number][] = [
+  // name, radius m, surface field T, mean density kg/m³
+  ["Earth", 6.371e6, 5.0e-5, 5515],
+  ["Jupiter", 6.99e7, 4.2e-4, 1326],
+  ["the Sun", 6.96e8, 1.0e-4, 1408],
+  ["a white dwarf", 7.0e6, 1.0e3, 1.0e9],
+  ["a neutron star", 1.2e4, 1.0e8, 5.9e17],
+  ["a magnetar", 1.2e4, 1.0e11, 5.9e17],
+];
+for (const [n, R, B, rho] of BODIES) {
+  const mu = 4 * Math.PI * R * R * R * B / MU0;           // B = µ0·µ/4πR³ at the pole-ish
+  const need = mu / CEIL;                                  // kg of fully aligned electrons' worth
+  const delta = need / (4 * Math.PI * R * R * rho);
+  console.log(`   ${n.padEnd(15)} ${R.toExponential(2)}   ${B.toExponential(1).padStart(9)}   ` +
+    `${mu.toExponential(2)}   ${delta.toExponential(2)} m`);
+}
+console.log("\n   Millimetres for the Earth, metres for the Sun, a tenth of a");
+console.log("   micron for a neutron star. THE AREA LAW IS NOWHERE NEAR BINDING");
+console.log("   at any scale — a skin thinner than a coin, fully aligned, carries");
+console.log("   the Earth's whole field. So 'use the surface for more emitting'");
+console.log("   works, and works with enormous room to spare.");
+console.log("\n   Which is worth being clear about, because it is a null result in");
+console.log("   the useful direction: scale is not what stops this model doing");
+console.log("   electromagnetism. The budget is fine at every size from an");
+console.log("   electron to a magnetar. What is missing is the COUPLING — see");
+console.log("   `coulomb` — and no amount of surface buys that.");
+console.log("\n   (And a real planetary field is a dynamo in a moving conductor,");
+console.log("   not a magnetised skin. The number above is a ceiling, not a");
+console.log("   claim about how the Earth does it.)");
+
+console.log();
+console.log("=".repeat(78));
+console.log("6. WHAT IS OWED — the relation this cannot yet write");
+console.log("=".repeat(78));
+console.log("   P is measured everywhere above and derived nowhere. To predict it");
+console.log("   the model would have to say how a configuration of matter decides");
+console.log("   how lopsided its emitters are — which is the same missing piece as");
+console.log("   `physics.ts`'s open question about a carrier's update cost, and is");
+console.log("   a statement about matter rather than about fields.");
+console.log("\n   THE LIKELY SHAPE OF IT, noted so it can be checked later: the mass");
+console.log("   pulsing and the biased pulsing are the same stream, so a relation");
+console.log("   between them is a relation between `beat` and `dwell`, and both are");
+console.log("   counted in ticks of the same CYCLE. Which already forces one thing —");
+console.log("   see below.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("7. AND ONE THING THAT FALLS OUT NOW: MAGNETISATION IS QUANTISED");
+console.log("=".repeat(78));
+console.log("   `dwell` is a count of ticks out of CYCLE, so it cannot be any real");
+console.log("   number — it is k/CYCLE for an integer k, and P = 2·dwell − 1 comes");
+console.log("   in steps of 2/CYCLE:\n");
+console.log("      ticks one way   dwell     P");
+for (let k = 4; k <= 8; k++)
+  console.log(`   ${String(k).padStart(15)}   ${(k / CYCLE).toFixed(3)}   ${((2 * k - CYCLE) / CYCLE).toFixed(2).padStart(5)}`);
+console.log(`\n   So the smallest magnetisation a single emitter can carry is`);
+console.log(`   2/CYCLE = ${(2 / CYCLE).toFixed(2)}, and a magnet's total is that times a count.`);
+console.log("   Which fixes how many emitters are lopsided in a real magnet:\n");
+console.log("      material            P (bulk)      emitters at the minimum");
+for (const [n, Br, rho] of MATS.slice(0, 4)) {
+  const P = ((Br / MU0) / rho) / CEIL;
+  console.log(`   ${n.padEnd(22)} ${P.toExponential(3)}   ${(P / (2 / CYCLE)).toExponential(3)} of all of them`);
+}
+console.log("\n   A prediction with no free parameter in it, and no way to measure");
+console.log("   it that anybody has — but it is the kind of thing that becomes a");
+console.log("   test the moment a model of matter exists to attach it to.");
+
+export {};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/tradeoff.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/tradeoff.ts
new file mode 100644
index 0000000..4e9138c
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/tradeoff.ts
@@ -0,0 +1,135 @@
+/**
+ * THE CEILING IS SHARED — so being a magnet costs weight, and that is
+ * measurable.
+ *
+ * `beat = 1/mass` with `mass ≤ 1` says an emitter lets go at most once a tick,
+ * and the pulses ARE the mass. If some of those pulses are spent being a
+ * magnet instead, they are not being mass, and the body weighs less. One
+ * budget, two uses:
+ *
+ *     f  spent on the magnetic layer
+ *     1 − f  left over as mass
+ *
+ * That is not a free choice of the model's; it follows from there being one
+ * ceiling. And it has a consequence nothing else in the article has: MAGNETISING
+ * A THING MAKES IT LIGHTER, by exactly f.
+ *
+ * Which is a real prediction, and it runs the other way too — the mass of a
+ * magnet is measured very well, so a null result puts a FLOOR under how strong
+ * the magnetic coupling has to be. That floor is the useful output here,
+ * because the coupling is the one thing `budget` leaves owed.
+ */
+
+const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
+const MU0 = 4e-7 * Math.PI;
+const M_PLANCK = Math.sqrt(HBAR * C / G_N);
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const BITE = 1, CORE = 0.5, LIGHT = 1;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const MU = G_LATTICE * M_PLANCK;
+
+const pulses = (m: number) => m * C * C / (G_LATTICE * HBAR);
+const KAPPA = Math.sqrt(MU0 / (4 * Math.PI * G_N));    // kg per A·m, from `budget`
+
+console.log("=".repeat(78));
+console.log("1. ONE BUDGET, TWO USES");
+console.log("=".repeat(78));
+console.log("   An emitter spending a fraction f of its ticks on the magnetic");
+console.log("   layer has 1 − f left for mass. So a saturated magnet must weigh");
+console.log("   less than the same matter unmagnetised, by f.\n");
+console.log("      f          mass left     what it would look like");
+for (const f of [0.5, 1e-3, 1e-5, 1e-10, 1e-15]) {
+  const note = f >= 1e-5 ? "impossible — a balance sees 10⁻⁹"
+    : f >= 1e-10 ? "at the edge of what is measurable"
+      : "invisible to anything now built";
+  console.log(`   ${f.toExponential(0).padStart(9)}   ${(1 - f).toFixed(10)}   ${note}`);
+}
+
+console.log();
+console.log("=".repeat(78));
+console.log("2. SO MEASURE IT BACKWARDS — the floor under the coupling");
+console.log("=".repeat(78));
+console.log("   `budget` says a magnet's pull, expressed in the gravity channel,");
+console.log("   needs an effective mass m_eff = q·√(µ0/4πG). If the magnetic layer");
+console.log("   buys that with a fraction f of the SAME pulses, then whatever the");
+console.log("   magnetic coupling κ is, it satisfies\n");
+console.log("      κ · f · m   =   m_eff        ⇒     κ  =  m_eff / (f · m)\n");
+console.log("   and an upper limit on f is a LOWER limit on κ:\n");
+console.log("      magnet              m_eff/m      κ if f = 10⁻⁹     κ if f = 10⁻¹²");
+type Bar = { name: string; Br: number; rho: number; A: number; L: number };
+const BARS: Bar[] = [
+  { name: "N52, 1 cm cube", Br: 1.45, rho: 7500, A: 1e-4, L: 0.01 },
+  { name: "ferrite, 1 cm cube", Br: 0.40, rho: 4900, A: 1e-4, L: 0.01 },
+  { name: "iron, saturated bar", Br: 2.15, rho: 7874, A: 1e-5, L: 0.05 },
+];
+for (const b of BARS) {
+  const q = (b.Br / MU0) * b.A, mass = b.rho * b.A * b.L;
+  const ratio = q * KAPPA / mass;
+  console.log(`   ${b.name.padEnd(20)} ${ratio.toExponential(2)}     ` +
+    `${(ratio / 1e-9).toExponential(2).padStart(12)}    ${(ratio / 1e-12).toExponential(2)}`);
+}
+console.log("\n   So the magnetic layer's pulses are worth at least 10¹⁴–10¹⁷ times");
+console.log("   a gravitational pulse, and that is a bound derived from a weighing");
+console.log("   rather than a number put in.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("3. AND THE PREDICTION, STATED SO IT CAN BE SHOT AT");
+console.log("=".repeat(78));
+console.log("   Take two identical iron bars, saturate one, weigh both against");
+console.log("   each other. The model says the magnetised one is LIGHTER by f.\n");
+{
+  const m = 1.0;                                    // 1 kg bars
+  console.log(`      bars of         ${m.toFixed(1)} kg each`);
+  console.log(`      best comparator ~10⁻¹⁰ relative, so ~${(m * 1e-10).toExponential(1)} kg`);
+  console.log("");
+  console.log("      IF f were 10⁻⁵ (the bulk bias P of a saturated magnet):");
+  console.log(`         Δm = ${(m * 1e-5).toExponential(1)} kg — five orders above the limit,`);
+  console.log("         so THIS IS ALREADY EXCLUDED. The magnetic layer does not");
+  console.log("         spend one pulse per unit of bias.");
+  console.log("");
+  console.log("      IF f is below 10⁻¹⁰, nothing measurable follows, and the");
+  console.log("      coupling is above the floor in section 2.");
+}
+console.log("\n   Which is the useful shape of a null result: it does not confirm");
+console.log("   the model, it EXCLUDES the cheap version of it. The magnetic layer");
+console.log("   cannot be 'the same pulses, counted with signs' at any efficiency");
+console.log("   near one — the weighing already forbids it.");
+
+console.log();
+console.log("=".repeat(78));
+console.log("4. AND THE OTHER SIDE OF THE TRADE, WHICH IS THE SHARPER TEST");
+console.log("=".repeat(78));
+console.log("   If mass and magnetism share a budget then a very strong magnet is");
+console.log("   a slightly lighter one — and equally, the HEAVIEST matter should");
+console.log("   be the WORST magnet, because it has nothing spare. That is a");
+console.log("   correlation, and correlations survive not knowing the coupling.\n");
+console.log("      material            ρ (kg/m³)   M (A/m)     M/ρ (A·m²/kg)");
+const MATS: [string, number, number][] = [
+  ["iron", 7874, 2.15], ["cobalt", 8900, 1.79], ["nickel", 8908, 0.61],
+  ["N52", 7500, 1.45], ["ferrite Y30", 4900, 0.40], ["SmCo5", 8300, 0.95],
+];
+const pts: [number, number][] = [];
+for (const [n, rho, Br] of MATS) {
+  const M = Br / MU0;
+  pts.push([rho, M / rho]);
+  console.log(`   ${n.padEnd(20)} ${String(rho).padStart(8)}   ${M.toExponential(2)}   ${(M / rho).toFixed(1)}`);
+}
+{
+  // Pearson correlation between density and moment per kg
+  const n = pts.length;
+  const mx = pts.reduce((a, p) => a + p[0], 0) / n, my = pts.reduce((a, p) => a + p[1], 0) / n;
+  let sxy = 0, sxx = 0, syy = 0;
+  for (const [x, y] of pts) { sxy += (x - mx) * (y - my); sxx += (x - mx) ** 2; syy += (y - my) ** 2; }
+  const r = sxy / Math.sqrt(sxx * syy);
+  console.log(`\n      correlation of density with moment per kg:  r = ${r.toFixed(3)}`);
+  console.log("\n   Weakly negative, which is the sign the trade-off predicts — but");
+  console.log("   six points spanning a factor of two in density prove nothing, and");
+  console.log("   the obvious confound is that these are different chemistries and");
+  console.log("   not the same matter budgeted differently. RECORDED AS SUGGESTIVE");
+  console.log("   AND NOT AS EVIDENCE. The clean version is the weighing above.");
+}
+
+export {};

From 2edf9a3d0f791dcff77c08133054912f0ea35686 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Wed, 12 Aug 2026 23:10:04 +0200
Subject: [PATCH 32/47] Convert into a booklet

---
 .../physics/[[...section]]/PhysicsClient.tsx  |   7 +
 .../app/physics/[[...section]]/page.tsx       |  50 ++++
 orbitmines.com/src/lib/post/Book.tsx          |  16 +-
 orbitmines.com/src/routes/Minimap.tsx         |   4 +-
 orbitmines.com/src/routes/Physics.tsx         | 222 ++++++++++++++++++
 .../archive/2026.RayCalculiAndPhysics/law.tsx | 124 +++++++++-
 .../2026.RayCalculiAndPhysics/models.ts       |   4 +-
 .../2026.RayCalculiAndPhysics/tests/README.md |   6 +
 .../tests/nopolarity.ts                       |   2 +-
 .../2026.RayCalculiAndPhysics/tests/run.sh    |   1 +
 orbitmines.com/src/routes/references.tsx      |  30 +++
 11 files changed, 454 insertions(+), 12 deletions(-)
 create mode 100644 orbitmines.com/app/physics/[[...section]]/PhysicsClient.tsx
 create mode 100644 orbitmines.com/app/physics/[[...section]]/page.tsx
 create mode 100644 orbitmines.com/src/routes/Physics.tsx

diff --git a/orbitmines.com/app/physics/[[...section]]/PhysicsClient.tsx b/orbitmines.com/app/physics/[[...section]]/PhysicsClient.tsx
new file mode 100644
index 0000000..2e76d9b
--- /dev/null
+++ b/orbitmines.com/app/physics/[[...section]]/PhysicsClient.tsx
@@ -0,0 +1,7 @@
+'use client';
+
+import Physics from '../../../src/routes/Physics';
+
+export default function PhysicsClient() {
+  return <Physics />;
+}
diff --git a/orbitmines.com/app/physics/[[...section]]/page.tsx b/orbitmines.com/app/physics/[[...section]]/page.tsx
new file mode 100644
index 0000000..84cedbc
--- /dev/null
+++ b/orbitmines.com/app/physics/[[...section]]/page.tsx
@@ -0,0 +1,50 @@
+import type {Metadata} from 'next';
+import fs from 'fs';
+import path from 'path';
+import {sectionSlug} from '../../../src/lib/post/sectionSlug';
+import PhysicsClient from './PhysicsClient';
+
+const BOOK_TITLE = 'OrbitMines: Notes on Physics';
+
+// The same arrangement the Almanac uses: arcs and sections live in the path
+// (/physics/<section-slug>) as client-side shallow routes within the book, and
+// every one is prerendered as its own URL so that dev and the static export
+// both serve them, and a refresh on a deep link does not 404.
+//
+// Derived from the source at build time rather than kept by hand, so adding an
+// arc is one edit rather than two.
+export function physicsSections(): {slug: string; head: string}[] {
+  const src = fs.readFileSync(
+    path.join(process.cwd(), 'src/routes/Physics.tsx'),
+    'utf8',
+  );
+  const heads = [...src.matchAll(/<(?:Arc|Section)\s+head="([^"]+)"/g)].map((m) => m[1]);
+  const bySlug = new Map<string, string>();
+  for (const head of heads) {
+    const slug = sectionSlug(head);
+    if (slug && !bySlug.has(slug)) bySlug.set(slug, head);
+  }
+  return [...bySlug].map(([slug, head]) => ({slug, head}));
+}
+
+export function generateStaticParams() {
+  return [
+    {section: [] as string[]},
+    ...physicsSections().map(({slug}) => ({section: [slug]})),
+  ];
+}
+
+export const dynamicParams = false;
+
+export async function generateMetadata(
+  {params}: {params: Promise<{section?: string[]}>},
+): Promise<Metadata> {
+  const slug = (await params).section?.[0];
+  if (!slug) return {title: BOOK_TITLE};
+  const head = physicsSections().find((s) => s.slug === slug)?.head;
+  return {title: head ? `${BOOK_TITLE} - ${head.trim()}` : BOOK_TITLE};
+}
+
+export default function Page() {
+  return <PhysicsClient />;
+}
diff --git a/orbitmines.com/src/lib/post/Book.tsx b/orbitmines.com/src/lib/post/Book.tsx
index 7a0f7b0..11010fa 100644
--- a/orbitmines.com/src/lib/post/Book.tsx
+++ b/orbitmines.com/src/lib/post/Book.tsx
@@ -66,8 +66,12 @@ export class BookUtil {
   nextSection = (reverse: boolean = false) => this.sectionName(this.next(reverse))
 
   sectionName = (element: any) => {
-    if (typeof element.props.head === "string") return element.props.head
-    if (element.props.head.props != undefined) return element.props.head.props.children
+    // Defensive at both levels: `firstSection()` reads `allSections()[0]`,
+    // which is undefined for a book with no arcs, and a Section may carry no
+    // head at all. Neither is worth a blank page.
+    const head = element?.props?.head
+    if (typeof head === "string") return head
+    if (head?.props !== undefined) return head.props.children
     return ""
   }
   disabled = (element: any) => typeof element.props.head !== "string"
@@ -173,12 +177,16 @@ export const Navigation = (props: PaperProps & { hideBorder?: boolean, onNavigat
       <a className="bp5-text-muted" data-selected={util.isSelected(arc) || undefined} style={{color: util.isSelected(arc) ? 'orange' : '#abb3bf'}} onClick={() => !util.disabled(arc) ? navigate(util.sectionName(arc)) : undefined}>{arc.props.head}</a>
 
       {React.Children.toArray((arc as any).props.children).filter(child =>
-        React.isValidElement(child) && child.type === Section
+        // `props.head` is what makes a Section navigable — see `getSections`.
+        // Without it there is nothing to name the link after, and `sectionName`
+        // reads `props.head.props` and throws. A Section used purely to group
+        // prose is content, not a destination.
+        React.isValidElement(child) && child.type === Section && (child.props as any).head
       ).map((section: any) => <Col key={util.sectionName(section)} xs={12} style={{textAlign: 'start'}} className="pt-3">
         <a className="bp5-text-muted ml-5" data-selected={util.isSelected(section) || undefined} style={util.isSelected(section) ? {color: 'orange'} : {}} onClick={() => !util.disabled(section) ? navigate(util.sectionName(section)) : undefined}>{section.props.head}</a>
 
         {React.Children.toArray((section as any).props.children).filter(child =>
-          React.isValidElement(child) && child.type === Section
+          React.isValidElement(child) && child.type === Section && (child.props as any).head
         ).map((section: any) => <Col key={util.sectionName(section)} xs={12} style={{textAlign: 'start'}}>
           <a className="bp5-text-muted ml-10" data-selected={util.isSelected(section) || undefined} style={util.isSelected(section) ? {color: 'orange'} : {}} onClick={() => !util.disabled(section) ? navigate(util.sectionName(section)) : undefined}>{section.props.head}</a>
 
diff --git a/orbitmines.com/src/routes/Minimap.tsx b/orbitmines.com/src/routes/Minimap.tsx
index 737f29e..cbac2e7 100644
--- a/orbitmines.com/src/routes/Minimap.tsx
+++ b/orbitmines.com/src/routes/Minimap.tsx
@@ -6,11 +6,11 @@ import {Author, Col, CustomIcon, Layer, pageStyles, Reference, Row} from "../lib
 import {PROFILES} from "./profiles/profiles";
 import {Button} from "@blueprintjs/core";
 import {download, DownloadButton, LoginButton, os} from "../@orbitmines/ether/Ether";
-import {ON_INTELLIGIBILITY, ON_ORBITS, _2024_02_ORBITMINES_AS_A_GAME_PROJECT, TOWARDS_A_UNIVERSAL_LANGUAGE, ETHERS_ALMANAC, ORBITMINES_MINECRAFT_ARCHIVE, RAY_CALCULI_AND_PHYSICS} from "./references";
+import {ON_INTELLIGIBILITY, ON_ORBITS, _2024_02_ORBITMINES_AS_A_GAME_PROJECT, TOWARDS_A_UNIVERSAL_LANGUAGE, ETHERS_ALMANAC, ORBITMINES_MINECRAFT_ARCHIVE, RAY_CALCULI_AND_PHYSICS, PHYSICS} from "./references";
 
 
 const Minimap = () => {
-  const papers = [ETHERS_ALMANAC.UPDATES[0], RAY_CALCULI_AND_PHYSICS, ORBITMINES_MINECRAFT_ARCHIVE, TOWARDS_A_UNIVERSAL_LANGUAGE, _2024_02_ORBITMINES_AS_A_GAME_PROJECT, ON_ORBITS, ON_INTELLIGIBILITY];
+  const papers = [ETHERS_ALMANAC.UPDATES[0], PHYSICS, ORBITMINES_MINECRAFT_ARCHIVE, TOWARDS_A_UNIVERSAL_LANGUAGE, _2024_02_ORBITMINES_AS_A_GAME_PROJECT, ON_ORBITS, ON_INTELLIGIBILITY];
 
   const profile = ORGANIZATIONS.orbitmines_research.profile;
 
diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
new file mode 100644
index 0000000..743fc34
--- /dev/null
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -0,0 +1,222 @@
+import Post, {
+  Arc, BlueprintIcons16, BlueprintIcons20, BR, JetBrainsMono, PaperProps, Section,
+  Title, renderable, useCounter,
+} from "../lib/post/Post";
+import { PHYSICS } from "./references";
+
+import { bySide, Graph } from "./archive/2026.RayCalculiAndPhysics/discrete";
+import { Law, MagnetismLaw, WithoutPolarity } from "./archive/2026.RayCalculiAndPhysics/law";
+import { lineGroups } from "./archive/2026.RayCalculiAndPhysics/lines";
+import { Model } from "./archive/2026.RayCalculiAndPhysics/model";
+import { ALONE_FOR, asGroup, MODELS, weighed } from "./archive/2026.RayCalculiAndPhysics/models";
+import { PACE, Polarity } from "./archive/2026.RayCalculiAndPhysics/physics";
+import { Models } from "./archive/2026.RayCalculiAndPhysics/views";
+import {
+  BarField, Ceiling, Fields, Kinds, Lopsided, Pairs,
+} from "./archive/2026.RayCalculiAndPhysics/magnetism";
+
+/**
+ * OrbitMines: Notes on Physics — a booklet rather than a paper.
+ *
+ * WHY IT IS A BOOK. What was one article is three things that are read
+ * separately and that fail separately. Gravity comes out of the lattice with
+ * its scale unfitted; magnetism comes out of the same integral once the signs
+ * are kept, and owes one coupling; the electric half is not started. Those are
+ * three different kinds of statement about three different amounts of
+ * evidence, and running them together as one paper made the weakest of them
+ * borrow the credibility of the strongest.
+ *
+ * So they are arcs, in the order they build on each other, and each one says
+ * at its head what it has actually earned. `references.tsx` carries the same
+ * three as `NOTES_ON_PHYSICS.NOTES`, so a note is citable on its own.
+ *
+ * AND THE ORDER IS NOT A NARRATIVE CHOICE. `tests/nopolarity` measures it:
+ * with the polarity taken out, every gravitational prediction here is
+ * identical to every digit quoted. So Gravity does not depend on Magnetism,
+ * Magnetism does depend on the emission Gravity is built out of, and the
+ * electric half depends on a model of matter neither of them has. The arcs are
+ * in dependency order because the model is.
+ *
+ * The subsections inside each arc are not written yet; the arcs are the
+ * skeleton they will hang from.
+ */
+const Physics = () => {
+  const referenceCounter = useCounter();
+
+  const book: Omit<PaperProps, 'children'> = {
+    book: true,
+    ...PHYSICS.reference,
+    title: renderable<React.ReactNode>((PHYSICS.reference.title as any), () => <>
+      <Title>OrbitMines: Physics Project</Title>
+    </>),
+    header: <>
+      <Models models={[{
+          name: '',
+          note: '',
+          world: { sources: weighed([{ at: [-12, 0], turning: 1, drift: [PACE, 0] }]) },
+          lattice: false,
+          metric: { span: 14, cycle: 100 },
+        }]}/>
+    </>,
+    pdf: {
+      fonts: [JetBrainsMono, BlueprintIcons20, BlueprintIcons16],
+    },
+    Reference: (props: {}) => (<></>),
+    references: referenceCounter,
+  };
+
+  // The same strips either way along: `backwards` lays the run out last-state
+  // first, with the arrow AND every charge's heading turned round — which is
+  // how the creation rule is drawn, annihilation being run the other way.
+  const strips = (backwards = false) => lineGroups(2).map((group) => asGroup(
+    '',
+    group,
+    { ticks: 1, filmstrip: true, height: 60, density: false, backwards },
+  ));
+
+  const DISCRETE = strips(), BACKWARD = strips(true);
+
+  return <Post {...book}>
+
+    <Arc head="2026. ">
+      I should probably preface this by saying that I am not a physicist by training. So my writing will likely not inheret the same culture as you would see in say a typical physics paper. My hope is that these ideas are useful enough to forgive those transgressions.
+      <BR/>
+      So here goes.
+      <BR/>
+      Emergence. That's the topic at play here. The question is: "How do you recover gravity and electromagnetism from local interactions?". I personally wanted a discrete model of physics I could point to which had such properties, and so birthed this idea.
+      <BR/>
+      Specifically, the idea would be the universe's tendency to exhibit XOR behavior on several scales. This is at least how I came to this idea. Two separate examples would be magnetism, and charged matter. In both cases: Opposites attract, Sameness repells. Hence my naming it XOR.
+      <BR/>
+      The model is essentially this idea taken to an extreme. Let me introduce the discrete model first, which (for someone like me) is much easier to understand the *why* of the thing. In order to later introduce the continuous model.
+      <BR/>
+      These notes are in three parts, and they are in that order because the model is. <b>#1: Gravity</b> is the one that stands on its own — measured, with its scale unfitted. <b>#2: Magnetism</b> is the same emission counted a second way, and it owes one number. <b>#3: Electromagnetism</b> is not started, and says so.
+    
+
+      <Section head="Gravity">
+          <b>#1 of three.</b> This is the part that stands on its own. A meeting
+          between two charges takes a point of space out of the world, so the only
+          thing two bodies can do to each other is remove what is between them —
+          and that, counted, is the pull. What comes out of the counting is
+          Newton's law, the metric, Mercury's perihelion, light's deflection, and
+          a rotation curve fitted to 1.1% with nothing tuned.
+          <BR/>
+          Nothing on this arc uses a sign. Which is not a stylistic claim:{' '}
+          take the polarity out of the model entirely and every number below is
+          identical to every digit quoted — see the end of <b>#2</b>.
+
+        <Section head="The Discrete Model">
+          It comes down to three essential rules:
+          <BR/>
+          (1) Annihilation: When two opposite polarities meet, they annihilate, leaving a single neutral spatial point behind.
+
+          <Models models={[DISCRETE[5]]}/>
+
+          (2) Repulsion: When two identical polarities meet, they turn around.
+
+          <Models models={[DISCRETE[4]]}/>
+
+          (3) Creation: A neutral point expands into two points with opposite polarity in all directions.
+
+          <Models models={[BACKWARD[5]]}/>
+
+          Then the other permutations of the rules are just movement rules (like these two).
+
+          <Models models={[DISCRETE[1]]}/>
+
+          With this setup, we get aggregate behavior of groups of the same polarities, turning away from each other.
+
+          <Models models={([
+              [Polarity.Positive, Polarity.Positive],
+              [Polarity.Negative, Polarity.Negative],
+          ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
+            name: '',
+            note: '',
+            lattice: {
+              seed: () => Graph.blocks({ charge: bySide(left, right) }),
+              ticks: 15, height: 140, density: false,
+            },
+          }))}/>
+
+          And ones with opposite polarities annihilating each-other.
+
+          <Models models={([
+              [Polarity.Positive, Polarity.Negative],
+          ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
+            name: '',
+            note: '',
+            lattice: {
+              seed: () => Graph.blocks({ charge: bySide(left, right) }),
+              ticks: 5, height: 140, density: false,
+            },
+          }))}/>
+
+          Then an interesting thing happens when you alternate polarities (the phase not mattering for this result). You get attraction.
+
+          <Models models={([
+            [Polarity.Positive, Polarity.Negative],
+            [Polarity.Positive, Polarity.Positive],
+          ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
+            name: '',
+            note: '',
+            lattice: {
+              seed: () => Graph.emitters({ left, right, gap: 20, every: 1, spin: true }),
+              ticks: 22, height: 140,
+            },
+          }))}/>
+
+          In 2D/3D these would of course get a little more complicated, but we can ignore that for now, this is only to form a basis for the idea. Instead: Based on these rules we can start extrapolating, let's continue to the continuous model for that, and afterwards return to the discrete.
+        
+              <Section head="The Continuous Model">
+
+        </Section>
+        </Section>
+
+        <Law />
+
+        <Models models={MODELS} />
+      </Section>
+
+      <Section head="Magnetism">
+          <b>#2 of three.</b> The same emission, counted a second way: with the
+          signs kept instead of thrown away. What falls out is magnetostatics —
+          the sign law, 3cos²θ − 1, the 1/R⁴ force, every orientation, no
+          monopoles — from the same integral that gave the pull, with nothing
+          added to it.
+          <BR/>
+          What it owes is a scale, and one number: the magnetic coupling.
+
+        <Kinds />
+        <Lopsided />
+        <Fields />
+        <Pairs />
+        <BarField />
+        <Ceiling />
+
+        <MagnetismLaw />
+
+        <WithoutPolarity />
+      </Section>
+      
+      <Section head="Electromagnetism">
+          <b>#3 of three, and it is not started.</b> Kept as an arc rather than
+          left out, because what is missing is specific and worth stating: there
+          is no account of matter in this model, so nothing in it says what an
+          electron or a positron would be, and the bias that gives magnetism is
+          not electric charge — a proton settles that, carrying the same charge as
+          an electron while emitting 1836 times as often.
+          <BR/>
+          And there is a structural piece missing under all of it. Every force
+          here is second order in the emission: nothing happens to a charge that
+          does not <i>meet</i> another charge. Electromagnetism needs a charge to
+          be pushed by a field it merely passes through, and there is no such rule
+          yet. Gravity never needed one, which is why <b>#1</b> works — a shortage
+          of space is exactly the kind of thing that only happens where two things
+          meet.
+      </Section>
+    </Arc>
+    <Arc head={<span className="bp5-text-disabled">2027.</span>}>
+    </Arc>
+  </Post>;
+};
+
+export default Physics;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 18b852e..c5d7b21 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -5366,6 +5366,25 @@ export const Law = () => {
       source emits into 4<V>π</V> and subtends nothing.
     </Note>
 
+
+    {open ? <Panel of={open} onClose={hide} /> : null}
+
+  </div>;
+};
+
+/**
+ * THE MAGNETIC HALF, WHICH IS ITS OWN NOTE.
+ *
+ * Split out of `Law` when the article became a booklet: the gravitational
+ * account and the magnetic one are separate readings of the same emission and
+ * they are now separate arcs, so they are separate components. Nothing here
+ * changed in the splitting — this is the same prose, lifted whole.
+ *
+ * No derivation panels in this half, which is why it needs no state where
+ * `Law` does: every equation on it is stated rather than opened.
+ */
+export const MagnetismLaw = () => (
+  <div style={{ marginBottom: '3rem' }}>
     <Head>and then magnetism</Head>
 
     <Note>
@@ -5716,7 +5735,106 @@ export const Law = () => {
       <code>physics.ts</code> already owes.
     </Note>
 
-    {open ? <Panel of={open} onClose={hide} /> : null}
+  </div>
+);
 
-  </div>;
-};
+/**
+ * AND THE ONE PLACE THE TWO ARE WEIGHED AGAINST EACH OTHER.
+ *
+ * Which belongs to neither on its own: it is the measurement that says the
+ * gravitational account does not depend on the magnetic one, and therefore
+ * that the two can be read apart at all. See `tests/nopolarity`.
+ */
+export const WithoutPolarity = () => (
+  <div style={{ marginBottom: '3rem' }}>
+    <Head>and the same theory with the XOR turned off</Head>
+
+    <Note>
+      Which is worth asking because it makes this a <i>family</i> rather than a
+      single thing. Take the polarity away — no signs, no opposites, just
+      discrete directions, and a meeting counted when two charges come at each
+      other head on. Does gravity notice?
+    </Note>
+
+    <Note>
+      Two things change in the rules and they pull opposite ways. The{' '}
+      <b style={{ color: INK }}>share</b> goes from ½ to 1, because every
+      meeting now annihilates where before only the opposite ones did. And the{' '}
+      <b style={{ color: INK }}>angular gate comes back</b> — with no sign to
+      decide the outcome there is nothing left but the angle, so{' '}
+      <K>closing</K> returns and the folding is bounded to a lens again.
+    </Note>
+
+    <Eq note="G doubles — and that is the whole of it">
+      <K>G</K> = <Frac
+        over={<><K>BITE</K>·<i>share</i>·<K>SHEET</K><Sup>2</Sup></>}
+        under={<>4<V>π</V><Sup>2</Sup>·<K>CORE</K>·<K>WAYS</K></>} />
+      <span style={{ padding: '0 1.4em' }} />
+      0.062351 → 0.124703
+    </Eq>
+
+    <Note>
+      And the factor of two is not observable. Every mass in the model is
+      carried in units of <K>GRAVITY</K>, so a body of physical mass <V>M</V>{' '}
+      holds <V>M</V>/<K>G</K> and the dynamics compute <K>G</K>·(<V>M</V>/<K>G</K>).
+      The constant is gone before it is used —{' '}
+      <b style={{ color: INK }}>a change of the mass unit, not of a
+        prediction</b>, which is the same statement <K>BITE</K> already carries.
+      Measured on the line integral: exactly two at every separation, with{' '}
+      <V>S</V>·<V>R</V><Sup>2</Sup> flat in both.
+    </Note>
+
+    <Rows of={[
+      [<span style={{ color: DERIVED }}>what does not move</span>,
+        <><K>SHEET</K>, <K>WAYS</K>, <K>BITE</K>, <K>BIAS</K>, <K>MADE</K>,{' '}
+          <K>SPREAD</K>, <K>REACHES</K>, and the tick — which is still exactly
+          the Planck time. <K>REACHES</K> is the pretty one: it carries <K>G</K>{' '}
+          on top and the share underneath, and the two cancel to the digit.</>],
+      [<span style={{ color: DERIVED }}>and what it predicts</span>,
+        <>Mercury’s sixth, the other five sixths, light’s deflection,{' '}
+          <V>a</V><Sub>0</Sub> = <V>c</V><V>H</V><Sub>0</Sub>/2<V>π</V>, the
+          Milky Way to 1.1%, the transport turnover, the interpolation function,
+          the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>.{' '}
+          <b style={{ color: INK }}>All identical, to every digit quoted</b> —
+          because every one of them is computed from something that never
+          mentions a sign.</>],
+      [<span style={{ color: BORROWED }}>where it really differs</span>,
+        <>Off the line. With the gate back the folding sits inside the sphere
+          having the two bodies as a diameter and comes to about a quarter as
+          much folding in space altogether — 0.230 of it, measured. Nothing in
+          the article reads that number: the dynamics read the line integral and
+          the metric reads <K>foldAt</K>, which is a fact about one body at one
+          place with no angle to gate.</>],
+      [<span style={{ color: BORROWED }}>and the rest</span>,
+        <><i>reach</i>’s λ is shorter by √2, worth 1.9·10<Sup>−10</Sup> →
+          3.8·10<Sup>−10</Sup> on the pull at 30 kpc. <K>MU</K> doubles to
+          2.71 µg. The Compton ratio becomes 0.124703 and stays exact. All three
+          are statements about units or about nothing anyone will weigh.</>],
+    ]} />
+
+    <Note>
+      <b style={{ color: INK }}>So gravity is the same theory.</b> Not
+      approximately — the shape of the force law, the metric, and every measured
+      prediction are untouched, and the one constant that moves cancels before
+      it is used.
+    </Note>
+
+    <Note>
+      What is lost is magnetism entirely — the sign law, 3cos²<V>θ</V> − 1,
+      1/<V>R</V><Sup>4</Sup>, ∇·<V>B</V> = 0, the quantised magnetisation — and
+      one explanation: with polarity{' '}
+      <b style={{ color: INK }}>the ½ in G is derived</b>, being the chance two
+      charges disagree, and it is why G would differ if matter were charged.
+      Without, the share is 1 by fiat and there is nothing to explain.
+    </Note>
+
+    <Note>
+      Which leaves the XOR as a <b style={{ color: INK }}>tunable parameter, and
+        a free one on the gravitational side</b>. Turning it on costs nothing and
+      buys magnetism; turning it off costs magnetism and buys nothing. That is a
+      better position than this page was in before the question was asked,
+      because it means the magnetic half cannot break the gravitational one —
+      there is no shared number for it to get wrong.
+    </Note>
+  </div>
+);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
index 34b0781..3ffd34b 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -59,7 +59,7 @@ const ARM = 32;
  * Enough after they arrive to see that they have arrived, and then round
  * again.
  */
-const ALONE_FOR = 260;
+export const ALONE_FOR = 260;
 const PAIR_FOR = 200;
 
 // And how long a lattice run gets, which is set by how much ball there is to
@@ -134,7 +134,7 @@ const ORBIT = 0.35 * LIGHT;
 const PAIR = 2 * (2 * 24) * ORBIT * ORBIT / GRAVITY;
 
 /** The same, on a list of sources that did not say. */
-const weighed = (sources: Source[]): Source[] =>
+export const weighed = (sources: Source[]): Source[] =>
   sources.map(s => ({ ...s, mass: s.mass ?? PAIR }));
 
 // The fly-by's own scale: `FLY` is far enough that light takes a good while
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
index ff10a9f..ddc6942 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
@@ -114,6 +114,12 @@ appears it is a measured input, not a result.
 | `tradeoff` | one ceiling, so the budget is shared: **magnetising a thing makes it lighter**. The cheap version is already dead — a kg bar would lose 10 mg — which puts a floor of 10¹⁴ under the magnetic coupling |
 | `maxwell` | **the audit** — 13 derived, 2 built in, 11 missing, 3 refuted, and why what is left missing is all on the electric side |
 
+### and the same theory without the XOR
+
+| | |
+|---|---|
+| `nopolarity` | **turn polarity off and gravity does not notice.** No signs, no opposites, meetings decided head-on instead. `G` doubles and cancels; the force law's shape, the metric, the perihelion, the deflection, `a₀`, the rotation curve and the cosmology are identical to every digit quoted. What is lost is magnetism entirely, and the *explanation* of the ½ in `G`. So the XOR is a tunable parameter, free on the gravitational side |
+
 ## what is still open
 
 Three things, all arithmetic rather than astronomy:
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts
index faf0e2a..4e16fb5 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts
@@ -173,7 +173,7 @@ const PRED: [string, string][] = [
   ["the Milky Way to 1.1% rms", "a₀ and the transport route"],
   ["the transport turnover", "n/n_c and flux — no sign"],
   ["blocking → the interpolation", "`through` = 1 − chance — no sign"],
-  ["the ⟨111⟩ / step anisotropy", "26 exits and three cosines — no sign"],
+  ["the step prediction, 33 & 52 kpc", "26 exits and three cosines — no sign"],
   ["the frontier cosmology, H₀ = 1/t₀", "counting the frontier — no sign"],
 ];
 for (const [p, why] of PRED) console.log(`      ${p.padEnd(36)} ${why}`);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
index c27dc45..4d4e140 100755
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
@@ -30,6 +30,7 @@ ORDER=(
   blocking redo shape quant steps joint
   recon which138 accum accumulate asym
   pulses magnets coulomb moment dipole poles ordering budget tradeoff scale maxwell
+  nopolarity
 )
 
 if [ "${1:-}" = "--list" ]; then printf '%s\n' "${ORDER[@]}"; exit 0; fi
diff --git a/orbitmines.com/src/routes/references.tsx b/orbitmines.com/src/routes/references.tsx
index 7e08da4..f56f63c 100644
--- a/orbitmines.com/src/routes/references.tsx
+++ b/orbitmines.com/src/routes/references.tsx
@@ -208,6 +208,36 @@ export const ETHERS_ALMANAC: Content & { UPDATES: Content[] } = { reference: {
 
 }
 
+/**
+ * The physics booklet, which is a book rather than a paper for the same reason
+ * the Almanac is one: it is several notes that are read together and updated
+ * separately, and a paper has no way to say that.
+ *
+ * `NOTES` are the numbered pieces inside it. They are references in their own
+ * right — each one is a thing that can be cited, linked and dated on its own —
+ * and the booklet is what they are collected in. The arcs in `Physics.tsx`
+ * carry the same three names in the same order, so a note and its arc are the
+ * same thing said in two places.
+ */
+export const PHYSICS: Content = { reference: {
+  title: "OrbitMines: Physics Project",
+  subtitle: "An initial look at a discrete Ray Calculus for physics: specifically for gravity and magnetism, and a continuous model based on ideas of that discrete setup.",
+  draft: true,
+  date: "Last update: 2026-12-31",
+  year: "2026",
+  external: {
+    discord: {serverId: '1055502602365845534', channelId: '1463219913044005018', link: () => "https://discord.com/channels/1055502602365845534/1463219913044005018/1463219913044005018"}
+  },
+  organizations: [ORGANIZATIONS.orbitmines_research],
+  authors: [{
+    ...PROFILES.fadi_shawki,
+    external: PROFILES.fadi_shawki.external?.filter((profile) => PLATFORMS.includes(profile.organization.key))
+  }],
+  published: [ORGANIZATIONS.orbitmines_research],
+  link: "https://orbitmines.com/physics"
+}, status: Viewed.VIEWED, found_at: "2026", viewed_at: "December, 2026",
+}
+
 export const RAY_CALCULI_AND_PHYSICS: Content = { reference: {
   title: "2026 Physics: Notes on an XOR Universe",
   subtitle: "An initial look at a discrete Ray Calculus for physics: specifically for gravity and electromagnetism, and a continuous model based on ideas of that discrete setup.",

From 07d24cbf27c17bf6788191030af8ebb4d6d1dec7 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Thu, 13 Aug 2026 02:01:57 +0200
Subject: [PATCH 33/47] Make a start to writing the article

---
 orbitmines.com/src/routes/Physics.tsx         |  369 ++-
 .../archive/2026.RayCalculiAndPhysics/law.tsx |   65 +-
 orbitmines.com/src/routes/archive/Physics.tsx | 1208 ----------
 .../src/routes/archive/Physics2.tsx           | 2090 -----------------
 4 files changed, 319 insertions(+), 3413 deletions(-)
 delete mode 100644 orbitmines.com/src/routes/archive/Physics.tsx
 delete mode 100644 orbitmines.com/src/routes/archive/Physics2.tsx

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index 743fc34..88d3293 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -1,11 +1,15 @@
 import Post, {
   Arc, BlueprintIcons16, BlueprintIcons20, BR, JetBrainsMono, PaperProps, Section,
   Title, renderable, useCounter,
+  Reference,
 } from "../lib/post/Post";
 import { PHYSICS } from "./references";
 
 import { bySide, Graph } from "./archive/2026.RayCalculiAndPhysics/discrete";
-import { Law, MagnetismLaw, WithoutPolarity } from "./archive/2026.RayCalculiAndPhysics/law";
+import {
+  Because, Eq, F, Frac, K, Law, MagnetismLaw, Paren, Step, Sup, V,
+  WithoutPolarity,
+} from "./archive/2026.RayCalculiAndPhysics/law";
 import { lineGroups } from "./archive/2026.RayCalculiAndPhysics/lines";
 import { Model } from "./archive/2026.RayCalculiAndPhysics/model";
 import { ALONE_FOR, asGroup, MODELS, weighed } from "./archive/2026.RayCalculiAndPhysics/models";
@@ -87,131 +91,302 @@ const Physics = () => {
       <BR/>
       Specifically, the idea would be the universe's tendency to exhibit XOR behavior on several scales. This is at least how I came to this idea. Two separate examples would be magnetism, and charged matter. In both cases: Opposites attract, Sameness repells. Hence my naming it XOR.
       <BR/>
-      The model is essentially this idea taken to an extreme. Let me introduce the discrete model first, which (for someone like me) is much easier to understand the *why* of the thing. In order to later introduce the continuous model.
+      The model is essentially this idea taken to an extreme. But it is important to note that the theory for gravity is (mostly) independent on that for magnetism, but later in the magnetism section, they will be equivalenced by means of XOR.
       <BR/>
-      These notes are in three parts, and they are in that order because the model is. <b>#1: Gravity</b> is the one that stands on its own — measured, with its scale unfitted. <b>#2: Magnetism</b> is the same emission counted a second way, and it owes one number. <b>#3: Electromagnetism</b> is not started, and says so.
-    
+      Let's get started with gravity.
 
       <Section head="Gravity">
-          <b>#1 of three.</b> This is the part that stands on its own. A meeting
-          between two charges takes a point of space out of the world, so the only
-          thing two bodies can do to each other is remove what is between them —
-          and that, counted, is the pull. What comes out of the counting is
-          Newton's law, the metric, Mercury's perihelion, light's deflection, and
-          a rotation curve fitted to 1.1% with nothing tuned.
-          <BR/>
-          Nothing on this arc uses a sign. Which is not a stylistic claim:{' '}
-          take the polarity out of the model entirely and every number below is
-          identical to every digit quoted — see the end of <b>#2</b>.
+        Gravity comes down to two essential rules:
+        <BR/>
+        (G/1) Annihilation: When two rays meet, they annihilate, leaving a single neutral spatial point behind.
+
+        <Models models={[DISCRETE[5]]}/>
+
+        (G/2) Creation: On all axis, a neutral point expands into two points with oppositely pointing rays.
+
+        <Models models={[BACKWARD[5]]}/>
+
+        Then the other permutations of the rules are just movement rules (like these two).
+
+        <Models models={[DISCRETE[3]]}/>
+
+        This is only to form a basis for the idea. In 2D/3D and when we want to recover magnetism these would of course get a little more complicated, but we can ignore that for now. 2D/3D is more easily understood as the continous model for starters. And this theory of gravity can be (mostly) understood separately from the theory of magnetism; later we'll unify them.
+        
+        <BR/>
+        
+        Instead: Based on these rules we can start extrapolating and start recovering existing ideas of gravity in physics, let's continue to the continuous model for that, and afterwards return to the discrete.
+
+        <BR/>
+
+        We build the continuous model, while keeping the discrete version in the back of our mind. Annihilation. Creation.
+
+        <BR/>
+
+        Since we're building on a lattice effectively then, there are some things we can and can't do. Before we dip into dive into the continuous we do need a little discreteness.
+
+        <BR/>
+
+        Let's first imagine something which travels at the speed of light. We can imagine that as something which travels every tick of the universe.
+        <BR/>
+        TODO
+        <BR/>
+        So whatever the maximum speed is any universe we can imagine, it is limited by this property. Something which travels every tick.
+
+        <BR/>
+
+        So since speed of light is 'c' in physics, we'll need some way to reference any kind of physics concept in its discrete form. Let's mark them by just putting a line on top of any variable when we want to reference its discrete form. (This will likely create some ambiguities - but at least in the context of this project that will be the case.)
+
+        <Eq>
+          <K>c̄</K> = <Frac over={<><K>S̅T̅E̅P̅</K> = 1</>} under={<><K>T̅I̅C̅K̅</K> = 1</>} /> =
+          1 <F>(x̅/t̅)</F>
+        </Eq>
+
+        These variables couldn't really be anything other than this, but this elementary thing is pretty important. Speed of light is just phrased as a single lattice step per tick. These don't need any units since we're not comparing them to anything else, but if one really wanted, you could use the x̅/t̅. x̅ meaning distance. t̅ meaning a light tick.
+
+        <BR/>
+
+        Next up we have dimensions, now the trouble with this, is that generally we could have a fraction in this number. So one would only be able to make a judgement on this number locally, or regionally. Instead these following variables will only be judged locally always (the current position). We denote that with a 'l.' in front of the variable. Unless otherwise mentioned the local variable has a default, which is the same variable name without the 'l.'.
+
+        <Eq>
+          <K>l.D̅</K> = number of dimensions
+          <span style={{ padding: '0 1.6em' }} />
+          <K>D̅</K> = 3
+        </Eq>
+
+        <span style={{textAlign: 'left', width: '100%'}}>You're allowed to change the <K>D̅</K> ofc. But unless otherwise specified variables have these default values.</span>
+
+        <BR/>
+
+        <span style={{textAlign: 'left', width: '100%'}}>There's one important piece of gravity that we'll discover and that is in order to reach the desired 1/R<Sup><K>D̅</K> - 1</Sup> of the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "inverse-square law", link: "https://en.wikipedia.org/wiki/Inverse-square_law"}}/>. It happens that as we'll discover in a moment, if we'd send out discrete pulses of our 'gravity-rays' (so the ones causing annihilation). That we can recover the intensity of gravity in a neat way based on the dimensionality of our space. This is our sheet. The sheet we pulse a beam towards. In order to cover our whole space, we'll be rotating this sheet in 1 more dimension than it's defined. Whenever there's a derived equation, you can click on it to see how it was derived! Try it!</span>
 
+        <Eq derive={{
+          label: 'l.S̅H̅E̅E̅T̅',
+          title: <>the sheet — what the inverse square asks for</>,
+          body: <>
+            <Because>(1) the thing we are trying to end up with</Because>
+            <Step eq={<>
+              intensity ∝
+              <Frac over={<>1</>}
+                under={<><V>r̅</V><Sup><K>l.D̅</K> - 1</Sup></>} />
+              <span style={{ padding: '0 1.2em', color: '#6c7080' }}>
+                = 1/<V>r̅</V><Sup>2</Sup> where <K>l.D̅</K> = 3
+              </span>
+            </>}>
+              This one is not derived — it is the target, the inverse-square law
+              we would like to come out of the lattice, written for however many
+              dimensions the place has. Everything below is what having it costs,
+              and the point of the exercise is that it costs exactly one thing
+              and leaves nothing over to tune.
+            </Step>
+
+            <Because>(2) what a falloff can even be here, since nothing pushes</Because>
+            <Step eq={<>
+              chance(<V>r̅</V>) =
+              <Frac over={<>what was let go of</>} under={<>shell(<V>r̅</V>)</>} />
+            </>}>
+              There is no force in the rules — only rays that step and meet. So
+              the only way something can weaken with distance is by being{' '}
+              <i>spread thinner</i>: a source lets go of some charges, they step
+              outward a cell a tick (that is <K>c̄</K>), and after <V>r̅</V>{' '}
+              ticks they are somewhere on the shell at <V>r̅</V>. None is made
+              and none is destroyed on the way, so what is on that shell is what
+              left, however far it has got. The chance a given cell out there is
+              holding one is that count over the size of the shell.
+            </Step>
+
+            <Because>(3) so the target is really a statement about what it spreads over</Because>
+            <Step eq={<>
+              shell(<V>r̅</V>) = 4<V>π</V> <V>r̅</V><Sup><K>l.D̅</K> - 1</Sup>
+              <span style={{ padding: '0 1.2em', color: '#6c7080' }}>
+                a surface: <K>l.D̅</K> - 1 dimensional
+              </span>
+            </>}>
+              Put (1) and (2) together and the demand is that a fixed count be
+              diluted by <V>r̅</V><Sup><K>l.D̅</K> - 1</Sup> — and a thing whose
+              size goes up by <V>r̅</V><Sup><V>n</V></Sup> when you scale it
+              by <V>r̅</V> is an <V>n</V> dimensional thing, because that is what
+              having a dimension <i>means</i>. So what the emission is spread
+              over has to be <K>l.D̅</K> - 1 dimensional: a surface, and the one
+              surrounding the source, or there are directions the pull never
+              reaches. In three dimensions that is 4π<V>r̅</V><Sup>2</Sup>.
+            </Step>
+
+            <Because>(4) and it has to get onto that surface by turning</Because>
+            <Step eq={<>
+              emitted + 1 <F>(the turn)</F> = <K>l.D̅</K>
+              <span style={{ padding: '0 1.2em' }} />
+              emitted = <K>l.D̅</K> - 1 = 2
+            </>}>
+              A source cannot pulse into a whole sphere at once — a pulse leaves
+              along lattice directions, and the sphere is not a set of them. It
+              can pulse into a <i>sheet</i> and turn, and one rotation carries
+              whatever it emits through exactly one more dimension than that
+              emission already has. Its sweep has to be the whole space, so what
+              is emitted is one dimension short of it: a sheet, two dimensional
+              in three dimensional space.
+            </Step>
+
+            <Because>(5) not more, not less — both alternatives fail, differently</Because>
+            <Step eq={<>
+              <K>l.D̅</K>: nothing left to turn
+              <span style={{ padding: '0 1.2em' }} />
+              <K>l.D̅</K> - 2: the sweep is a surface, not a space
+            </>}>
+              Emit into all of space — every way out of the point, which is the
+              full 3<Sup><K>l.D̅</K></Sup> - 1 = 26 — and there is no dimension
+              left for the turn to happen in; the sphere is covered by the pulse
+              itself and never gets thinner in the right way. Emit into a line
+              instead, two directions, and one turn sweeps a surface — a disc
+              through the source, with the rest of the space untouched. Only{' '}
+              <K>l.D̅</K> - 1 both covers the space and needs the turn.
+            </Step>
+
+            <Because>(6) so count the directions that lie in the sheet</Because>
+            <Step eq={<>
+              <K>l.S̅H̅E̅E̅T̅</K> = 3<Sup><K>l.D̅</K> - 1</Sup> - 1 = 8
+            </>}>
+              Along any one axis a ray can go down it, up it, or not along it —
+              three, and no more, because two steps in a tick is faster
+              than <K>c̄</K>. The axes do not constrain each other, so the
+              choices multiply: three of them over the <K>l.D̅</K> - 1 axes
+              lying in the sheet, less the one that is zero on all of them,
+              which is standing still and is not a direction to leave in. In
+              three dimensions that is the 3×3 around the point with its middle
+              taken out. <b>Eight. Not the 26, not the 2</b> — and every part of
+              it was forced: the 3 is a tick's worth of one axis, the exponent is
+              what the turn in (4) needs, the −1 is standing still.
+            </Step>
+
+            <Because>(7) and reading it back the way a pulse actually runs</Because>
+            <Step eq={<>
+              chance(<V>m</V>, <V>r̅</V>) =
+              <Frac over={<><V>m</V> · <K>l.S̅H̅E̅E̅T̅</K></>}
+                under={<>4<V>π</V> <V>r̅</V><Sup><K>l.D̅</K> - 1</Sup></>} />
+              &nbsp;=&nbsp;
+              <Frac over={<>8<V>m</V></>} under={<>4<V>π</V> <V>r̅</V><Sup>2</Sup></>} />
+            </>}>
+              Eight charges leave, the sheet they left in comes round as the
+              source turns so that over a revolution the space around it has all
+              been pulsed into, and those same eight are on the shell at{' '}
+              <V>r̅</V> a moment later. Eight over 4π<V>r̅</V><Sup>2</Sup>:{' '}
+              <b>the inverse square, back out</b>, which it had better be — this
+              step is the check, not the derivation.
+            </Step>
+
+            <Because>(8) what it cost, which is the reason for doing it this way</Because>
+            <Step>
+              <b>Nothing was fitted and nothing is left free.</b> The strength of
+              a source is not a constant anybody chose — it is eight, because
+              eight is what a sheet in three dimensions has in it, and a sheet is
+              what an inverse square asks for: <b>not the 26 and not the 2</b>.
+              The argument never mentioned three, so it runs the same in any{' '}
+              <K>l.D̅</K> — sheet one dimension short of the space, count{' '}
+              3<Sup><K>l.D̅</K> - 1</Sup> - 1, diluted over the surface
+              surrounding the source — and three is only where that comes out as
+              eight and an inverse <i>square</i>. And <K>l.D̅</K> is{' '}
+              <i>local</i>, which is what the l. is for: it is the dimension
+              where the pulsing is happening, not a number set once for the
+              universe.
+            </Step>
+          </>,
+        }}>
+          <K>l.S̅H̅E̅E̅T̅</K> = <>3<Sup><K>l.D̅</K> - 1</Sup> - 1</>
+        </Eq>
+
+        <Section head="The Continuous Model">
+
+        </Section>
         <Section head="The Discrete Model">
-          It comes down to three essential rules:
-          <BR/>
-          (1) Annihilation: When two opposite polarities meet, they annihilate, leaving a single neutral spatial point behind.
+        </Section>
+        <Section head="TODO">
+          <Law />
 
-          <Models models={[DISCRETE[5]]}/>
+          <Models models={MODELS} />
+        </Section>
+      </Section>
 
-          (2) Repulsion: When two identical polarities meet, they turn around.
+      <Section head="XOR: Gravity + Magnetism">
+        Instead of having our rays me neutral, we can introduce a polarity to them: positive/negative. When we do that gravity + magnetism comes down to three rules:
+        <BR/>
+        (G+M/1) Annihilation: When two opposite polarities meet, they annihilate, leaving a single neutral spatial point behind.
 
-          <Models models={[DISCRETE[4]]}/>
+        <Models models={[DISCRETE[5]]}/>
 
-          (3) Creation: A neutral point expands into two points with opposite polarity in all directions.
+        (G+M/2) Creation: On all axis, a neutral point expands into two points with opposite polarity in all directions.
 
-          <Models models={[BACKWARD[5]]}/>
+        <Models models={[BACKWARD[5]]}/>
 
-          Then the other permutations of the rules are just movement rules (like these two).
+        (G+M/3) Repulsion: When two identical polarities meet, they turn around.
 
-          <Models models={[DISCRETE[1]]}/>
+        <Models models={[DISCRETE[4]]}/>
 
-          With this setup, we get aggregate behavior of groups of the same polarities, turning away from each other.
+        Then the other permutations of the rules are just movement rules (like these two).
 
-          <Models models={([
-              [Polarity.Positive, Polarity.Positive],
-              [Polarity.Negative, Polarity.Negative],
-          ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
-            name: '',
-            note: '',
-            lattice: {
-              seed: () => Graph.blocks({ charge: bySide(left, right) }),
-              ticks: 15, height: 140, density: false,
-            },
-          }))}/>
+        <Models models={[DISCRETE[1]]}/>
 
-          And ones with opposite polarities annihilating each-other.
+        With this setup, we get aggregate behavior of groups of the same polarities, turning away from each other.
 
-          <Models models={([
-              [Polarity.Positive, Polarity.Negative],
-          ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
-            name: '',
-            note: '',
-            lattice: {
-              seed: () => Graph.blocks({ charge: bySide(left, right) }),
-              ticks: 5, height: 140, density: false,
-            },
-          }))}/>
+        <Models models={([
+            [Polarity.Positive, Polarity.Positive],
+            [Polarity.Negative, Polarity.Negative],
+        ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
+          name: '',
+          note: '',
+          lattice: {
+            seed: () => Graph.blocks({ charge: bySide(left, right) }),
+            ticks: 15, height: 140, density: false,
+          },
+        }))}/>
 
-          Then an interesting thing happens when you alternate polarities (the phase not mattering for this result). You get attraction.
+        And ones with opposite polarities annihilating each-other.
 
-          <Models models={([
+        <Models models={([
             [Polarity.Positive, Polarity.Negative],
-            [Polarity.Positive, Polarity.Positive],
-          ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
-            name: '',
-            note: '',
-            lattice: {
-              seed: () => Graph.emitters({ left, right, gap: 20, every: 1, spin: true }),
-              ticks: 22, height: 140,
-            },
-          }))}/>
-
-          In 2D/3D these would of course get a little more complicated, but we can ignore that for now, this is only to form a basis for the idea. Instead: Based on these rules we can start extrapolating, let's continue to the continuous model for that, and afterwards return to the discrete.
+        ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
+          name: '',
+          note: '',
+          lattice: {
+            seed: () => Graph.blocks({ charge: bySide(left, right) }),
+            ticks: 5, height: 140, density: false,
+          },
+        }))}/>
+
+        Then an interesting thing happens when you alternate polarities (the phase not mattering for this result). You get attraction. And we recover our two rules of gravity (G/1 + G/2) from these three rules.
+
+        <Models models={([
+          [Polarity.Positive, Polarity.Negative],
+          [Polarity.Positive, Polarity.Positive],
+        ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
+          name: '',
+          note: '',
+          lattice: {
+            seed: () => Graph.emitters({ left, right, gap: 20, every: 1, spin: true }),
+            ticks: 22, height: 140,
+          },
+        }))}/>
         
-              <Section head="The Continuous Model">
+        <Section head="XOR Continuous Model">
 
         </Section>
+        <Section head="XOR Discrete Model">
         </Section>
 
-        <Law />
+        <Section head="TODO2">
+          <Kinds />
+          <Lopsided />
+          <Fields />
+          <Pairs />
+          <BarField />
+          <Ceiling />
 
-        <Models models={MODELS} />
-      </Section>
+          <MagnetismLaw />
 
-      <Section head="Magnetism">
-          <b>#2 of three.</b> The same emission, counted a second way: with the
-          signs kept instead of thrown away. What falls out is magnetostatics —
-          the sign law, 3cos²θ − 1, the 1/R⁴ force, every orientation, no
-          monopoles — from the same integral that gave the pull, with nothing
-          added to it.
-          <BR/>
-          What it owes is a scale, and one number: the magnetic coupling.
-
-        <Kinds />
-        <Lopsided />
-        <Fields />
-        <Pairs />
-        <BarField />
-        <Ceiling />
-
-        <MagnetismLaw />
-
-        <WithoutPolarity />
+          <WithoutPolarity />
+        </Section>
       </Section>
       
       <Section head="Electromagnetism">
-          <b>#3 of three, and it is not started.</b> Kept as an arc rather than
-          left out, because what is missing is specific and worth stating: there
-          is no account of matter in this model, so nothing in it says what an
-          electron or a positron would be, and the bias that gives magnetism is
-          not electric charge — a proton settles that, carrying the same charge as
-          an electron while emitting 1836 times as often.
-          <BR/>
-          And there is a structural piece missing under all of it. Every force
-          here is second order in the emission: nothing happens to a charge that
-          does not <i>meet</i> another charge. Electromagnetism needs a charge to
-          be pushed by a field it merely passes through, and there is no such rule
-          yet. Gravity never needed one, which is why <b>#1</b> works — a shortage
-          of space is exactly the kind of thing that only happens where two things
-          meet.
+     
       </Section>
     </Arc>
     <Arc head={<span className="bp5-text-disabled">2027.</span>}>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index c5d7b21..1a359e9 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -57,30 +57,34 @@ const SERIF = 'Georgia, "Times New Roman", serif';
 // —— notation ————————————————————————————————————————————————————————————
 
 /** A quantity. Leans, as a variable should. */
-const V = ({ children }: { children: ReactNode }) => (
+export const V = ({ children }: { children: ReactNode }) => (
   <span style={{ fontStyle: 'italic' }}>{children}</span>
 );
 
 /** One of the lattice's own counts. Upright, and coloured. */
-const K = ({ children }: { children: ReactNode }) => (
+export const K = ({ children }: { children: ReactNode }) => (
   <span style={{ color: NAMED, fontStyle: 'normal' }}>{children}</span>
 );
 
+export const F = ({ children }: { children: ReactNode }) => (
+  <span style={{ color: FAINT, fontStyle: 'normal' }}>{children}</span>
+);
+
 /** A vector. Upright and bold, the way a vector is set. */
-const B = ({ children }: { children: ReactNode }) => (
+export const B = ({ children }: { children: ReactNode }) => (
   <span style={{ fontWeight: 700, fontStyle: 'normal' }}>{children}</span>
 );
 
-const Sub = ({ children }: { children: ReactNode }) => (
+export const Sub = ({ children }: { children: ReactNode }) => (
   <sub style={{ fontSize: '0.72em', fontStyle: 'italic' }}>{children}</sub>
 );
 
-const Sup = ({ children }: { children: ReactNode }) => (
+export const Sup = ({ children }: { children: ReactNode }) => (
   <sup style={{ fontSize: '0.72em' }}>{children}</sup>
 );
 
 /** A fraction, which is the only thing here that needs building. */
-const Frac = ({ over, under }: { over: ReactNode, under: ReactNode }) => (
+export const Frac = ({ over, under }: { over: ReactNode, under: ReactNode }) => (
   <span style={{
     display: 'inline-flex', flexDirection: 'column', alignItems: 'center',
     verticalAlign: 'middle', margin: '0 0.35em', lineHeight: 1.25,
@@ -102,7 +106,7 @@ const Frac = ({ over, under }: { over: ReactNode, under: ReactNode }) => (
  * along with its height, which is what a bigger bracket IS. Centred by flex so
  * it sits on the middle of whatever it contains, however tall that is.
  */
-const Paren = ({ children }: { children: ReactNode }) => (
+export const Paren = ({ children }: { children: ReactNode }) => (
   <span style={{ display: 'inline-flex', alignItems: 'center', verticalAlign: 'middle' }}>
     <span style={{ fontSize: '2.2em', lineHeight: 0.72, fontStyle: 'normal', fontWeight: 300 }}>(</span>
     <span style={{ padding: '0 0.12em' }}>{children}</span>
@@ -111,7 +115,7 @@ const Paren = ({ children }: { children: ReactNode }) => (
 );
 
 /** A hat, for a direction. */
-const Hat = ({ children }: { children: ReactNode }) => (
+export const Hat = ({ children }: { children: ReactNode }) => (
   <span style={{ position: 'relative', display: 'inline-block', fontStyle: 'italic' }}>
     <span style={{
       position: 'absolute', left: 0, right: 0, top: '-0.62em',
@@ -121,7 +125,7 @@ const Hat = ({ children }: { children: ReactNode }) => (
   </span>
 );
 
-const Note = ({ children }: { children: ReactNode }) => (
+export const Note = ({ children }: { children: ReactNode }) => (
   <div style={{ color: DIM, fontSize: '0.88em', lineHeight: 1.6, paddingTop: '0.5em' }}>
     {children}
   </div>
@@ -129,10 +133,10 @@ const Note = ({ children }: { children: ReactNode }) => (
 
 // —— the derivations, and the panel they open in —————————————————————————
 
-type Derivation = { title: ReactNode; label: string; body: ReactNode };
+export type Derivation = { title: ReactNode; label: string; body: ReactNode };
 
 /** A step of working: the line, then why. */
-const Step = ({ eq, children }: { eq?: ReactNode, children: ReactNode }) => (
+export const Step = ({ eq, children }: { eq?: ReactNode, children: ReactNode }) => (
   <div style={{ padding: '0 0 1.4em' }}>
     {eq ? <div style={{
       fontFamily: SERIF, fontSize: '1.05em', color: INK,
@@ -142,7 +146,7 @@ const Step = ({ eq, children }: { eq?: ReactNode, children: ReactNode }) => (
   </div>
 );
 
-const Because = ({ children }: { children: ReactNode }) => (
+export const Because = ({ children }: { children: ReactNode }) => (
   <div style={{
     color: FAINT, fontSize: '0.68em', letterSpacing: '0.09em',
     textTransform: 'uppercase', padding: '0.6em 0 0.5em',
@@ -157,7 +161,7 @@ const Because = ({ children }: { children: ReactNode }) => (
  * moves into it on open and back to whatever opened it on close, so a reader
  * who arrived by keyboard is not stranded at the top of the document.
  */
-const Panel = ({ of, onClose }: { of: Derivation, onClose: () => void }) => {
+export const Panel = ({ of, onClose }: { of: Derivation, onClose: () => void }) => {
   const panel = useRef<HTMLDivElement>(null);
 
   useEffect(() => {
@@ -234,11 +238,26 @@ const Panel = ({ of, onClose }: { of: Derivation, onClose: () => void }) => {
 /**
  * A displayed equation. Clickable when there is working behind it, and looking
  * clickable — a derived line and a stated one must not be the same object.
+ *
+ * IT CARRIES ITS OWN PANEL unless whoever placed it keeps one. `Law` is a page
+ * where everything opens, so it holds a single piece of state and passes
+ * `open`; a line standing in the prose of a book has nothing above it doing
+ * that, and cannot be given one from the top of the article either — a book
+ * renders the children of the SELECTED SECTION and nothing else, so a panel
+ * hung anywhere but beside its own equation is never rendered at all. Hence the
+ * state living here, which is the one place that is always in the tree when the
+ * equation a reader just clicked is.
+ *
+ * Only one is ever open: the panel's backdrop covers the viewport, so a click
+ * meant for a second equation closes the first instead.
  */
-const Eq = (
+export const Eq = (
   { children, note, derive, open }:
     { children: ReactNode, note?: ReactNode, derive?: Derivation, open?: (d: Derivation) => void },
 ) => {
+  const [shown, setShown] = useState(false);
+  const from = useRef<HTMLElement | null>(null);
+
   const inner = <>
     <div style={{
       overflowX: 'auto', textAlign: 'center', color: INK,
@@ -252,11 +271,16 @@ const Eq = (
     }}>{note}</div> : null}
   </>;
 
-  if (!derive || !open) return <div style={{ margin: '1.5em 0' }}>{inner}</div>;
+  if (!derive) return <div style={{ margin: '1.5em 0' }}>{inner}</div>;
 
-  return (
+  return (<>
     <button
-      onClick={() => open(derive)}
+      onClick={() => {
+        if (open) return open(derive);
+
+        from.current = document.activeElement as HTMLElement;
+        setShown(true);
+      }}
       style={{
         display: 'block', width: '100%', margin: '1.5em 0',
         background: 'none', border: '1px solid transparent', borderRadius: 3,
@@ -282,7 +306,12 @@ const Eq = (
         textTransform: 'uppercase', opacity: 0.75,
       }}>derived ›</span>
     </button>
-  );
+
+    {shown ? <Panel of={derive} onClose={() => {
+      setShown(false);
+      from.current?.focus();
+    }} /> : null}
+  </>);
 };
 
 const Head = ({ children }: { children: ReactNode }) => (
diff --git a/orbitmines.com/src/routes/archive/Physics.tsx b/orbitmines.com/src/routes/archive/Physics.tsx
deleted file mode 100644
index b7521e2..0000000
--- a/orbitmines.com/src/routes/archive/Physics.tsx
+++ /dev/null
@@ -1,1208 +0,0 @@
-import { useEffect, useRef, useState, useCallback } from "react";
-
-/* ---------------------------------------------------------------------
- * Core model — faithful port of Op / Boundary / Ray, plus a spatial
- * GridNode wrapper (position + velocity) so the abstract graph can be
- * laid out and drawn. Nothing here is React-specific.
- * ------------------------------------------------------------------- */
-
-const Op = { Repell: "Repell", Attract: "Attract", Neutral: "Neutral" };
-
-class Boundary {
-  constructor(at) {
-    this.op = Op.Neutral;
-    this.at = at;
-    this.target = null;
-  }
-  repell() {
-    /* like repels like — no structural change, just displacement */
-  }
-  attract() {
-    /* unused by the expanding-grid seed: no Attract boundaries exist yet */
-  }
-}
-
-class Ray {
-  constructor(direction) {
-    this.direction = direction; // unit vector this Ray's Repell boundary faces
-    this.boundaries = [new Boundary(this)];
-  }
-}
-
-class GridNode {
-  // node = Ray[] in the original model; this wraps that with spatial state
-  // so the same graph can be force-laid-out and rendered. gridPos is null
-  // for nodes that don't belong to the lattice (repell-spawned space
-  // markers) — those are driven entirely by the generic physics in
-  // step(), never by the deterministic gridPos×scaleFactor placement.
-  constructor(pos, isCenter, gridPos = pos) {
-    this.gridPos = gridPos ? gridPos.slice() : null;
-    this.pos = pos.slice();
-    this.vel = pos.map(() => 0);
-    this.isCenter = isCenter;
-    this.isPhoton = false;
-    this.weight = 1; // accumulates when this node consumes another
-    this.rays = [];
-  }
-  get repelCount() {
-    let n = 0;
-    for (const ray of this.rays) {
-      for (const b of ray.boundaries) if (b.op === Op.Repell) n++;
-    }
-    return n;
-  }
-  hasOp(op) {
-    return this.rays.some((ray) => ray.boundaries[0].op === op);
-  }
-}
-
-// A ray's direction is one of the grid's own cardinal axes (±x, ±y, ±z —
-// exactly what a mesh-neighbor direction actually is), not an arbitrary
-// continuous direction. This is what makes tryConsume's alignment check
-// meaningful (dot product lands at exactly 1 when a ray really does point
-// at an occupied neighbor slot) and what makes rays render along the same
-// grid lines the mesh edges use, instead of at odd, unrelated angles.
-function randomDir(d) {
-  const axis = Math.floor(Math.random() * d);
-  const sign = Math.random() < 0.5 ? -1 : 1;
-  const v = new Array(d).fill(0);
-  v[axis] = sign;
-  return v;
-}
-
-// 40% Repell / 30% Attract / 30% Neutral — enough Repell to keep the
-// expansion-frontier glow visible, enough Attract density that adjacent
-// cells occasionally line up for an Attract ray to consume its neighbor.
-function randomOp() {
-  const r = Math.random();
-  if (r < 0.4) return Op.Repell;
-  if (r < 0.7) return Op.Attract;
-  return Op.Neutral;
-}
-
-// The axis-aligned direction that points toward center along whichever
-// coordinate is largest in magnitude — the one that actually put this
-// cell at its current ring distance. Used as the boundary's guaranteed
-// inward Repell ray (see below) rather than leaving it to random chance.
-function primaryInwardDir(gridPos, d) {
-  let axis = 0, maxAbs = -1;
-  for (let i = 0; i < d; i++) {
-    const a = Math.abs(gridPos[i]);
-    if (a > maxAbs) {
-      maxAbs = a;
-      axis = i;
-    }
-  }
-  const dir = new Array(d).fill(0);
-  dir[axis] = gridPos[axis] > 0 ? -1 : 1;
-  return dir;
-}
-
-/**
- * Universe.nD_Expanding — seeds a (2·1+1)^d grid (3×3 for d=2, 3×3×3 for d=3).
- * Every non-center cell gets two rays, both pointing inward (toward
- * center along whichever axis is largest — see primaryInwardDir): that
- * direction is deterministic, defining the cell's structural place in
- * the lattice. Each ray's op (Repell/Attract/Neutral) is independently
- * random. The grid's own structure carries the ops directly — there is
- * no separate node holding them. The center cell gets a single Repell
- * ray with no direction — it's the seed the rest of the grid expands
- * from.
- */
-function nD_Expanding(d, size = 3) {
-  const center = Math.floor(size / 2);
-  const coords = [];
-  (function build(prefix) {
-    if (prefix.length === d) {
-      coords.push(prefix);
-      return;
-    }
-    for (let i = 0; i < size; i++) build([...prefix, i]);
-  })([]);
-
-  const nodes = coords.map((idx) => {
-    const c = idx.map((v) => v - center);
-    const isCenter = c.every((v) => v === 0);
-    const node = new GridNode(c, isCenter);
-
-    if (isCenter) {
-      const seed = new Ray(c.map(() => 0));
-      seed.boundaries[0].op = Op.Repell;
-      node.rays.push(seed);
-    } else {
-      // Direction is deterministic (inward, defining this cell's place in
-      // the lattice); op is random. The grid's own structure carries the
-      // ops directly — there's no separate node holding them.
-      const inward = primaryInwardDir(c, d);
-      for (let k = 0; k < 2; k++) {
-        const ray = new Ray(inward.slice());
-        ray.boundaries[0].op = randomOp();
-        node.rays.push(ray);
-      }
-    }
-    return node;
-  });
-
-  const keyOf = (c) => c.join(",");
-  const byKey = new Map(nodes.map((n) => [keyOf(n.pos), n]));
-
-  // Boundary.target: both of a cell's Repell boundaries target the same
-  // inward neighbor (one step closer to center) — "superposed ... targeting
-  // inward". This is the semantic op-graph the Ray/Boundary model actually
-  // acts on, kept separate from the mesh below.
-  for (const n of nodes) {
-    if (n.isCenter) continue;
-    const parentPos = n.pos.map((v) => v - Math.sign(v));
-    const parent = byKey.get(keyOf(parentPos));
-    if (parent) {
-      for (const ray of n.rays) ray.boundaries[0].target = parent.rays[0].boundaries[0];
-    }
-  }
-
-  // Rendering/layout mesh: full orthogonal grid adjacency — every cell to
-  // its lattice neighbors — so what's on screen reads as an actual grid
-  // (squares in 2D, a cube lattice in 3D) rather than spokes to the center.
-  const edges = [];
-  for (let i = 0; i < nodes.length; i++) {
-    for (let j = i + 1; j < nodes.length; j++) {
-      const a = nodes[i], b = nodes[j];
-      const manhattan = a.pos.reduce((s, v, k) => s + Math.abs(v - b.pos[k]), 0);
-      if (manhattan === 1) edges.push([a, b]);
-    }
-  }
-
-  const initialMaxR = Math.max(...nodes.map((n) => Math.hypot(...n.pos)), 1e-6);
-  const byGridKey = new Map(nodes.map((n) => [keyOf(n.pos), n]));
-  return { nodes, edges, tick: 0, initialMaxR, ringRadius: 1, scaleFactor: 1, freeCount: 0, freeQueue: [], nextGlobalTick: 0, globalTickId: 0, gridNodeCount: nodes.length, byGridKey };
-}
-
-/**
- * growShell — adds the next outer shell of the lattice (every cell at
- * Chebyshev distance ringRadius+1 from center). Each new cell gets two
- * rays, both pointing inward (see primaryInwardDir) — the deterministic
- * structure that defines the grid's shape. Each ray's op is independently
- * random (Repell/Attract/Neutral) — the grid's own structure carries the
- * ops directly, there's no separate node holding them. Spawn position is
- * exact (gridPos × current scaleFactor), so cells land in place
- * immediately.
- */
-// Creates one grid cell at gridPos if that position isn't already
-// occupied — no-op (returns null) otherwise. Shared by growShell's
-// systematic ring-filling and by Repell-triggered spawning below, so
-// both use the exact same cell structure and the exact same dedupe
-// check: whichever gets there first wins, the other is just a no-op.
-function createGridCell(sim, gridPos, d) {
-  const keyOf = (c) => c.join(",");
-  const byGridKey = sim.byGridKey;
-  const key = keyOf(gridPos);
-  if (byGridKey.has(key)) return null;
-
-  const parentGridPos = gridPos.map((v) => v - Math.sign(v));
-  const parent = byGridKey.get(keyOf(parentGridPos));
-
-  const node = new GridNode(gridPos, false);
-  // Position is fully deterministic — no Math.random() anywhere in this
-  // calculation. Seeded from the parent's actual current position (found
-  // via gridPos adjacency, but using the parent's real physics-driven
-  // position, not a gridPos*scale formula) plus a tiny, deterministic
-  // offset along this cell's own inward direction (same value every run
-  // for the same graph state) — just enough to avoid two siblings
-  // landing at the exact same coordinate, which would leave repulsion's
-  // force direction undefined between them. The weak spring on the edge
-  // below, plus repulsion, is what actually determines where this node
-  // ends up — the seed position is only a deterministic starting point.
-  const seedDir = primaryInwardDir(gridPos, d).map((v) => -v);
-  const anchor = parent || sim.nodes[0];
-  node.pos = anchor.pos.map((v, k) => v + seedDir[k] * 0.01);
-
-  // Direction is deterministic (inward); op is random. The grid's own
-  // structure carries the ops directly — no separate node holds them.
-  const inward = primaryInwardDir(gridPos, d);
-  for (let k = 0; k < 2; k++) {
-    const ray = new Ray(inward.slice());
-    ray.boundaries[0].op = randomOp();
-    node.rays.push(ray);
-  }
-
-  if (parent && parent.rays[0]) {
-    for (const ray of node.rays) ray.boundaries[0].target = parent.rays[0].boundaries[0];
-  }
-
-  byGridKey.set(key, node);
-  for (let axis = 0; axis < d; axis++) {
-    for (const step of [-1, 1]) {
-      const np = gridPos.slice();
-      np[axis] += step;
-      const neighbor = byGridKey.get(keyOf(np));
-      if (neighbor) sim.edges.push([node, neighbor]);
-    }
-  }
-
-  sim.nodes.push(node);
-  sim.gridNodeCount = (sim.gridNodeCount || 0) + 1;
-  const ring = Math.max(...gridPos.map((v) => Math.abs(v)));
-  if (ring > sim.ringRadius) sim.ringRadius = ring;
-
-  return node;
-}
-
-function growShell(sim, d) {
-  const newR = sim.ringRadius + 1;
-  const newGridCoords = [];
-  (function build(prefix) {
-    if (prefix.length === d) {
-      const maxAbs = Math.max(...prefix.map((v) => Math.abs(v)));
-      if (maxAbs === newR) newGridCoords.push(prefix);
-      return;
-    }
-    for (let i = -newR; i <= newR; i++) build([...prefix, i]);
-  })([]);
-
-  // Spawn position is exact, not estimated: gridPos × the current global
-  // scale factor — that's what createGridCell uses. Nodes with a gridPos
-  // skip the generic force-directed physics entirely (see step()) and
-  // are driven purely by this scale factor, so they can't drift,
-  // overlap, or destabilize regardless of grid size.
-  for (const gridPos of newGridCoords) createGridCell(sim, gridPos, d);
-
-  sim._forces = null; // resize physics buffers next step()
-  sweep(sim);
-}
-
-/**
- * Reaction mechanics — the literal reading of repel/attract as space
- * creation/destruction: a Repell ray periodically sprouts a new node
- * ahead of itself (on a cooldown, so it's an ongoing trickle rather than
- * a one-time burst or a permanent exhaustion). An Attract ray, aimed
- * close enough at an actual neighbor, consumes it — the graph
- * restructures rather than anything going flying: the target is removed
- * and its other connections are inherited by the attacker, which is what
- * accumulates weight over time. When the attacker and target are BOTH
- * "matter" (an Attract ray and a Repell ray each), the encounter is an
- * annihilation instead: both are replaced by two photons. Two photons
- * that end up structurally connected pair-produce back into matter. None
- * of this uses velocity or movement — it's all graph restructuring, so
- * it can't reintroduce nodes "flying" anywhere.
- */
-function markDead(sim, node) {
-  node._dead = true;
-  sim._anyDead = true;
-  if (node.gridPos) sim.gridNodeCount = Math.max((sim.gridNodeCount || 0) - 1, 0);
-  else sim.freeCount = Math.max((sim.freeCount || 0) - 1, 0);
-}
-
-function sweep(sim) {
-  if (!sim._anyDead) return;
-  sim.nodes = sim.nodes.filter((n) => !n._dead);
-  sim.edges = sim.edges.filter(([a, b]) => !a._dead && !b._dead);
-  if (sim.byGridKey) {
-    for (const [k, v] of sim.byGridKey) {
-      if (v._dead) sim.byGridKey.delete(k);
-    }
-  }
-  sim._anyDead = false;
-  sim._forces = null;
-}
-
-// Rewires target's OTHER edges (not the one to `keep`) onto `keep`,
-// skipping anything already connected or dead. Shared by consume and
-// annihilation — both replace a node but want its structure inherited.
-function rewireOnto(sim, keep, from) {
-  const keepNeighbors = new Set();
-  for (const [ea, eb] of sim.edges) {
-    if (ea === keep) keepNeighbors.add(eb);
-    else if (eb === keep) keepNeighbors.add(ea);
-  }
-  for (const [ea, eb] of sim.edges) {
-    let other = null;
-    if (ea === from && eb !== keep) other = eb;
-    else if (eb === from && ea !== keep) other = ea;
-    if (other && !other._dead && other !== keep && !keepNeighbors.has(other)) {
-      sim.edges.push([keep, other, true]);
-      keepNeighbors.add(other);
-    }
-  }
-}
-
-// Rolling window: instead of ever blocking creation once the free-node
-// budget is full, retire the oldest free node to make room first. Repel
-// (and photon/pair-production) creation should never be stoppable — a
-// hard cap that refuses new creation contradicts that, however generous
-// the number. This keeps total count bounded through turnover instead.
-function makeRoomForFreeNode(sim) {
-  while ((sim.freeCount || 0) >= FREE_NODE_CAP && sim.freeQueue.length) {
-    const oldest = sim.freeQueue.shift();
-    if (!oldest._dead) markDead(sim, oldest);
-  }
-}
-
-function spawnPhoton(sim, pos, dir) {
-  makeRoomForFreeNode(sim);
-  const node = new GridNode(pos, false, null);
-  node.isPhoton = true;
-  const ray = new Ray(dir.slice());
-  ray.boundaries[0].op = Op.Neutral;
-  node.rays.push(ray);
-  sim.nodes.push(node);
-  sim.freeQueue.push(node);
-  sim.freeCount = (sim.freeCount || 0) + 1;
-  return node;
-}
-
-function spawnMatter(sim, pos, dir, reversed) {
-  makeRoomForFreeNode(sim);
-  const node = new GridNode(pos, false, null);
-  const front = new Ray(dir.slice());
-  const back = new Ray(dir.map((v) => -v));
-  if (!reversed) {
-    front.boundaries[0].op = Op.Attract;
-    back.boundaries[0].op = Op.Repell;
-  } else {
-    front.boundaries[0].op = Op.Repell;
-    back.boundaries[0].op = Op.Attract;
-  }
-  node.rays.push(front, back);
-  sim.nodes.push(node);
-  sim.freeQueue.push(node);
-  sim.freeCount = (sim.freeCount || 0) + 1;
-  return node;
-}
-
-function isMatter(node) {
-  return node.hasOp(Op.Attract) && node.hasOp(Op.Repell);
-}
-
-// Both nodes are "matter" and aligned — annihilate into two photons
-// instead of a normal one-sided consume. Each photon inherits one side's
-// other connections and points away from the collision, back-to-back —
-// direction only, no velocity. Frontier nodes are exempt, same reasoning
-// as tryConsume.
-function isOnFrontier(sim, node) {
-  return node.gridPos && Math.max(...node.gridPos.map((v) => Math.abs(v))) === sim.ringRadius;
-}
-
-function tryAnnihilate(sim, a, b) {
-  if (a._dead || b._dead || a.isCenter || b.isCenter) return false;
-  if (a.isPhoton || b.isPhoton) return false;
-  if (isOnFrontier(sim, a) || isOnFrontier(sim, b)) return false;
-  if (!isMatter(a) || !isMatter(b)) return false;
-
-  const diff = a.pos.map((v, k) => v - b.pos[k]);
-  const len = Math.hypot(...diff) || 1e-6;
-  const dir = diff.map((v) => v / len);
-
-  const aligned = (n1, n2, d) =>
-    n1.rays.some((ray) => ray.boundaries[0].op === Op.Attract && ray.direction.reduce((s, v, k) => s + v * d[k], 0) > 0.75);
-  const negDir = dir.map((v) => -v);
-  if (!aligned(a, b, negDir) && !aligned(b, a, dir)) return false;
-
-  const mid = a.pos.map((v, k) => (v + b.pos[k]) / 2);
-  const p1 = spawnPhoton(sim, mid, dir);
-  const p2 = spawnPhoton(sim, mid, negDir);
-  rewireOnto(sim, p1, a);
-  rewireOnto(sim, p2, b);
-  markDead(sim, a);
-  markDead(sim, b);
-  return true;
-}
-
-// Two photons sharing an edge pair-produce back into matter, moving in
-// the reverse of their incoming directions — mirrors annihilation.
-function tryPairProduce(sim, a, b) {
-  if (a._dead || b._dead) return false;
-  if (!a.isPhoton || !b.isPhoton) return false;
-
-  const mid = a.pos.map((v, k) => (v + b.pos[k]) / 2);
-  const dirA = a.rays[0].direction.map((v) => -v);
-  const dirB = b.rays[0].direction.map((v) => -v);
-  const m1 = spawnMatter(sim, mid, dirA, false);
-  const m2 = spawnMatter(sim, mid, dirB, true);
-  rewireOnto(sim, m1, a);
-  rewireOnto(sim, m2, b);
-  markDead(sim, a);
-  markDead(sim, b);
-  return true;
-}
-
-// An Attract ray consumes whichever actual neighbor it's aimed closely
-// enough at (dot product of ray direction vs. direction-to-neighbor).
-// The target is removed, but its other edges are rewired onto the
-// attacker — if A/2 points at B/5 and B also has rays 4 and 6 connecting
-// it elsewhere, once B is consumed, 4 and 6 now connect to A instead of
-// dangling or vanishing. Weight transfers along with the structure. The
-// active frontier (the current outermost ring) is exempt — it's freshly
-// spawned and would otherwise get eaten before it ever gets a chance to
-// repel outward itself. It becomes a normal consumption target once a
-// newer shell grows past it.
-function tryConsume(sim, attacker, target) {
-  if (attacker._dead || target._dead || target.isCenter) return false;
-  if (attacker.isPhoton || target.isPhoton) return false;
-  if (isOnFrontier(sim, target)) return false;
-  const diff = target.pos.map((v, k) => v - attacker.pos[k]);
-  const len = Math.hypot(...diff) || 1e-6;
-  const dir = diff.map((v) => v / len);
-  for (const ray of attacker.rays) {
-    if (ray.boundaries[0].op !== Op.Attract) continue;
-    if (ray._lastConsumeTick === sim.globalTickId) continue; // already acted this tick
-    const dot = ray.direction.reduce((s, v, k) => s + v * dir[k], 0);
-    if (dot <= 0.75) continue;
-
-    rewireOnto(sim, attacker, target);
-    attacker.weight += target.weight;
-    ray._lastConsumeTick = sim.globalTickId;
-    markDead(sim, target);
-    return true;
-  }
-  return false;
-}
-
-/* ---------------------------------------------------------------------
- * Generic force-directed physics — this is what makes the renderer work
- * for "any arbitrary graph": mutual repulsion keeps nodes from
- * overlapping, spring edges keep connected nodes near each other. Repell
- * boundaries add one extra force on top: a push away from the origin,
- * scaled by how many Repell boundaries a node carries — which is the
- * literal mechanism of the expansion.
- * ------------------------------------------------------------------- */
-
-const SPRING_K = 0.05; // almost nothing — just enough to keep connected pairs from drifting apart forever, not to hold any shape
-const REWIRED_SPRING_K = 4.0; // strong — a consumption-driven connection is real graph structure and should actually pull
-const REST_LEN = 1.0;
-const EXPANSION_K = 0.85;
-const DAMPING = 0.8;
-const EXPANSION_RATE = 0.18; // exponential growth rate for gridPos-node scaling
-const MAX_NODES = 10000;
-const FREE_NODE_CAP = 4000; // separate budget for repel/photon-spawned nodes, independent of grid growth
-const GLOBAL_TICK_INTERVAL = 0.9; // seconds between synchronized whole-graph repel/attract updates
-
-function step(sim, dt, dim) {
-  const { nodes, edges } = sim;
-  const n = nodes.length;
-  const dims = nodes[0].pos.length;
-
-  // Deterministic scale factor for anything with a gridPos — exact
-  // self-similar growth (v ∝ r, applied exactly rather than integrated),
-  // so it can't drift, overlap, or destabilize no matter how large the
-  // grid gets. This replaces relying on the force-directed physics below
-  // to determine overall grid scale; that physics remains fully intact
-  // and generic for future non-grid nodes (graph rewrites).
-  sim.scaleFactor *= Math.exp(EXPANSION_RATE * dt);
-  const scale = sim.scaleFactor;
-
-  if (!sim._forces || sim._forces.length !== n) {
-    sim._forces = new Array(n);
-    for (let i = 0; i < n; i++) sim._forces[i] = new Array(dims).fill(0);
-  }
-  const forces = sim._forces;
-  for (let i = 0; i < n; i++) for (let k = 0; k < dims; k++) forces[i][k] = 0;
-
-  if (!sim._index) sim._index = new Map();
-  const index = sim._index;
-  index.clear();
-  for (let i = 0; i < n; i++) index.set(nodes[i], i);
-
-  const delta = new Array(dims);
-
-  // Generic force-directed physics — springs from every edge, including
-  // ones consumption has rewired into long-range connections. Rest length
-  // tracks the current scale factor rather than a fixed constant: grid
-  // spacing itself grows exponentially (scaleFactor), so a fixed rest
-  // length would leave springs permanently fighting to compress a graph
-  // that expansion is simultaneously stretching apart — that fight is
-  // what physics couldn't keep pace with. With rest length tracking
-  // scale, springs and expansion agree on target spacing, and spacing
-  // emerges from the springs themselves rather than needing any position
-  // reset, hard or soft.
-  const restLen = REST_LEN * scale;
-  for (const edge of edges) {
-    const a = edge[0], b = edge[1];
-    const k_spring = edge[2] ? REWIRED_SPRING_K : SPRING_K;
-    const i = index.get(a), j = index.get(b);
-    let distSq = 0;
-    for (let k = 0; k < dims; k++) {
-      delta[k] = b.pos[k] - a.pos[k];
-      distSq += delta[k] * delta[k];
-    }
-    const dist = Math.sqrt(distSq) || 1e-4;
-    const f = (k_spring * (dist - restLen)) / dist;
-    for (let k = 0; k < dims; k++) {
-      const fk = delta[k] * f;
-      forces[i][k] += fk;
-      forces[j][k] -= fk;
-    }
-  }
-
-  const dimBoost = dims === 3 ? 1.5 : 1;
-  for (let i = 0; i < n; i++) {
-    const node = nodes[i];
-    if (node.isCenter || node.gridPos) continue;
-    const f = node.repelCount * EXPANSION_K * dimBoost;
-    for (let k = 0; k < dims; k++) forces[i][k] += node.pos[k] * f;
-  }
-
-  // Spatial repulsion between NEARBY nodes, independent of whether
-  // they're connected by an edge at all. Springs only respond to graph
-  // topology — a region with no rewired edges (like the fully
-  // consumption-immune frontier) has nothing else pulling it away from
-  // the shape its mesh topology implies, no matter how the springs
-  // themselves are tuned. This is what gives every node genuine
-  // positional freedom. Hash-bucketed so cost stays roughly O(n) instead
-  // of O(n²): each node only checks nearby buckets, not the whole graph.
-  //
-  // This pairwise scan was measured at ~88% of total frame time once
-  // population reached a couple thousand nodes — by far the dominant
-  // cost. It's recomputed only every OTHER frame now; each node caches
-  // its own repulsion contribution (a property on the node itself, so
-  // it survives sweep() removing dead nodes and shifting indices) and
-  // that cached value is reused untouched on the skipped frame.
-  // Repulsion is a soft, continuous force, not collision detection — one
-  // frame of staleness is physically safe and visually imperceptible,
-  // and this roughly halves its effective cost.
-  const REPEL_RADIUS = restLen * 3;
-  const REPEL_RADIUS_SQ = REPEL_RADIUS * REPEL_RADIUS;
-  const REPULSION_K = 1.3;
-  const bucketSize = REPEL_RADIUS;
-
-  sim._repulseFrameCounter = (sim._repulseFrameCounter || 0) + 1;
-  const recomputeRepulsion = sim._repulseFrameCounter % 2 === 1;
-
-  if (recomputeRepulsion) {
-    if (!sim._neighborOffsets || sim._neighborOffsetsDims !== dims) {
-      const offsets = [];
-      (function buildOffsets(prefix) {
-        if (prefix.length === dims) {
-          offsets.push(prefix.slice());
-          return;
-        }
-        for (const s of [-1, 0, 1]) buildOffsets([...prefix, s]);
-      })([]);
-      sim._neighborOffsets = offsets;
-      sim._neighborOffsetsDims = dims;
-    }
-    // Numeric integer hash instead of array.map+join string keys — avoids
-    // allocating an array and a string for every node on every frame.
-    const P1 = 73856093, P2 = 19349663, P3 = 83492791;
-    const cellCoord = new Array(dims);
-    function hashCell(c) {
-      let h = 0;
-      if (dims > 0) h ^= (c[0] | 0) * P1;
-      if (dims > 1) h ^= (c[1] | 0) * P2;
-      if (dims > 2) h ^= (c[2] | 0) * P3;
-      return h;
-    }
-    const buckets = new Map();
-    for (let i = 0; i < n; i++) {
-      const p = nodes[i].pos;
-      for (let k = 0; k < dims; k++) cellCoord[k] = Math.floor(p[k] / bucketSize);
-      const key = hashCell(cellCoord);
-      let arr = buckets.get(key);
-      if (!arr) buckets.set(key, (arr = []));
-      arr.push(i);
-    }
-    for (let i = 0; i < n; i++) {
-      const node = nodes[i];
-      if (!node._repulseForce || node._repulseForce.length !== dims) node._repulseForce = new Array(dims).fill(0);
-    }
-    for (let i = 0; i < n; i++) for (let k = 0; k < dims; k++) nodes[i]._repulseForce[k] = 0;
-    for (let i = 0; i < n; i++) {
-      const node = nodes[i];
-      for (let k = 0; k < dims; k++) cellCoord[k] = Math.floor(node.pos[k] / bucketSize);
-      for (const offset of sim._neighborOffsets) {
-        for (let k = 0; k < dims; k++) cellCoord[k] += offset[k];
-        const key = hashCell(cellCoord);
-        for (let k = 0; k < dims; k++) cellCoord[k] -= offset[k]; // restore for next offset
-        const bucketNodes = buckets.get(key);
-        if (!bucketNodes) continue;
-        for (const j of bucketNodes) {
-          if (j <= i) continue; // each pair considered exactly once
-          const other = nodes[j];
-          let distSq2 = 0;
-          for (let k = 0; k < dims; k++) {
-            delta[k] = other.pos[k] - node.pos[k];
-            distSq2 += delta[k] * delta[k];
-          }
-          if (distSq2 >= REPEL_RADIUS_SQ) continue; // cheap reject before the sqrt below
-          const d2 = Math.sqrt(distSq2) || 1e-4;
-          const f2 = (REPULSION_K * (REPEL_RADIUS - d2)) / d2;
-          for (let k = 0; k < dims; k++) {
-            const fk = delta[k] * f2;
-            node._repulseForce[k] -= fk;
-            other._repulseForce[k] += fk;
-          }
-        }
-      }
-    }
-  }
-
-  for (let i = 0; i < n; i++) {
-    const node = nodes[i];
-    if (!node._repulseForce) continue; // just created this frame on a skip-frame; gets a fresh value next recompute
-    for (let k = 0; k < dims; k++) forces[i][k] += node._repulseForce[k];
-  }
-
-  const MAX_FORCE = 400;
-  const MAX_VEL = 150;
-
-  for (let i = 0; i < n; i++) {
-    const node = nodes[i];
-
-    if (node.isCenter) {
-      for (let k = 0; k < dims; k++) node.vel[k] = 0;
-      continue;
-    }
-
-    let fMagSq = 0;
-    for (let k = 0; k < dims; k++) fMagSq += forces[i][k] * forces[i][k];
-    if (fMagSq > MAX_FORCE * MAX_FORCE) {
-      const s = MAX_FORCE / Math.sqrt(fMagSq);
-      for (let k = 0; k < dims; k++) forces[i][k] *= s;
-    }
-
-    let vMagSq = 0;
-    for (let k = 0; k < dims; k++) {
-      node.vel[k] = (node.vel[k] + forces[i][k] * dt) * DAMPING;
-      vMagSq += node.vel[k] * node.vel[k];
-    }
-    if (vMagSq > MAX_VEL * MAX_VEL) {
-      const s = MAX_VEL / Math.sqrt(vMagSq);
-      for (let k = 0; k < dims; k++) node.vel[k] *= s;
-    }
-
-    for (let k = 0; k < dims; k++) {
-      node.pos[k] += node.vel[k] * dt;
-      if (!Number.isFinite(node.pos[k])) node.pos[k] = 0;
-    }
-  }
-
-  // One synchronized global tick governs everything: grid growth (one new
-  // ring — 3×3 → 5×5 → 7×7, exactly one ring per tick) and every
-  // Repell/Attract boundary in the graph, together. Not independent
-  // timers. On each tick the whole graph is scanned: every un-consumed
-  // edge is checked for annihilation/pair-production/consumption, and
-  // every Repell ray fires. Repell is never spent and never individually
-  // throttled — a boundary keeps expanding on every single global tick,
-  // unconditionally.
-  if (sim.tick >= (sim.nextGlobalTick || 0)) {
-    sim.nextGlobalTick = sim.tick + GLOBAL_TICK_INTERVAL;
-    sim.globalTickId = (sim.globalTickId || 0) + 1;
-
-    // Snapshot the edge count first — rewireOnto (inside tryConsume/
-    // tryAnnihilate) pushes new edges onto this exact array. Iterating a
-    // live, growing array meant a newly-rewired edge got immediately
-    // reprocessed by this same loop, which could trigger further
-    // consumption on a different node's still-unspent ray, pushing more
-    // edges, reprocessed again — an unbounded same-tick cascade once it
-    // reached a high-weight, high-degree node. Newly-rewired edges now
-    // get their first chance on the NEXT tick instead, same as growShell.
-    const edgeCountAtTickStart = edges.length;
-    for (let ei = 0; ei < edgeCountAtTickStart; ei++) {
-      const [a, b] = edges[ei];
-      if (a._dead || b._dead) continue;
-      if (a.isPhoton && b.isPhoton) {
-        tryPairProduce(sim, a, b);
-        continue;
-      }
-      if (a.isPhoton || b.isPhoton) continue;
-      if (tryAnnihilate(sim, a, b)) continue;
-      tryConsume(sim, a, b);
-      tryConsume(sim, b, a);
-    }
-
-    // Repell-triggered spawning: any grid cell with a Repell-op ray tries
-    // to create a new cell one step further outward, using the exact
-    // same mechanism growShell uses (createGridCell). Most of these
-    // no-op — the target position is already filled by growShell's own
-    // systematic growth — except right at the frontier (genuinely empty)
-    // or over a gap left by consumption (regrows it). That self-limits
-    // the real work to roughly the frontier's surface area without
-    // needing an explicit frontier check. Bounded by n (the tick-start
-    // node count) so newly-created cells this tick aren't immediately
-    // rescanned — same reasoning as the edge-scan snapshot above.
-    if ((sim.gridNodeCount || 0) < MAX_NODES) {
-      for (let i = 0; i < n; i++) {
-        const cell = nodes[i];
-        if (cell._dead || cell.isCenter || !cell.gridPos) continue;
-        for (const ray of cell.rays) {
-          if (ray.boundaries[0].op !== Op.Repell) continue;
-          const outward = ray.direction.map((v) => -v);
-          const targetPos = cell.gridPos.map((v, k) => v + (outward[k] || 0));
-          createGridCell(sim, targetPos, dim);
-        }
-      }
-    }
-
-    if ((sim.gridNodeCount || 0) < MAX_NODES) growShell(sim, dim);
-  }
-  sweep(sim);
-}
-
-/* ---------------------------------------------------------------------
- * Projection + drawing
- * ------------------------------------------------------------------- */
-
-function project(pos, dim, rot, tilt, camDist) {
-  const x = pos[0] || 0, y = pos[1] || 0, z = pos[2] || 0;
-  if (dim === 2) return { x, y, depth: 1, clipped: false };
-  const cosR = Math.cos(rot), sinR = Math.sin(rot);
-  const x1 = x * cosR - z * sinR;
-  const z1 = x * sinR + z * cosR;
-  const cosT = Math.cos(tilt), sinT = Math.sin(tilt);
-  const y1 = y * cosT - z1 * sinT;
-  const z2 = y * sinT + z1 * cosT;
-  // True perspective: camera sits at distance camDist from the origin
-  // along the view axis. Points nearer the camera than that (denom small
-  // or negative) are behind/at the lens and get clipped. Convergence
-  // toward a vanishing point is now the CORRECT result of an actual
-  // camera, not a bug — it's what "moving the camera closer" means.
-  const denom = z2 + camDist;
-  if (denom < camDist * 0.02) return { x: 0, y: 0, depth: 0, clipped: true };
-  const persp = camDist / denom;
-  return { x: x1 * persp, y: y1 * persp, depth: Math.min(Math.max(persp, 0.15), 6), clipped: false };
-}
-
-function draw(ctx, canvas, sim, dim, cam, dt) {
-  const w = canvas.clientWidth, h = canvas.clientHeight;
-
-  ctx.fillStyle = "#06070c";
-  ctx.fillRect(0, 0, w, h);
-  const vg = ctx.createRadialGradient(w / 2, h / 2, 0, w / 2, h / 2, Math.max(w, h) / 1.05);
-  vg.addColorStop(0, "rgba(20,22,34,0)");
-  vg.addColorStop(1, "rgba(0,0,0,0.55)");
-  ctx.fillStyle = vg;
-  ctx.fillRect(0, 0, w, h);
-
-  if (!sim) return;
-
-  // Raw world extent (unprojected) — this is what the base pixel scale
-  // tracks, deliberately independent of camera distance/perspective, so
-  // there's no feedback loop between "how far the camera has dollied" and
-  // "how much of the grid fits on screen". A real camera doesn't refit
-  // its FOV to guarantee everything stays visible as it moves closer.
-  let worldExtent = 1e-6;
-  for (const n of sim.nodes) {
-    const r = Math.hypot(...n.pos);
-    if (r > worldExtent) worldExtent = r;
-  }
-
-  // Scale/distance are always exactly proportional to the grid's current
-  // size — recomputed directly every frame, not smoothed toward a target.
-  // That matters for two reasons: (1) no lerp means nothing ever "chases"
-  // a moving target, which is what read as unwanted drift; (2) being
-  // exactly proportional means the camera can never fall behind the
-  // grid's exponential physical growth, which a genuinely fixed distance
-  // eventually does — that falling-behind is what looked like runaway
-  // automatic zoom-in with no way to scroll back out. The user's zoom
-  // level (scaleMult / distMult) is a stable multiplier riding on top,
-  // changed only by scroll — never reset or overridden automatically.
-  if (dim === 3) {
-    cam.dist = worldExtent * (cam.distMult || 1.5);
-    cam.scale = (Math.min(w, h) * 0.38) / worldExtent;
-  } else {
-    cam.scale = ((Math.min(w, h) * 0.38) / worldExtent) * (cam.scaleMult || 1);
-  }
-
-  // Cursor-anchored pan only applies in 2D — there's no camera distance to
-  // dolly there, so screen-space zoom-toward-cursor is the natural
-  // control. In 3D the camera orbits/dollies toward the origin, which is
-  // the standard convention for an orbit camera.
-  const panX = dim === 2 && cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
-  const panY = dim === 2 && cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
-  const cx = w / 2 + panX, cy = h / 2 + panY;
-
-  const projected = new Map();
-  for (const n of sim.nodes) {
-    projected.set(n, project(n.pos, dim, cam.rot, cam.tilt, cam.dist || 1));
-  }
-
-  const pts = new Map();
-  for (const [n, p] of projected) {
-    pts.set(n, { x: cx + p.x * cam.scale, y: cy + p.y * cam.scale, depth: p.depth, clipped: p.clipped });
-  }
-
-  // Viewport culling: skip the detailed rendering work (ray projection,
-  // shadowBlur, stroke/fill calls) for anything clearly off-screen. Once
-  // zoomed into part of a large structure, most of the population isn't
-  // actually visible — this is what stops paying for it anyway. Margin
-  // is generous (a couple of scale-units of screen space) so a node just
-  // outside the canvas edge doesn't have its still-visible ray tip
-  // prematurely clipped.
-  const cullMargin = cam.scale * 2;
-  const onScreen = (p) => p.x > -cullMargin && p.x < w + cullMargin && p.y > -cullMargin && p.y < h + cullMargin;
-
-  for (const [n, parent] of sim.edges) {
-    const a = pts.get(n), b = pts.get(parent);
-    if (a.clipped || b.clipped) continue;
-    if (!onScreen(a) && !onScreen(b)) continue;
-    const w = Math.max(n.weight, parent.weight);
-    if (w > 1) {
-      const boost = Math.min(w - 1, 6);
-      ctx.strokeStyle = `rgba(199,175,255,${Math.min(0.16 + boost * 0.1, 0.7)})`;
-      ctx.lineWidth = 1 + boost * 0.35;
-    } else {
-      ctx.strokeStyle = "rgba(120,130,160,0.16)";
-      ctx.lineWidth = 1;
-    }
-    ctx.beginPath();
-    ctx.moveTo(a.x, a.y);
-    ctx.lineTo(b.x, b.y);
-    ctx.stroke();
-  }
-
-  for (const n of sim.nodes) {
-    const p = pts.get(n);
-    if (p.clipped) continue;
-    if (!onScreen(p)) continue;
-    const depth = dim === 3 ? Math.min(Math.max(p.depth, 0.4), 1.6) : 1;
-
-    if (n.isCenter) {
-      const r = Math.min(Math.max(cam.scale * 0.16 * depth, 0.8), 26);
-      const g = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3);
-      g.addColorStop(0, "rgba(255,217,168,0.9)");
-      g.addColorStop(1, "rgba(255,217,168,0)");
-      ctx.fillStyle = g;
-      ctx.beginPath();
-      ctx.arc(p.x, p.y, r * 3, 0, Math.PI * 2);
-      ctx.fill();
-      ctx.fillStyle = "#FFE9CE";
-      ctx.beginPath();
-      ctx.arc(p.x, p.y, r, 0, Math.PI * 2);
-      ctx.fill();
-      continue;
-    }
-
-    if (n.isPhoton) {
-      const dir = n.rays[0].direction;
-      const tipPos = n.pos.map((v, k) => v + (dir[k] || 0) * 0.5);
-      const tip = project(tipPos, dim, cam.rot, cam.tilt, cam.dist || 1);
-      const tx = cx + tip.x * cam.scale, ty = cy + tip.y * cam.scale;
-      const rayLen = Math.hypot(tx - p.x, ty - p.y);
-      if (!tip.clipped && Number.isFinite(tx) && Number.isFinite(ty) && rayLen < cam.scale * 6) {
-        ctx.strokeStyle = "#FFE9A8";
-        ctx.lineWidth = 2 * depth;
-        ctx.shadowColor = "#FFE9A8";
-        ctx.shadowBlur = Math.min(Math.max(cam.scale * 0.06, 2), 16);
-        ctx.beginPath();
-        ctx.moveTo(p.x, p.y);
-        ctx.lineTo(tx, ty);
-        ctx.stroke();
-        ctx.shadowBlur = 0;
-      }
-      ctx.fillStyle = "#FFF6DC";
-      ctx.beginPath();
-      ctx.arc(p.x, p.y, Math.min(Math.max(cam.scale * 0.07 * depth, 0.6), 11), 0, Math.PI * 2);
-      ctx.fill();
-      continue;
-    }
-
-    // Draw each ray colored by its own op — Repell (amber) vs Attract
-    // (cyan) vs Neutral (not drawn). A node with both an Attract and a
-    // Repell ray gets a bright core, since it can both consume neighbors
-    // and sprout new structure.
-    let hasAttract = false, hasRepell = false;
-    for (const ray of n.rays) {
-      const op = ray.boundaries[0].op;
-      if (op === Op.Attract) hasAttract = true;
-      if (op === Op.Repell) hasRepell = true;
-      if (op === Op.Neutral) continue;
-
-      const dir = op === Op.Repell ? ray.direction.map((v) => -v) : ray.direction;
-      const tipPos = n.pos.map((v, k) => v + (dir[k] || 0) * 0.45);
-      const tip = project(tipPos, dim, cam.rot, cam.tilt, cam.dist || 1);
-      const tx = cx + tip.x * cam.scale, ty = cy + tip.y * cam.scale;
-      const rayLen = Math.hypot(tx - p.x, ty - p.y);
-      // The tip point sits farther from origin than the node itself, so
-      // under true perspective it can cross the near-clip plane (or blow
-      // up near it) even when the node doesn't — skip degenerate tips
-      // rather than draw a stray line to screen-center.
-      if (!(!tip.clipped && Number.isFinite(tx) && Number.isFinite(ty) && rayLen < cam.scale * 6)) continue;
-
-      // A Repell ray on an interior (non-frontier) cell still exists — it
-      // just stopped being "the active boundary". Rendered dim rather
-      // than hidden, so a node's true op composition (e.g. an attractor
-      // that also has a repell ray) is never visually lied about; only
-      // the frontier gets the bright glow.
-      const onFrontierNow = n.gridPos ? isOnFrontier(sim, n) : true;
-      const dim_ = op === Op.Repell && !onFrontierNow;
-      const color = op === Op.Repell ? "#FF7A45" : "#3DDCFF";
-      ctx.strokeStyle = dim_ ? "rgba(255,122,69,0.35)" : color;
-      ctx.lineWidth = (dim_ ? 1 : 1.6) * depth;
-      if (!dim_) {
-        ctx.shadowColor = color;
-        ctx.shadowBlur = Math.min(Math.max(cam.scale * 0.045, 1), 9);
-      }
-      ctx.beginPath();
-      ctx.moveTo(p.x, p.y);
-      ctx.lineTo(tx, ty);
-      ctx.stroke();
-      ctx.shadowBlur = 0;
-    }
-
-    const isMatter = hasAttract && hasRepell;
-    const weightBoost = 1 + Math.min(n.weight - 1, 6) * 0.12;
-    ctx.fillStyle = isMatter ? "#EDEFF5" : "#5A5F72";
-    ctx.beginPath();
-    ctx.arc(p.x, p.y, Math.min(Math.max(cam.scale * (isMatter ? 0.075 : 0.05) * depth * weightBoost, 0.5), 16), 0, Math.PI * 2);
-    ctx.fill();
-  }
-}
-
-/* ---------------------------------------------------------------------
- * Component
- * ------------------------------------------------------------------- */
-
-export default function ExpandingUniverse() {
-  const canvasRef = useRef(null);
-  const simRef = useRef(null);
-  const camRef = useRef({ scale: 44, rot: 0, tilt: 0.6155, anchor: null, dist: null, distMult: 1.5, scaleMult: 1 });
-  const lastReadoutRef = useRef(0);
-
-  const [dim, setDim] = useState(2);
-  const [running, setRunning] = useState(true);
-  const [readout, setReadout] = useState({ tick: "0.0", factor: "1.00", nodes: 0, gridNodes: 0, ring: 1 });
-
-  const reset = useCallback((d) => {
-    simRef.current = nD_Expanding(d, 3);
-    camRef.current.rot = d === 3 ? Math.PI / 4 : 0;
-    camRef.current.tilt = 0.6155;
-    camRef.current.anchor = null;
-    camRef.current.distMult = 1.5;
-    camRef.current.scaleMult = 1;
-  }, []);
-
-  useEffect(() => {
-    reset(dim);
-  }, [dim, reset]);
-
-  useEffect(() => {
-    const canvas = canvasRef.current;
-    const ctx = canvas.getContext("2d");
-    let raf;
-    let last = performance.now();
-
-    function resize() {
-      const parent = canvas.parentElement;
-      const w = parent.clientWidth, h = parent.clientHeight;
-      const ratio = window.devicePixelRatio || 1;
-      canvas.width = w * ratio;
-      canvas.height = h * ratio;
-      canvas.style.width = w + "px";
-      canvas.style.height = h + "px";
-      ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
-    }
-    resize();
-    window.addEventListener("resize", resize);
-
-    // Scroll to zoom. 2D: cursor-anchored zoom (screen-space, no depth to
-    // navigate) — modifies cam.scaleMult. 3D: real dolly — scrolling
-    // moves the camera closer/farther along the view axis, driving
-    // genuine perspective rather than a flat scale.
-    function onWheel(e) {
-      e.preventDefault();
-      const factor = Math.exp(-e.deltaY * 0.001);
-      const cam = camRef.current;
-
-      if (dim === 3) {
-        cam.distMult = Math.min(Math.max((cam.distMult || 1.5) / factor, 0.01), 200);
-        return;
-      }
-
-      const rect = canvas.getBoundingClientRect();
-      const rx = e.clientX - rect.left - rect.width / 2;
-      const ry = e.clientY - rect.top - rect.height / 2;
-      const curPanX = cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
-      const curPanY = cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
-      cam.anchor = {
-        worldX: (rx - curPanX) / cam.scale,
-        worldY: (ry - curPanY) / cam.scale,
-        screenX: rx,
-        screenY: ry,
-      };
-      cam.scaleMult = Math.min(Math.max((cam.scaleMult || 1) * factor, 1e-4), 1e4);
-    }
-    canvas.addEventListener("wheel", onWheel, { passive: false });
-
-    // Right-click drag to orbit (3D) — horizontal drag rotates, vertical
-    // drag adjusts tilt. Suppress the browser context menu so right-click
-    // is free to use as a drag button.
-    function onContextMenu(e) {
-      e.preventDefault();
-    }
-    canvas.addEventListener("contextmenu", onContextMenu);
-
-    let dragging = false;
-    let lastX = 0, lastY = 0;
-    function onMouseDown(e) {
-      if (e.button !== 2) return;
-      dragging = true;
-      lastX = e.clientX;
-      lastY = e.clientY;
-    }
-    function onMouseMove(e) {
-      if (!dragging) return;
-      const dx = e.clientX - lastX, dy = e.clientY - lastY;
-      lastX = e.clientX;
-      lastY = e.clientY;
-      const cam = camRef.current;
-      cam.rot += dx * 0.006;
-      cam.tilt = Math.min(Math.max(cam.tilt + dy * 0.006, -1.15), 1.15);
-    }
-    function onMouseUp(e) {
-      if (e.button === 2) dragging = false;
-    }
-    canvas.addEventListener("mousedown", onMouseDown);
-    window.addEventListener("mousemove", onMouseMove);
-    window.addEventListener("mouseup", onMouseUp);
-
-    function frame(now) {
-      const dt = Math.min((now - last) / 1000, 0.05);
-      last = now;
-      const sim = simRef.current;
-
-      if (sim && running) {
-        step(sim, dt * 1.3, dim);
-        sim.tick += dt;
-      }
-      draw(ctx, canvas, sim, dim, camRef.current, dt);
-
-      if (sim && now - lastReadoutRef.current > 200) {
-        lastReadoutRef.current = now;
-        setReadout({
-          tick: sim.tick.toFixed(1),
-          factor: sim.scaleFactor.toFixed(2),
-          nodes: sim.nodes.length,
-          gridNodes: sim.gridNodeCount || 0,
-          ring: sim.ringRadius,
-        });
-      }
-      raf = requestAnimationFrame(frame);
-    }
-    raf = requestAnimationFrame(frame);
-
-    return () => {
-      cancelAnimationFrame(raf);
-      window.removeEventListener("resize", resize);
-      canvas.removeEventListener("wheel", onWheel);
-      canvas.removeEventListener("contextmenu", onContextMenu);
-      canvas.removeEventListener("mousedown", onMouseDown);
-      window.removeEventListener("mousemove", onMouseMove);
-      window.removeEventListener("mouseup", onMouseUp);
-    };
-  }, [dim, running]);
-
-  const pillStyle = (active) => ({
-    padding: "6px 14px",
-    borderRadius: 999,
-    fontSize: 12,
-    letterSpacing: 0.5,
-    fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-    border: `1px solid ${active ? "#FF7A45" : "rgba(255,255,255,0.15)"}`,
-    background: active ? "rgba(255,122,69,0.14)" : "rgba(255,255,255,0.03)",
-    color: active ? "#FFD9A8" : "#9BA0B3",
-    cursor: "pointer",
-  });
-
-  return (
-    <div
-      style={{
-        position: "relative",
-        width: "100%",
-        height: "100%",
-        minHeight: 560,
-        background: "#06070c",
-        borderRadius: 16,
-        overflow: "hidden",
-        fontFamily: "Inter, system-ui, sans-serif",
-      }}
-    >
-      <div style={{ position: "absolute", inset: 0 }}>
-        <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%", cursor: "grab" }} />
-      </div>
-
-      <div style={{ position: "absolute", top: 16, left: 16, display: "flex", gap: 8 }}>
-        {[2, 3].map((d) => (
-          <button key={d} onClick={() => setDim(d)} style={pillStyle(dim === d)}>
-            {d}D
-          </button>
-        ))}
-        <button onClick={() => reset(dim)} style={pillStyle(false)}>
-          reset
-        </button>
-        <button onClick={() => setRunning((r) => !r)} style={pillStyle(false)}>
-          {running ? "pause" : "resume"}
-        </button>
-        <span
-          style={{
-            alignSelf: "center",
-            fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-            fontSize: 10,
-            color: "#4A4E5A",
-            marginLeft: 4,
-          }}
-        >
-          scroll to zoom · right-drag to orbit
-        </span>
-      </div>
-
-      <div
-        style={{
-          position: "absolute",
-          top: 16,
-          right: 16,
-          display: "flex",
-          gap: 12,
-          alignItems: "center",
-          fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-          fontSize: 10,
-          color: "#5A5F72",
-        }}
-      >
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FF7A45", boxShadow: "0 0 6px #FF7A45" }} />
-          repell
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#3DDCFF", boxShadow: "0 0 6px #3DDCFF" }} />
-          attract
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#EDEFF5", boxShadow: "0 0 6px #EDEFF5" }} />
-          matter
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#5A5F72" }} />
-          spark
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FFE9A8", boxShadow: "0 0 10px #FFE9A8" }} />
-          photon
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FFE9CE", boxShadow: "0 0 10px #FFE9CE" }} />
-          seed
-        </span>
-      </div>
-
-      <div
-        style={{
-          position: "absolute",
-          bottom: 14,
-          right: 16,
-          textAlign: "right",
-          fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-          fontSize: 11,
-          color: "#7B8093",
-          lineHeight: 1.7,
-        }}
-      >
-        <div>t = {readout.tick}</div>
-        <div>a(t) = {readout.factor}</div>
-        <div>
-          grid = {readout.gridNodes} · total = {readout.nodes} · ring = {readout.ring}
-        </div>
-        <div style={{ color: "#4A4E5A" }}>
-          random repell/attract/neutral per ray · matter annihilates → photons → pair-produces back
-        </div>
-      </div>
-    </div>
-  );
-}
\ No newline at end of file
diff --git a/orbitmines.com/src/routes/archive/Physics2.tsx b/orbitmines.com/src/routes/archive/Physics2.tsx
deleted file mode 100644
index 3a372bb..0000000
--- a/orbitmines.com/src/routes/archive/Physics2.tsx
+++ /dev/null
@@ -1,2090 +0,0 @@
-import { useEffect, useRef, useState, useCallback } from "react";
-
-/* ---------------------------------------------------------------------
- * Core model — faithful port of Op / Boundary / Ray, plus a spatial
- * GridNode wrapper (position + velocity) so the abstract graph can be
- * laid out and drawn. Nothing here is React-specific.
- * ------------------------------------------------------------------- */
-
-const Op = { Repell: "Repell", Attract: "Attract", Neutral: "Neutral" };
-
-class Boundary {
-  constructor(at) {
-    this.op = Op.Neutral;
-    this.at = at;
-    this.target = null;
-  }
-  repell() {
-    /* like repels like — no structural change, just displacement */
-  }
-  attract() {
-    /* unused by the expanding-grid seed: no Attract boundaries exist yet */
-  }
-}
-
-class Ray {
-  constructor(direction) {
-    this.direction = direction; // unit vector this Ray's Repell boundary faces
-    this.boundaries = [new Boundary(this)];
-  }
-}
-
-class GridNode {
-  // node = Ray[] in the original model; this wraps that with spatial state
-  // so the same graph can be force-laid-out and rendered. gridPos is null
-  // for nodes that don't belong to the lattice (repell-spawned space
-  // markers) — those are driven entirely by the generic physics in
-  // step(), never by the deterministic gridPos×scaleFactor placement.
-  constructor(pos, isCenter, gridPos = pos) {
-    this.gridPos = gridPos ? gridPos.slice() : null;
-    this.pos = pos.slice();
-    this.vel = pos.map(() => 0);
-    this.isCenter = isCenter;
-    this.isPhoton = false;
-    this.weight = 1; // accumulates when this node consumes another
-    this.rays = [];
-  }
-  get repelCount() {
-    let n = 0;
-    for (const ray of this.rays) {
-      for (const b of ray.boundaries) if (b.op === Op.Repell) n++;
-    }
-    return n;
-  }
-  hasOp(op) {
-    return this.rays.some((ray) => ray.boundaries[0].op === op);
-  }
-}
-
-// A ray's direction is one of the grid's own cardinal axes (±x, ±y, ±z —
-// exactly what a mesh-neighbor direction actually is), not an arbitrary
-// continuous direction. This is what makes tryConsume's alignment check
-// meaningful (dot product lands at exactly 1 when a ray really does point
-// at an occupied neighbor slot) and what makes rays render along the same
-// grid lines the mesh edges use, instead of at odd, unrelated angles.
-function randomDir(d) {
-  const axis = Math.floor(Math.random() * d);
-  const sign = Math.random() < 0.5 ? -1 : 1;
-  const v = new Array(d).fill(0);
-  v[axis] = sign;
-  return v;
-}
-
-// 40% Repell / 30% Attract / 30% Neutral — enough Repell to keep the
-// expansion-frontier glow visible, enough Attract density that adjacent
-// cells occasionally line up for an Attract ray to consume its neighbor.
-function randomOp() {
-  const r = Math.random();
-  if (r < 0.4) return Op.Repell;
-  if (r < 0.7) return Op.Attract;
-  return Op.Neutral;
-}
-
-// The axis-aligned direction that points toward center along whichever
-// coordinate is largest in magnitude — the one that actually put this
-// cell at its current ring distance. Used as the boundary's guaranteed
-// inward Repell ray (see below) rather than leaving it to random chance.
-function primaryInwardDir(gridPos, d) {
-  let axis = 0, maxAbs = -1;
-  for (let i = 0; i < d; i++) {
-    const a = Math.abs(gridPos[i]);
-    if (a > maxAbs) {
-      maxAbs = a;
-      axis = i;
-    }
-  }
-  const dir = new Array(d).fill(0);
-  dir[axis] = gridPos[axis] > 0 ? -1 : 1;
-  return dir;
-}
-
-// Where this cell belongs in the approximate-3D shell, given its gridPos
-// and the current scale factor: project onto gridPos's own direction,
-// but scale by the Chebyshev ring number rather than gridPos's own
-// Euclidean length — a corner cell like (3,3) and an edge-midpoint cell
-// like (3,0) are the same ring, but (3,3) has Euclidean length √18≈4.24
-// while (3,0) has exactly 3; this pulls corners in to match, which is
-// what makes the whole population a sphere/circle instead of a
-// square/cube. Shared by the seed position at creation and the ongoing
-// anchor force in step() — same formula, same target, so a newly-spawned
-// cell starts exactly where it's headed rather than lagging behind it.
-function sphereTargetPos(gridPos, scale) {
-  const ring = Math.max(...gridPos.map((v) => Math.abs(v)));
-  const euclideanLen = Math.hypot(...gridPos) || 1;
-  const targetR = ring * scale;
-  return gridPos.map((v) => (v / euclideanLen) * targetR);
-}
-
-/**
- * Universe.nD_Expanding — seeds a (2·1+1)^d grid (3×3 for d=2, 3×3×3 for d=3).
- * Every non-center cell gets two rays, both pointing inward (toward
- * center along whichever axis is largest — see primaryInwardDir): that
- * direction is deterministic, defining the cell's structural place in
- * the lattice. Each ray's op (Repell/Attract/Neutral) is independently
- * random. The grid's own structure carries the ops directly — there is
- * no separate node holding them. The center cell gets a single Repell
- * ray with no direction — it's the seed the rest of the grid expands
- * from.
- */
-function nD_Expanding(d, size = 3) {
-  const center = Math.floor(size / 2);
-  const coords = [];
-  (function build(prefix) {
-    if (prefix.length === d) {
-      coords.push(prefix);
-      return;
-    }
-    for (let i = 0; i < size; i++) build([...prefix, i]);
-  })([]);
-
-  const nodes = coords.map((idx) => {
-    const c = idx.map((v) => v - center);
-    const isCenter = c.every((v) => v === 0);
-    const node = new GridNode(c, isCenter);
-
-    if (isCenter) {
-      const seed = new Ray(c.map(() => 0));
-      seed.boundaries[0].op = Op.Repell;
-      node.rays.push(seed);
-    } else {
-      // Direction is deterministic (inward, defining this cell's place in
-      // the lattice); op is random. The grid's own structure carries the
-      // ops directly — there's no separate node holding them.
-      const inward = primaryInwardDir(c, d);
-      for (let k = 0; k < 2; k++) {
-        const ray = new Ray(inward.slice());
-        ray.boundaries[0].op = randomOp();
-        node.rays.push(ray);
-      }
-    }
-    return node;
-  });
-
-  const keyOf = (c) => c.join(",");
-  const byKey = new Map(nodes.map((n) => [keyOf(n.pos), n]));
-
-  // Boundary.target: both of a cell's Repell boundaries target the same
-  // inward neighbor (one step closer to center) — "superposed ... targeting
-  // inward". This is the semantic op-graph the Ray/Boundary model actually
-  // acts on, kept separate from the mesh below.
-  for (const n of nodes) {
-    if (n.isCenter) continue;
-    const parentPos = n.pos.map((v) => v - Math.sign(v));
-    const parent = byKey.get(keyOf(parentPos));
-    if (parent) {
-      for (const ray of n.rays) ray.boundaries[0].target = parent.rays[0].boundaries[0];
-    }
-  }
-
-  // Rendering/layout mesh: full orthogonal grid adjacency — every cell to
-  // its lattice neighbors — so what's on screen reads as an actual grid
-  // (squares in 2D, a cube lattice in 3D) rather than spokes to the center.
-  const edges = [];
-  for (let i = 0; i < nodes.length; i++) {
-    for (let j = i + 1; j < nodes.length; j++) {
-      const a = nodes[i], b = nodes[j];
-      const manhattan = a.pos.reduce((s, v, k) => s + Math.abs(v - b.pos[k]), 0);
-      if (manhattan === 1) edges.push([a, b]);
-    }
-  }
-
-  const initialMaxR = Math.max(...nodes.map((n) => Math.hypot(...n.pos)), 1e-6);
-  const byGridKey = new Map(nodes.map((n) => [keyOf(n.pos), n]));
-  return { nodes, edges, tick: 0, initialMaxR, ringRadius: 1, scaleFactor: 1, freeCount: 0, freeQueue: [], nextGlobalTick: 0, globalTickId: 0, gridNodeCount: nodes.length, byGridKey };
-}
-
-/**
- * growShell — adds the next outer shell of the lattice (every cell at
- * Chebyshev distance ringRadius+1 from center). Each new cell gets two
- * rays, both pointing inward (see primaryInwardDir) — the deterministic
- * structure that defines the grid's shape. Each ray's op is independently
- * random (Repell/Attract/Neutral) — the grid's own structure carries the
- * ops directly, there's no separate node holding them. Spawn position is
- * exact (gridPos × current scaleFactor), so cells land in place
- * immediately.
- */
-// Creates one grid cell at gridPos if that position isn't already
-// occupied — no-op (returns null) otherwise. Shared by growShell's
-// systematic ring-filling and by Repell-triggered spawning below, so
-// both use the exact same cell structure and the exact same dedupe
-// check: whichever gets there first wins, the other is just a no-op.
-function createGridCell(sim, gridPos, d) {
-  const keyOf = (c) => c.join(",");
-  const byGridKey = sim.byGridKey;
-  const key = keyOf(gridPos);
-  if (byGridKey.has(key)) return null;
-
-  const parentGridPos = gridPos.map((v) => v - Math.sign(v));
-  const parent = byGridKey.get(keyOf(parentGridPos));
-
-  const node = new GridNode(gridPos, false);
-  // Seeded directly at the sphere-projected target position (see
-  // sphereTargetPos) — the same formula the ongoing anchor force in
-  // step() pulls toward. Previously this seeded near the parent's
-  // current position and relied on the anchor force to pull it out to
-  // its proper ring distance over several frames, which is what made
-  // freshly-spawned cells visibly cluster near center before migrating
-  // outward. Now it starts where 3D space says it belongs; a tiny
-  // deterministic offset (this cell's own inward direction) avoids two
-  // siblings landing at the exact same coordinate.
-  const seedDir = primaryInwardDir(gridPos, d).map((v) => -v);
-  const target = sphereTargetPos(gridPos, sim.scaleFactor);
-  node.pos = target.map((v, k) => v + seedDir[k] * 0.01);
-
-  // Direction is deterministic (inward); op is random. The grid's own
-  // structure carries the ops directly — no separate node holds them.
-  const inward = primaryInwardDir(gridPos, d);
-  for (let k = 0; k < 2; k++) {
-    const ray = new Ray(inward.slice());
-    ray.boundaries[0].op = randomOp();
-    node.rays.push(ray);
-  }
-
-  if (parent && parent.rays[0]) {
-    for (const ray of node.rays) ray.boundaries[0].target = parent.rays[0].boundaries[0];
-  }
-
-  byGridKey.set(key, node);
-  for (let axis = 0; axis < d; axis++) {
-    for (const step of [-1, 1]) {
-      const np = gridPos.slice();
-      np[axis] += step;
-      const neighbor = byGridKey.get(keyOf(np));
-      if (neighbor) sim.edges.push([node, neighbor]);
-    }
-  }
-
-  sim.nodes.push(node);
-  sim.gridNodeCount = (sim.gridNodeCount || 0) + 1;
-  const ring = Math.max(...gridPos.map((v) => Math.abs(v)));
-  if (ring > sim.ringRadius) sim.ringRadius = ring;
-
-  return node;
-}
-
-function growShell(sim, d) {
-  const newR = sim.ringRadius + 1;
-  const newGridCoords = [];
-  (function build(prefix) {
-    if (prefix.length === d) {
-      const maxAbs = Math.max(...prefix.map((v) => Math.abs(v)));
-      if (maxAbs === newR) newGridCoords.push(prefix);
-      return;
-    }
-    for (let i = -newR; i <= newR; i++) build([...prefix, i]);
-  })([]);
-
-  // Spawn position is exact, not estimated: gridPos × the current global
-  // scale factor — that's what createGridCell uses. Nodes with a gridPos
-  // skip the generic force-directed physics entirely (see step()) and
-  // are driven purely by this scale factor, so they can't drift,
-  // overlap, or destabilize regardless of grid size.
-  for (const gridPos of newGridCoords) createGridCell(sim, gridPos, d);
-
-  sim._forces = null; // resize physics buffers next step()
-  sweep(sim);
-}
-
-/**
- * Reaction mechanics — the literal reading of repel/attract as space
- * creation/destruction: a Repell ray periodically sprouts a new node
- * ahead of itself (on a cooldown, so it's an ongoing trickle rather than
- * a one-time burst or a permanent exhaustion). An Attract ray, aimed
- * close enough at an actual neighbor, consumes it — the graph
- * restructures rather than anything going flying: the target is removed
- * and its other connections are inherited by the attacker, which is what
- * accumulates weight over time. When the attacker and target are BOTH
- * "matter" (an Attract ray and a Repell ray each), the encounter is an
- * annihilation instead: both are replaced by two photons. Two photons
- * that end up structurally connected pair-produce back into matter. None
- * of this uses velocity or movement — it's all graph restructuring, so
- * it can't reintroduce nodes "flying" anywhere.
- */
-function markDead(sim, node) {
-  node._dead = true;
-  sim._anyDead = true;
-  if (node.gridPos) sim.gridNodeCount = Math.max((sim.gridNodeCount || 0) - 1, 0);
-  else sim.freeCount = Math.max((sim.freeCount || 0) - 1, 0);
-}
-
-function sweep(sim) {
-  if (!sim._anyDead) return;
-  sim.nodes = sim.nodes.filter((n) => !n._dead);
-  sim.edges = sim.edges.filter(([a, b]) => !a._dead && !b._dead);
-  if (sim.byGridKey) {
-    for (const [k, v] of sim.byGridKey) {
-      if (v._dead) sim.byGridKey.delete(k);
-    }
-  }
-  sim._anyDead = false;
-  sim._forces = null;
-}
-
-// Rewires target's OTHER edges (not the one to `keep`) onto `keep`,
-// skipping anything already connected or dead. Shared by consume and
-// annihilation — both replace a node but want its structure inherited.
-function rewireOnto(sim, keep, from) {
-  const keepNeighbors = new Set();
-  for (const [ea, eb] of sim.edges) {
-    if (ea === keep) keepNeighbors.add(eb);
-    else if (eb === keep) keepNeighbors.add(ea);
-  }
-  for (const [ea, eb] of sim.edges) {
-    let other = null;
-    if (ea === from && eb !== keep) other = eb;
-    else if (eb === from && ea !== keep) other = ea;
-    if (other && !other._dead && other !== keep && !keepNeighbors.has(other)) {
-      sim.edges.push([keep, other, true]);
-      keepNeighbors.add(other);
-    }
-  }
-}
-
-// Rolling window: instead of ever blocking creation once the free-node
-// budget is full, retire the oldest free node to make room first. Repel
-// (and photon/pair-production) creation should never be stoppable — a
-// hard cap that refuses new creation contradicts that, however generous
-// the number. This keeps total count bounded through turnover instead.
-function makeRoomForFreeNode(sim) {
-  while ((sim.freeCount || 0) >= FREE_NODE_CAP && sim.freeQueue.length) {
-    const oldest = sim.freeQueue.shift();
-    if (!oldest._dead) markDead(sim, oldest);
-  }
-}
-
-function spawnPhoton(sim, pos, dir) {
-  makeRoomForFreeNode(sim);
-  const node = new GridNode(pos, false, null);
-  node.isPhoton = true;
-  const ray = new Ray(dir.slice());
-  ray.boundaries[0].op = Op.Neutral;
-  node.rays.push(ray);
-  sim.nodes.push(node);
-  sim.freeQueue.push(node);
-  sim.freeCount = (sim.freeCount || 0) + 1;
-  return node;
-}
-
-function spawnMatter(sim, pos, dir, reversed) {
-  makeRoomForFreeNode(sim);
-  const node = new GridNode(pos, false, null);
-  const front = new Ray(dir.slice());
-  const back = new Ray(dir.map((v) => -v));
-  if (!reversed) {
-    front.boundaries[0].op = Op.Attract;
-    back.boundaries[0].op = Op.Repell;
-  } else {
-    front.boundaries[0].op = Op.Repell;
-    back.boundaries[0].op = Op.Attract;
-  }
-  node.rays.push(front, back);
-  sim.nodes.push(node);
-  sim.freeQueue.push(node);
-  sim.freeCount = (sim.freeCount || 0) + 1;
-  return node;
-}
-
-function isMatter(node) {
-  return node.hasOp(Op.Attract) && node.hasOp(Op.Repell);
-}
-
-// Both nodes are "matter" and aligned — annihilate into two photons
-// instead of a normal one-sided consume. Each photon inherits one side's
-// other connections and points away from the collision, back-to-back —
-// direction only, no velocity. Frontier nodes are exempt, same reasoning
-// as tryConsume.
-function isOnFrontier(sim, node) {
-  return node.gridPos && Math.max(...node.gridPos.map((v) => Math.abs(v))) === sim.ringRadius;
-}
-
-function tryAnnihilate(sim, a, b) {
-  if (a._dead || b._dead || a.isCenter || b.isCenter) return false;
-  if (a.isPhoton || b.isPhoton) return false;
-  if (isOnFrontier(sim, a) || isOnFrontier(sim, b)) return false;
-  if (!isMatter(a) || !isMatter(b)) return false;
-
-  const diff = a.pos.map((v, k) => v - b.pos[k]);
-  const len = Math.hypot(...diff) || 1e-6;
-  const dir = diff.map((v) => v / len);
-
-  const aligned = (n1, n2, d) =>
-    n1.rays.some((ray) => ray.boundaries[0].op === Op.Attract && ray.direction.reduce((s, v, k) => s + v * d[k], 0) > 0.75);
-  const negDir = dir.map((v) => -v);
-  if (!aligned(a, b, negDir) && !aligned(b, a, dir)) return false;
-
-  const mid = a.pos.map((v, k) => (v + b.pos[k]) / 2);
-  const p1 = spawnPhoton(sim, mid, dir);
-  const p2 = spawnPhoton(sim, mid, negDir);
-  rewireOnto(sim, p1, a);
-  rewireOnto(sim, p2, b);
-  markDead(sim, a);
-  markDead(sim, b);
-  return true;
-}
-
-// Two photons sharing an edge pair-produce back into matter, moving in
-// the reverse of their incoming directions — mirrors annihilation.
-function tryPairProduce(sim, a, b) {
-  if (a._dead || b._dead) return false;
-  if (!a.isPhoton || !b.isPhoton) return false;
-
-  const mid = a.pos.map((v, k) => (v + b.pos[k]) / 2);
-  const dirA = a.rays[0].direction.map((v) => -v);
-  const dirB = b.rays[0].direction.map((v) => -v);
-  const m1 = spawnMatter(sim, mid, dirA, false);
-  const m2 = spawnMatter(sim, mid, dirB, true);
-  rewireOnto(sim, m1, a);
-  rewireOnto(sim, m2, b);
-  markDead(sim, a);
-  markDead(sim, b);
-  return true;
-}
-
-// An Attract ray consumes whichever actual neighbor it's aimed closely
-// enough at (dot product of ray direction vs. direction-to-neighbor).
-// The target is removed, but its other edges are rewired onto the
-// attacker — if A/2 points at B/5 and B also has rays 4 and 6 connecting
-// it elsewhere, once B is consumed, 4 and 6 now connect to A instead of
-// dangling or vanishing. Weight transfers along with the structure. The
-// active frontier (the current outermost ring) is exempt — it's freshly
-// spawned and would otherwise get eaten before it ever gets a chance to
-// repel outward itself. It becomes a normal consumption target once a
-// newer shell grows past it.
-function tryConsume(sim, attacker, target) {
-  if (attacker._dead || target._dead || target.isCenter) return false;
-  if (attacker.isPhoton || target.isPhoton) return false;
-  if (isOnFrontier(sim, target)) return false;
-  const diff = target.pos.map((v, k) => v - attacker.pos[k]);
-  const len = Math.hypot(...diff) || 1e-6;
-  const dir = diff.map((v) => v / len);
-  for (const ray of attacker.rays) {
-    if (ray.boundaries[0].op !== Op.Attract) continue;
-    if (ray._lastConsumeTick === sim.globalTickId) continue; // already acted this tick
-    const dot = ray.direction.reduce((s, v, k) => s + v * dir[k], 0);
-    if (dot <= 0.75) continue;
-
-    rewireOnto(sim, attacker, target);
-    attacker.weight += target.weight;
-    ray._lastConsumeTick = sim.globalTickId;
-    markDead(sim, target);
-    return true;
-  }
-  return false;
-}
-
-/* ---------------------------------------------------------------------
- * Generic force-directed physics — this is what makes the renderer work
- * for "any arbitrary graph": mutual repulsion keeps nodes from
- * overlapping, spring edges keep connected nodes near each other. Repell
- * boundaries add one extra force on top: a push away from the origin,
- * scaled by how many Repell boundaries a node carries — which is the
- * literal mechanism of the expansion.
- * ------------------------------------------------------------------- */
-
-const SPRING_K = 0.05; // almost nothing — just enough to keep connected pairs from drifting apart forever, not to hold any shape
-const REWIRED_SPRING_K = 4.0; // strong — a consumption-driven connection is real graph structure and should actually pull
-const REST_LEN = 1.0;
-const EXPANSION_K = 0.85;
-const DAMPING = 0.8;
-const EXPANSION_RATE = 0.18; // exponential growth rate for gridPos-node scaling
-const MAX_NODES = 10000;
-const FREE_NODE_CAP = 4000; // separate budget for repel/photon-spawned nodes, independent of grid growth
-const GLOBAL_TICK_INTERVAL = 0.9; // seconds between synchronized whole-graph repel/attract updates
-const REWIRED_SLOTS_GRID = 2; // rewired (consumption-driven) neighbor slots per grid cell — small, since most cells have none; mesh neighbors need zero slots at all now
-const REWIRED_SLOTS_FREE = 4; // free nodes carry a few more since they have no mesh edges of their own
-const GRID_ATLAS_PADDING = 8; // headroom rings before the atlas needs reallocating
-
-/* ---------------------------------------------------------------------
- * GPU physics, v2 — grid cells are stored in a texture indexed directly
- * by their own gridPos (offset to a non-negative atlas coordinate), not
- * by an arbitrary flat index. A mesh neighbor is always exactly ±1 along
- * one axis, so once a cell's own atlas texel IS its gridPos, finding a
- * neighbor stops being "look up wherever this index points" (a
- * data-dependent gather — slow, cache-hostile, and what made the
- * previous design's dispatch cost dominate regardless of shader
- * micro-optimization) and becomes "read the texel one step over" — a
- * fixed, compile-time-known offset. That's the actual fix; every
- * previous attempt (removing dynamic array indexing, removing
- * large-argument sin(), halving the gather count) was optimizing
- * *inside* the gather instead of removing it.
- *
- * For 3D, a true GPU 3D texture would need one draw call per Z-layer
- * (framebuffers attach one 2D layer at a time) — real complexity for
- * something unverifiable here without a GPU. Instead, Z-slices are
- * tiled side by side into one larger 2D texture (an atlas): a step of
- * ±1 in x or y stays within the current slice tile; a step of ±1 in z
- * is a constant horizontal jump of exactly one slice-width. Single
- * texture, single draw call, only fixed offsets — verified this
- * round-trips correctly and that both neighbor directions reduce to
- * constant offsets before writing any shader code.
- *
- * Free nodes (photons/matter — no gridPos, no mesh edges by
- * construction) and rewired connections (consumption-driven, genuinely
- * arbitrary/non-local — a heavily-consumed cell can inherit connections
- * from anywhere) still need a gather. They get a second, separate,
- * much smaller pass: free nodes are relatively few, and rewired links
- * are the minority of edges compared to mesh — so the gather that
- * remains is doing far less work than before, not just doing the same
- * work faster.
- * ------------------------------------------------------------------- */
-
-const GRID_VERTEX_SRC = `#version 300 es
-in vec2 aPos;
-void main() { gl_Position = vec4(aPos, 0.0, 1.0); }
-`;
-
-function buildGridFragmentSrc() {
-  return `#version 300 es
-precision highp float;
-
-uniform sampler2D uGridPos;      // atlas: xyz=pos, w=weight (0 = empty slot)
-uniform sampler2D uGridVel;      // atlas: xyz=vel, w=unused
-uniform sampler2D uGridRewired;  // atlas: x=idx0, y=idx1 (flat indices into uPoolPos, -1=none)
-uniform sampler2D uPoolPos;      // flat pool (grid cells mirrored + free nodes): xyz=pos, w=weight
-
-uniform float uScale;
-uniform float uDt;
-uniform float uTick;
-uniform float uDims;
-uniform float uAtlasW;
-uniform float uSliceSize;
-uniform float uGridOffset;
-uniform vec2 uPoolTexSize;
-
-layout(location = 0) out vec4 outPos;
-layout(location = 1) out vec4 outVel;
-
-vec4 fetchPoolByIndex(float idx) {
-  if (idx < -0.5) return vec4(0.0);
-  float w = uPoolTexSize.x;
-  float x = mod(idx, w);
-  float y = floor(idx / w);
-  return texelFetch(uPoolPos, ivec2(int(x), int(y)), 0);
-}
-
-void springTerm(inout vec3 force, vec3 pos, float weight, float restLen, vec4 otherData, float k) {
-  if (otherData.w < 0.5) return;
-  vec3 delta = otherData.xyz - pos;
-  float dist = max(length(delta), 1e-4);
-  float edgeWeight = (weight + otherData.w) * 0.5;
-  force += delta * (k * edgeWeight * (dist - restLen) / dist);
-}
-
-void main() {
-  ivec2 texel = ivec2(gl_FragCoord.xy);
-  vec4 posData = texelFetch(uGridPos, texel, 0);
-  float weight = posData.w;
-
-  if (weight < 0.5) {
-    outPos = posData;
-    outVel = texelFetch(uGridVel, texel, 0);
-    return;
-  }
-
-  vec3 pos = posData.xyz;
-  vec4 velData = texelFetch(uGridVel, texel, 0);
-  vec3 vel = velData.xyz;
-
-  // This cell's own gridPos is implicit in its atlas position — no
-  // lookup, just arithmetic on which texel we are.
-  float sliceSize = uSliceSize;
-  float sliceIndex = floor(float(texel.x) / sliceSize);
-  float localX = float(texel.x) - sliceIndex * sliceSize;
-  vec3 gridPos = vec3(localX - uGridOffset, float(texel.y) - uGridOffset, uDims > 2.5 ? (sliceIndex - uGridOffset) : 0.0);
-
-  bool isCenter = abs(gridPos.x) < 0.5 && abs(gridPos.y) < 0.5 && abs(gridPos.z) < 0.5;
-
-  vec3 force = vec3(0.0);
-  float restLen = uScale;
-  float meshK = ${SPRING_K.toFixed(4)};
-
-  // Mesh neighbors: fixed offsets, no gather, no branch on variable
-  // neighbor count — every occupied cell checks the exact same
-  // candidate set the exact same way.
-  springTerm(force, pos, weight, restLen, texelFetch(uGridPos, texel + ivec2(1, 0), 0), meshK);
-  springTerm(force, pos, weight, restLen, texelFetch(uGridPos, texel + ivec2(-1, 0), 0), meshK);
-  springTerm(force, pos, weight, restLen, texelFetch(uGridPos, texel + ivec2(0, 1), 0), meshK);
-  springTerm(force, pos, weight, restLen, texelFetch(uGridPos, texel + ivec2(0, -1), 0), meshK);
-  if (uDims > 2.5) {
-    int slice = int(sliceSize);
-    ivec2 zp = texel + ivec2(slice, 0);
-    if (zp.x < int(uAtlasW)) springTerm(force, pos, weight, restLen, texelFetch(uGridPos, zp, 0), meshK);
-    ivec2 zn = texel + ivec2(-slice, 0);
-    if (zn.x >= 0) springTerm(force, pos, weight, restLen, texelFetch(uGridPos, zn, 0), meshK);
-  }
-
-  // Rewired (consumption-driven) connections — genuinely arbitrary, so
-  // still a gather, but only 2 slots and only for cells that actually
-  // have any (most don't).
-  vec4 rew = texelFetch(uGridRewired, texel, 0);
-  springTerm(force, pos, weight, restLen, fetchPoolByIndex(rew.x), ${REWIRED_SPRING_K.toFixed(4)});
-  springTerm(force, pos, weight, restLen, fetchPoolByIndex(rew.y), ${REWIRED_SPRING_K.toFixed(4)});
-
-  if (!isCenter) {
-    float ring = max(max(abs(gridPos.x), abs(gridPos.y)), abs(gridPos.z));
-    float glen = max(length(gridPos), 1e-6);
-    vec3 target = (gridPos / glen) * ring * uScale;
-    force += (target - pos) * 3.5;
-
-    int h = 0;
-    h = h * 92821 + int(gridPos.x) * (-1640531535);
-    h = h * 92821 + int(gridPos.y) * (-1640531535);
-    h = h * 92821 + int(gridPos.z) * (-1640531535);
-    float phase = (float(uint(h)) / 4294967296.0) * 6.28318530718;
-    float wobbleK = restLen * 0.18;
-    force.x += sin(uTick * 1.6 + phase) * wobbleK;
-    force.y += sin(uTick * 1.6 + phase + 2.09) * wobbleK;
-    if (uDims > 2.5) force.z += sin(uTick * 1.6 + phase + 4.18) * wobbleK;
-  }
-
-  if (isCenter) {
-    outPos = vec4(pos, weight);
-    outVel = vec4(0.0, 0.0, 0.0, 0.0);
-    return;
-  }
-
-  float maxForce = 400.0;
-  float fMag = length(force);
-  if (fMag > maxForce) force *= (maxForce / fMag);
-
-  vec3 newVel = (vel + force * uDt) * ${DAMPING.toFixed(4)};
-  float maxVel = 150.0;
-  float vMag = length(newVel);
-  if (vMag > maxVel) newVel *= (maxVel / vMag);
-
-  vec3 newPos = pos + newVel * uDt;
-  if (!(newPos.x == newPos.x)) newPos = pos;
-  if (!(newPos.y == newPos.y)) newPos = pos;
-  if (!(newPos.z == newPos.z)) newPos = pos;
-
-  outPos = vec4(newPos, weight);
-  outVel = vec4(newVel, 0.0);
-}
-`;
-}
-
-const FREE_FRAGMENT_SRC = `#version 300 es
-precision highp float;
-
-uniform sampler2D uFreePos;     // xyz=pos, w=weight
-uniform sampler2D uFreeVel;     // xyz=vel, w=repelCount
-uniform sampler2D uFreeRewiredA; // 4 rewired neighbor indices into uPoolPos
-uniform sampler2D uFreeRewiredB; // 4 more
-uniform sampler2D uPoolPos;     // combined pool (grid cells mirrored + free nodes)
-
-uniform float uDt;
-uniform float uDims;
-uniform vec2 uPoolTexSize;
-
-layout(location = 0) out vec4 outPos;
-layout(location = 1) out vec4 outVel;
-
-vec4 fetchPoolByIndex(float idx) {
-  if (idx < -0.5) return vec4(0.0);
-  float w = uPoolTexSize.x;
-  float x = mod(idx, w);
-  float y = floor(idx / w);
-  return texelFetch(uPoolPos, ivec2(int(x), int(y)), 0);
-}
-
-void springTerm(inout vec3 force, vec3 pos, float weight, vec4 otherData) {
-  if (otherData.w < 0.5) return;
-  vec3 delta = otherData.xyz - pos;
-  float dist = max(length(delta), 1e-4);
-  float edgeWeight = (weight + otherData.w) * 0.5;
-  force += delta * (${REWIRED_SPRING_K.toFixed(4)} * edgeWeight * (dist - 1.0) / dist);
-}
-
-void main() {
-  ivec2 texel = ivec2(gl_FragCoord.xy);
-  vec4 posData = texelFetch(uFreePos, texel, 0);
-  float weight = posData.w;
-  if (weight < 0.5) {
-    outPos = posData;
-    outVel = texelFetch(uFreeVel, texel, 0);
-    return;
-  }
-  vec3 pos = posData.xyz;
-  vec4 velData = texelFetch(uFreeVel, texel, 0);
-  vec3 vel = velData.xyz;
-  float repelCount = velData.w;
-
-  vec3 force = vec3(0.0);
-  float dimBoost = uDims > 2.5 ? 1.5 : 1.0;
-  force += pos * (repelCount * ${EXPANSION_K.toFixed(4)} * dimBoost);
-
-  vec4 rA = texelFetch(uFreeRewiredA, texel, 0);
-  vec4 rB = texelFetch(uFreeRewiredB, texel, 0);
-  springTerm(force, pos, weight, fetchPoolByIndex(rA.x));
-  springTerm(force, pos, weight, fetchPoolByIndex(rA.y));
-  springTerm(force, pos, weight, fetchPoolByIndex(rA.z));
-  springTerm(force, pos, weight, fetchPoolByIndex(rA.w));
-  springTerm(force, pos, weight, fetchPoolByIndex(rB.x));
-  springTerm(force, pos, weight, fetchPoolByIndex(rB.y));
-  springTerm(force, pos, weight, fetchPoolByIndex(rB.z));
-  springTerm(force, pos, weight, fetchPoolByIndex(rB.w));
-
-  float maxForce = 400.0;
-  float fMag = length(force);
-  if (fMag > maxForce) force *= (maxForce / fMag);
-
-  vec3 newVel = (vel + force * uDt) * ${DAMPING.toFixed(4)};
-  float maxVel = 150.0;
-  float vMag = length(newVel);
-  if (vMag > maxVel) newVel *= (maxVel / vMag);
-
-  vec3 newPos = pos + newVel * uDt;
-  if (!(newPos.x == newPos.x)) newPos = pos;
-  if (!(newPos.y == newPos.y)) newPos = pos;
-  if (!(newPos.z == newPos.z)) newPos = pos;
-
-  outPos = vec4(newPos, weight);
-  outVel = vec4(newVel, repelCount);
-}
-`;
-
-class GPUPhysics {
-  constructor(dims) {
-    this.available = false;
-    this.lastError = null;
-    this.frameCount = 0;
-    this.dims = dims;
-    this.gridCapacityRing = 0;
-    this.poolCapacity = 0;
-    this.freeCapacity = 0;
-    try {
-      let canvas;
-      let usedOffscreen = false;
-      if (typeof OffscreenCanvas !== "undefined") {
-        canvas = new OffscreenCanvas(1, 1);
-        usedOffscreen = true;
-      } else {
-        canvas = document.createElement("canvas");
-      }
-      let gl = canvas.getContext("webgl2");
-      if (!gl && usedOffscreen) {
-        canvas = document.createElement("canvas");
-        usedOffscreen = false;
-        gl = canvas.getContext("webgl2");
-      }
-      if (!gl) {
-        this.lastError = "WebGL2 not supported by this browser/device";
-        return;
-      }
-      this.usedOffscreenCanvas = usedOffscreen;
-      const ext = gl.getExtension("EXT_color_buffer_float");
-      if (!ext) {
-        this.lastError = "EXT_color_buffer_float extension unavailable";
-        return;
-      }
-      this.gl = gl;
-      this.canvas = canvas;
-
-      this.gridProgram = this._buildProgram(gl, GRID_VERTEX_SRC, buildGridFragmentSrc());
-      if (!this.gridProgram) {
-        this.lastError = this.lastError || "grid shader compile/link failed";
-        return;
-      }
-      this.freeProgram = this._buildProgram(gl, GRID_VERTEX_SRC, FREE_FRAGMENT_SRC);
-      if (!this.freeProgram) {
-        this.lastError = this.lastError || "free-node shader compile/link failed";
-        return;
-      }
-
-      const quad = gl.createBuffer();
-      gl.bindBuffer(gl.ARRAY_BUFFER, quad);
-      gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]), gl.STATIC_DRAW);
-      this.quad = quad;
-
-      this.gridUniforms = {};
-      for (const name of ["uGridPos", "uGridVel", "uGridRewired", "uPoolPos", "uScale", "uDt", "uTick", "uDims", "uAtlasW", "uSliceSize", "uGridOffset", "uPoolTexSize"]) {
-        this.gridUniforms[name] = gl.getUniformLocation(this.gridProgram, name);
-      }
-      this.gridAPos = gl.getAttribLocation(this.gridProgram, "aPos");
-
-      this.freeUniforms = {};
-      for (const name of ["uFreePos", "uFreeVel", "uFreeRewiredA", "uFreeRewiredB", "uPoolPos", "uDt", "uDims", "uPoolTexSize"]) {
-        this.freeUniforms[name] = gl.getUniformLocation(this.freeProgram, name);
-      }
-      this.freeAPos = gl.getAttribLocation(this.freeProgram, "aPos");
-
-      this._fbo = gl.createFramebuffer();
-      this.available = true;
-    } catch (e) {
-      this.available = false;
-      this.lastError = "exception during init: " + (e && e.message ? e.message : String(e));
-    }
-  }
-
-  _buildProgram(gl, vsSrc, fsSrc) {
-    const compile = (type, src) => {
-      const sh = gl.createShader(type);
-      gl.shaderSource(sh, src);
-      gl.compileShader(sh);
-      if (!gl.getShaderParameter(sh, gl.COMPILE_STATUS)) {
-        const info = gl.getShaderInfoLog(sh);
-        console.error("GPUPhysics shader compile error:", info);
-        this.lastError = "shader compile error: " + info;
-        gl.deleteShader(sh);
-        return null;
-      }
-      return sh;
-    };
-    const vs = compile(gl.VERTEX_SHADER, vsSrc);
-    const fs = compile(gl.FRAGMENT_SHADER, fsSrc);
-    if (!vs || !fs) return null;
-    const prog = gl.createProgram();
-    gl.attachShader(prog, vs);
-    gl.attachShader(prog, fs);
-    gl.linkProgram(prog);
-    if (!gl.getProgramParameter(prog, gl.LINK_STATUS)) {
-      const info = gl.getProgramInfoLog(prog);
-      console.error("GPUPhysics program link error:", info);
-      this.lastError = "program link error: " + info;
-      return null;
-    }
-    return prog;
-  }
-
-  _makeTexture(gl, w, h) {
-    const tex = gl.createTexture();
-    gl.bindTexture(gl.TEXTURE_2D, tex);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, w, h, 0, gl.RGBA, gl.FLOAT, null);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    return tex;
-  }
-
-  // Grid atlas sized to cover [-ringRadius, ringRadius] in every axis
-  // with headroom, so it doesn't need reallocating every single tick.
-  _ensureGridCapacity(ringRadius, dims) {
-    if (ringRadius <= this.gridCapacityRing && this.sliceSize) return;
-    const gl = this.gl;
-    const ring = ringRadius + GRID_ATLAS_PADDING;
-    this.gridCapacityRing = ring;
-    const sliceSize = 2 * ring + 1;
-    this.sliceSize = sliceSize;
-    this.gridOffset = ring;
-    const atlasW = dims === 3 ? sliceSize * sliceSize : sliceSize;
-    const atlasH = sliceSize;
-    this.atlasW = atlasW;
-    this.atlasH = atlasH;
-
-    for (const key of ["gridPos", "gridPos2", "gridVel", "gridVel2", "gridRewired"]) {
-      const cur = this["_tex_" + key];
-      if (cur) gl.deleteTexture(cur);
-    }
-    this._tex_gridPos = this._makeTexture(gl, atlasW, atlasH);
-    this._tex_gridPos2 = this._makeTexture(gl, atlasW, atlasH);
-    this._tex_gridVel = this._makeTexture(gl, atlasW, atlasH);
-    this._tex_gridVel2 = this._makeTexture(gl, atlasW, atlasH);
-    this._tex_gridRewired = this._makeTexture(gl, atlasW, atlasH);
-
-    this._gridBuf = {
-      pos: new Float32Array(atlasW * atlasH * 4),
-      vel: new Float32Array(atlasW * atlasH * 4),
-      rewired: new Float32Array(atlasW * atlasH * 4),
-      outPos: new Float32Array(atlasW * atlasH * 4),
-      outVel: new Float32Array(atlasW * atlasH * 4),
-    };
-  }
-
-  // Flat pool: mirrors every grid cell's pos/weight (so rewired gathers
-  // — from anyone, grid or free — can reach them) plus every free node.
-  _ensurePoolCapacity(n) {
-    if (n <= this.poolCapacity && this.poolTexW) return;
-    const gl = this.gl;
-    const texW = Math.max(1, Math.ceil(Math.sqrt(n * 1.15)));
-    const texH = Math.max(1, Math.ceil(n / texW) + 1);
-    this.poolTexW = texW;
-    this.poolTexH = texH;
-    this.poolCapacity = texW * texH;
-    if (this._tex_pool) this.gl.deleteTexture(this._tex_pool);
-    this._tex_pool = this._makeTexture(gl, texW, texH);
-    this._poolBuf = new Float32Array(this.poolCapacity * 4);
-  }
-
-  // Free-node flat texture — separate from the pool (which is read-only
-  // gather source for this pass), since free nodes need their own
-  // in/out ping-pong just like grid cells do.
-  _ensureFreeCapacity(n) {
-    if (n <= this.freeCapacity && this.freeTexW) return;
-    const gl = this.gl;
-    const texW = Math.max(1, Math.ceil(Math.sqrt(Math.max(n, 1) * 1.3)));
-    const texH = Math.max(1, Math.ceil(Math.max(n, 1) / texW) + 1);
-    this.freeTexW = texW;
-    this.freeTexH = texH;
-    this.freeCapacity = texW * texH;
-    for (const key of ["freePos", "freePos2", "freeVel", "freeVel2", "freeRewiredA", "freeRewiredB"]) {
-      const cur = this["_tex_" + key];
-      if (cur) gl.deleteTexture(cur);
-    }
-    this._tex_freePos = this._makeTexture(gl, texW, texH);
-    this._tex_freePos2 = this._makeTexture(gl, texW, texH);
-    this._tex_freeVel = this._makeTexture(gl, texW, texH);
-    this._tex_freeVel2 = this._makeTexture(gl, texW, texH);
-    this._tex_freeRewiredA = this._makeTexture(gl, texW, texH);
-    this._tex_freeRewiredB = this._makeTexture(gl, texW, texH);
-    this._freeBuf = {
-      pos: new Float32Array(this.freeCapacity * 4),
-      vel: new Float32Array(this.freeCapacity * 4),
-      rA: new Float32Array(this.freeCapacity * 4),
-      rB: new Float32Array(this.freeCapacity * 4),
-      outPos: new Float32Array(this.freeCapacity * 4),
-      outVel: new Float32Array(this.freeCapacity * 4),
-    };
-  }
-
-  update(sim, dt, dims) {
-    const nodes = sim.nodes;
-    const n = nodes.length;
-    if (n === 0) return true;
-    const __t0 = performance.now();
-    const gl = this.gl;
-
-    const gridNodes = [];
-    const freeNodes = [];
-    for (const node of nodes) {
-      if (node.gridPos) gridNodes.push(node);
-      else freeNodes.push(node);
-    }
-
-    this._ensureGridCapacity(sim.ringRadius || 0, dims);
-    this._ensurePoolCapacity(n);
-    this._ensureFreeCapacity(freeNodes.length);
-
-    const sliceSize = this.sliceSize, offset = this.gridOffset, atlasW = this.atlasW, atlasH = this.atlasH;
-    const gbuf = this._gridBuf;
-    const poolBuf = this._poolBuf;
-    const poolIndex = new Map(); // node -> flat pool index, for rewired-gather encoding
-    let poolCursor = 0;
-
-    const atlasTexelOf = (gridPos) => {
-      const gx = Math.round(gridPos[0]) + offset;
-      const gy = Math.round(gridPos[1]) + offset;
-      if (dims === 3) {
-        const gz = Math.round(gridPos[2] || 0) + offset;
-        return [gx + gz * sliceSize, gy];
-      }
-      return [gx, gy];
-    };
-
-    // Pass 1a: write every grid cell into BOTH the atlas (for mesh
-    // lookups) and the flat pool (for rewired-gather targets from
-    // anyone) — same underlying data, two access patterns.
-    for (const node of gridNodes) {
-      const [ax, ay] = atlasTexelOf(node.gridPos);
-      const off = (ay * atlasW + ax) * 4;
-      gbuf.pos[off] = node.pos[0] || 0;
-      gbuf.pos[off + 1] = node.pos[1] || 0;
-      gbuf.pos[off + 2] = node.pos[2] || 0;
-      gbuf.pos[off + 3] = node.weight;
-      gbuf.vel[off] = node.vel[0] || 0;
-      gbuf.vel[off + 1] = node.vel[1] || 0;
-      gbuf.vel[off + 2] = node.vel[2] || 0;
-      gbuf.vel[off + 3] = 0;
-
-      const pi = poolCursor++;
-      poolIndex.set(node, pi);
-      poolBuf[pi * 4] = node.pos[0] || 0;
-      poolBuf[pi * 4 + 1] = node.pos[1] || 0;
-      poolBuf[pi * 4 + 2] = node.pos[2] || 0;
-      poolBuf[pi * 4 + 3] = node.weight;
-    }
-    for (const node of freeNodes) {
-      const pi = poolCursor++;
-      poolIndex.set(node, pi);
-      poolBuf[pi * 4] = node.pos[0] || 0;
-      poolBuf[pi * 4 + 1] = node.pos[1] || 0;
-      poolBuf[pi * 4 + 2] = node.pos[2] || 0;
-      poolBuf[pi * 4 + 3] = node.weight;
-    }
-
-    // Rewired slots (grid): reset the whole rewired buffer only for
-    // occupied cells' worth of data — simplest correct approach is to
-    // clear indices to -1 across the buffer once, then fill.
-    gbuf.rewired.fill(-1);
-    const gridSlotCursor = new Map();
-    const freeBuf = this._freeBuf;
-    freeBuf.rA.fill(-1);
-    freeBuf.rB.fill(-1);
-    const freeIndexOf = new Map();
-    for (let i = 0; i < freeNodes.length; i++) freeIndexOf.set(freeNodes[i], i);
-    const freeSlotCursor = new Int8Array(freeNodes.length);
-
-    for (const edge of sim.edges) {
-      if (!edge[2]) continue; // mesh edges are handled by fixed atlas offsets — only rewired links need the gather
-      const a = edge[0], b = edge[1];
-      if (a._dead || b._dead) continue;
-      const pa = poolIndex.get(a), pb = poolIndex.get(b);
-      if (pa === undefined || pb === undefined) continue;
-
-      if (a.gridPos) {
-        const [ax, ay] = atlasTexelOf(a.gridPos);
-        const key = ay * atlasW + ax;
-        const slot = gridSlotCursor.get(key) || 0;
-        if (slot < REWIRED_SLOTS_GRID) {
-          gbuf.rewired[key * 4 + slot] = pb;
-          gridSlotCursor.set(key, slot + 1);
-        }
-      } else {
-        const fi = freeIndexOf.get(a);
-        if (fi !== undefined) {
-          const s = freeSlotCursor[fi]++;
-          if (s < REWIRED_SLOTS_FREE) {
-            const tex = s < 4 ? freeBuf.rA : freeBuf.rB;
-            tex[fi * 4 + (s % 4)] = pb;
-          }
-        }
-      }
-
-      if (b.gridPos) {
-        const [bx, by] = atlasTexelOf(b.gridPos);
-        const key = by * atlasW + bx;
-        const slot = gridSlotCursor.get(key) || 0;
-        if (slot < REWIRED_SLOTS_GRID) {
-          gbuf.rewired[key * 4 + slot] = pa;
-          gridSlotCursor.set(key, slot + 1);
-        }
-      } else {
-        const fi = freeIndexOf.get(b);
-        if (fi !== undefined) {
-          const s = freeSlotCursor[fi]++;
-          if (s < REWIRED_SLOTS_FREE) {
-            const tex = s < 4 ? freeBuf.rA : freeBuf.rB;
-            tex[fi * 4 + (s % 4)] = pa;
-          }
-        }
-      }
-    }
-
-    for (let i = 0; i < freeNodes.length; i++) {
-      const node = freeNodes[i];
-      freeBuf.pos[i * 4] = node.pos[0] || 0;
-      freeBuf.pos[i * 4 + 1] = node.pos[1] || 0;
-      freeBuf.pos[i * 4 + 2] = node.pos[2] || 0;
-      freeBuf.pos[i * 4 + 3] = node.weight;
-      freeBuf.vel[i * 4] = node.vel[0] || 0;
-      freeBuf.vel[i * 4 + 1] = node.vel[1] || 0;
-      freeBuf.vel[i * 4 + 2] = node.vel[2] || 0;
-      freeBuf.vel[i * 4 + 3] = node.repelCount;
-    }
-
-    const uploadTo = (tex, w, h, data) => {
-      gl.bindTexture(gl.TEXTURE_2D, tex);
-      gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, w, h, gl.RGBA, gl.FLOAT, data);
-    };
-    uploadTo(this._tex_gridPos, atlasW, atlasH, gbuf.pos);
-    uploadTo(this._tex_gridVel, atlasW, atlasH, gbuf.vel);
-    uploadTo(this._tex_gridRewired, atlasW, atlasH, gbuf.rewired);
-    uploadTo(this._tex_pool, this.poolTexW, this.poolTexH, poolBuf);
-    uploadTo(this._tex_freePos, this.freeTexW, this.freeTexH, freeBuf.pos);
-    uploadTo(this._tex_freeVel, this.freeTexW, this.freeTexH, freeBuf.vel);
-    uploadTo(this._tex_freeRewiredA, this.freeTexW, this.freeTexH, freeBuf.rA);
-    uploadTo(this._tex_freeRewiredB, this.freeTexW, this.freeTexH, freeBuf.rB);
-    const __t1 = performance.now();
-
-    // Pass A: grid cells.
-    gl.viewport(0, 0, atlasW, atlasH);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, this._fbo);
-    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._tex_gridPos2, 0);
-    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._tex_gridVel2, 0);
-    gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
-    if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) {
-      this.lastError = "grid framebuffer incomplete (status " + gl.checkFramebufferStatus(gl.FRAMEBUFFER) + ")";
-      return false;
-    }
-    gl.useProgram(this.gridProgram);
-    gl.bindBuffer(gl.ARRAY_BUFFER, this.quad);
-    gl.enableVertexAttribArray(this.gridAPos);
-    gl.vertexAttribPointer(this.gridAPos, 2, gl.FLOAT, false, 0, 0);
-    const bindGrid = (unit, tex, uniform) => {
-      gl.activeTexture(gl.TEXTURE0 + unit);
-      gl.bindTexture(gl.TEXTURE_2D, tex);
-      gl.uniform1i(this.gridUniforms[uniform], unit);
-    };
-    bindGrid(0, this._tex_gridPos, "uGridPos");
-    bindGrid(1, this._tex_gridVel, "uGridVel");
-    bindGrid(2, this._tex_gridRewired, "uGridRewired");
-    bindGrid(3, this._tex_pool, "uPoolPos");
-    gl.uniform1f(this.gridUniforms.uScale, sim.scaleFactor);
-    gl.uniform1f(this.gridUniforms.uDt, dt);
-    gl.uniform1f(this.gridUniforms.uTick, sim.tick % (Math.PI * 2 / 1.6));
-    gl.uniform1f(this.gridUniforms.uDims, dims);
-    gl.uniform1f(this.gridUniforms.uAtlasW, atlasW);
-    gl.uniform1f(this.gridUniforms.uSliceSize, sliceSize);
-    gl.uniform1f(this.gridUniforms.uGridOffset, offset);
-    gl.uniform2f(this.gridUniforms.uPoolTexSize, this.poolTexW, this.poolTexH);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-
-    // Pass B: free nodes (only if any exist — skip an empty draw call).
-    if (freeNodes.length > 0) {
-      gl.viewport(0, 0, this.freeTexW, this.freeTexH);
-      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._tex_freePos2, 0);
-      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._tex_freeVel2, 0);
-      gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
-      if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) {
-        this.lastError = "free framebuffer incomplete (status " + gl.checkFramebufferStatus(gl.FRAMEBUFFER) + ")";
-        return false;
-      }
-      gl.useProgram(this.freeProgram);
-      gl.bindBuffer(gl.ARRAY_BUFFER, this.quad);
-      gl.enableVertexAttribArray(this.freeAPos);
-      gl.vertexAttribPointer(this.freeAPos, 2, gl.FLOAT, false, 0, 0);
-      const bindFree = (unit, tex, uniform) => {
-        gl.activeTexture(gl.TEXTURE0 + unit);
-        gl.bindTexture(gl.TEXTURE_2D, tex);
-        gl.uniform1i(this.freeUniforms[uniform], unit);
-      };
-      bindFree(0, this._tex_freePos, "uFreePos");
-      bindFree(1, this._tex_freeVel, "uFreeVel");
-      bindFree(2, this._tex_freeRewiredA, "uFreeRewiredA");
-      bindFree(3, this._tex_freeRewiredB, "uFreeRewiredB");
-      bindFree(4, this._tex_pool, "uPoolPos");
-      gl.uniform1f(this.freeUniforms.uDt, dt);
-      gl.uniform1f(this.freeUniforms.uDims, dims);
-      gl.uniform2f(this.freeUniforms.uPoolTexSize, this.poolTexW, this.poolTexH);
-      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    }
-    const __t2 = performance.now();
-
-    gl.bindFramebuffer(gl.FRAMEBUFFER, this._fbo);
-    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._tex_gridPos2, 0);
-    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._tex_gridVel2, 0);
-    gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
-    gl.readBuffer(gl.COLOR_ATTACHMENT0);
-    gl.readPixels(0, 0, atlasW, atlasH, gl.RGBA, gl.FLOAT, gbuf.outPos);
-    gl.readBuffer(gl.COLOR_ATTACHMENT1);
-    gl.readPixels(0, 0, atlasW, atlasH, gl.RGBA, gl.FLOAT, gbuf.outVel);
-
-    if (freeNodes.length > 0) {
-      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._tex_freePos2, 0);
-      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._tex_freeVel2, 0);
-      gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
-      gl.readBuffer(gl.COLOR_ATTACHMENT0);
-      gl.readPixels(0, 0, this.freeTexW, this.freeTexH, gl.RGBA, gl.FLOAT, this._freeBuf.outPos);
-      gl.readBuffer(gl.COLOR_ATTACHMENT1);
-      gl.readPixels(0, 0, this.freeTexW, this.freeTexH, gl.RGBA, gl.FLOAT, this._freeBuf.outVel);
-    }
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    const __t3 = performance.now();
-
-    for (const node of gridNodes) {
-      if (node.isCenter) {
-        for (let k = 0; k < dims; k++) node.vel[k] = 0;
-        continue;
-      }
-      const [ax, ay] = atlasTexelOf(node.gridPos);
-      const off = (ay * atlasW + ax) * 4;
-      for (let k = 0; k < dims; k++) {
-        const val = gbuf.outPos[off + k];
-        node.pos[k] = Number.isFinite(val) ? val : node.pos[k];
-      }
-      for (let k = 0; k < dims; k++) {
-        const val = gbuf.outVel[off + k];
-        node.vel[k] = Number.isFinite(val) ? val : 0;
-      }
-    }
-    for (let i = 0; i < freeNodes.length; i++) {
-      const node = freeNodes[i];
-      for (let k = 0; k < dims; k++) {
-        const val = this._freeBuf.outPos[i * 4 + k];
-        node.pos[k] = Number.isFinite(val) ? val : node.pos[k];
-      }
-      for (let k = 0; k < dims; k++) {
-        const val = this._freeBuf.outVel[i * 4 + k];
-        node.vel[k] = Number.isFinite(val) ? val : 0;
-      }
-    }
-
-    this.frameCount++;
-    this.lastTiming = {
-      marshalUpload: __t1 - __t0,
-      drawDispatch: __t2 - __t1,
-      readback: __t3 - __t2,
-      total: performance.now() - __t0,
-    };
-    this.texW = atlasW; // reused by the UI's fragment-count readout
-    this.texH = atlasH;
-    return true;
-  }
-}
-
-function step(sim, dt, dim) {
-  const { nodes, edges } = sim;
-  const n = nodes.length;
-  const dims = nodes[0].pos.length;
-
-  // Deterministic scale factor for anything with a gridPos — exact
-  // self-similar growth (v ∝ r, applied exactly rather than integrated),
-  // so it can't drift, overlap, or destabilize no matter how large the
-  // grid gets. This replaces relying on the force-directed physics below
-  // to determine overall grid scale; that physics remains fully intact
-  // and generic for future non-grid nodes (graph rewrites).
-  sim.scaleFactor *= Math.exp(EXPANSION_RATE * dt);
-  const scale = sim.scaleFactor;
-
-  if (!sim._forces || sim._forces.length !== n) {
-    sim._forces = new Array(n);
-    for (let i = 0; i < n; i++) sim._forces[i] = new Array(dims).fill(0);
-  }
-  const forces = sim._forces;
-  for (let i = 0; i < n; i++) for (let k = 0; k < dims; k++) forces[i][k] = 0;
-
-  if (!sim._index) sim._index = new Map();
-  const index = sim._index;
-  index.clear();
-  for (let i = 0; i < n; i++) index.set(nodes[i], i);
-
-  const delta = new Array(dims);
-
-  // Generic force-directed physics — springs from every edge, including
-  // ones consumption has rewired into long-range connections. Rest length
-  // tracks the current scale factor rather than a fixed constant: grid
-  // spacing itself grows exponentially (scaleFactor), so a fixed rest
-  // length would leave springs permanently fighting to compress a graph
-  // that expansion is simultaneously stretching apart — that fight is
-  // what physics couldn't keep pace with. With rest length tracking
-  // scale, springs and expansion agree on target spacing, and spacing
-  // emerges from the springs themselves rather than needing any position
-  // reset, hard or soft.
-  const restLen = REST_LEN * scale;
-
-  if (sim._gpuPhysics === undefined) {
-    sim._gpuPhysics = new GPUPhysics(dims);
-  }
-  const gpuOk = sim._gpuPhysics.available && sim._gpuPhysics.update(sim, dt, dims);
-
-  if (!gpuOk) {
-    // CPU fallback — identical math to the GPU shader above, used only
-    // if WebGL2 (or a required extension) isn't available in this
-    // environment. Everything downstream (rendering, growth,
-    // consume/annihilate) is agnostic to which path computed the
-    // positions.
-    for (const edge of edges) {
-      const a = edge[0], b = edge[1];
-      const k_spring = edge[2] ? REWIRED_SPRING_K : SPRING_K;
-      const i = index.get(a), j = index.get(b);
-      let distSq = 0;
-      for (let k = 0; k < dims; k++) {
-        delta[k] = b.pos[k] - a.pos[k];
-        distSq += delta[k] * delta[k];
-      }
-      const dist = Math.sqrt(distSq) || 1e-4;
-      const f = (k_spring * (dist - restLen)) / dist;
-      for (let k = 0; k < dims; k++) {
-        const fk = delta[k] * f;
-        forces[i][k] += fk;
-        forces[j][k] -= fk;
-      }
-    }
-
-    const dimBoost = dims === 3 ? 1.5 : 1;
-    for (let i = 0; i < n; i++) {
-      const node = nodes[i];
-      if (node.isCenter || node.gridPos) continue;
-      const f = node.repelCount * EXPANSION_K * dimBoost;
-      for (let k = 0; k < dims; k++) forces[i][k] += node.pos[k] * f;
-    }
-
-    const SHELL_ANCHOR_K = 3.5;
-    for (let i = 0; i < n; i++) {
-      const node = nodes[i];
-      if (node.isCenter || !node.gridPos) continue;
-      const target = sphereTargetPos(node.gridPos, scale);
-      for (let k = 0; k < dims; k++) {
-        forces[i][k] += (target[k] - node.pos[k]) * SHELL_ANCHOR_K;
-      }
-    }
-
-    const WOBBLE_K = restLen * 0.18;
-    const WOBBLE_RATE = 1.6;
-    for (let i = 0; i < n; i++) {
-      const node = nodes[i];
-      if (node.isCenter || !node.gridPos) continue;
-      if (node._wobblePhase === undefined) {
-        let h = 0;
-        for (let k = 0; k < dims; k++) h = (h * 92821 + (node.gridPos[k] | 0) * 2654435761) | 0;
-        node._wobblePhase = ((h >>> 0) / 4294967296) * Math.PI * 2;
-      }
-      for (let k = 0; k < dims; k++) {
-        const axisPhase = node._wobblePhase + k * 2.09;
-        forces[i][k] += Math.sin(sim.tick * WOBBLE_RATE + axisPhase) * WOBBLE_K;
-      }
-    }
-
-    const MAX_FORCE = 400;
-    const MAX_VEL = 150;
-
-    for (let i = 0; i < n; i++) {
-      const node = nodes[i];
-
-      if (node.isCenter) {
-        for (let k = 0; k < dims; k++) node.vel[k] = 0;
-        continue;
-      }
-
-      let fMagSq = 0;
-      for (let k = 0; k < dims; k++) fMagSq += forces[i][k] * forces[i][k];
-      if (fMagSq > MAX_FORCE * MAX_FORCE) {
-        const s = MAX_FORCE / Math.sqrt(fMagSq);
-        for (let k = 0; k < dims; k++) forces[i][k] *= s;
-      }
-
-      let vMagSq = 0;
-      for (let k = 0; k < dims; k++) {
-        node.vel[k] = (node.vel[k] + forces[i][k] * dt) * DAMPING;
-        vMagSq += node.vel[k] * node.vel[k];
-      }
-      if (vMagSq > MAX_VEL * MAX_VEL) {
-        const s = MAX_VEL / Math.sqrt(vMagSq);
-        for (let k = 0; k < dims; k++) node.vel[k] *= s;
-      }
-
-      for (let k = 0; k < dims; k++) {
-        node.pos[k] += node.vel[k] * dt;
-        if (!Number.isFinite(node.pos[k])) node.pos[k] = 0;
-      }
-    }
-  }
-
-  // One synchronized global tick governs everything: grid growth (one new
-  // ring — 3×3 → 5×5 → 7×7, exactly one ring per tick) and every
-  // Repell/Attract boundary in the graph, together. Not independent
-  // timers. On each tick the whole graph is scanned: every un-consumed
-  // edge is checked for annihilation/pair-production/consumption, and
-  // every Repell ray fires. Repell is never spent and never individually
-  // throttled — a boundary keeps expanding on every single global tick,
-  // unconditionally.
-  const __tickT0 = performance.now();
-  if (sim.tick >= (sim.nextGlobalTick || 0)) {
-    sim.nextGlobalTick = sim.tick + GLOBAL_TICK_INTERVAL;
-    sim.globalTickId = (sim.globalTickId || 0) + 1;
-
-    // Snapshot the edge count first — rewireOnto (inside tryConsume/
-    // tryAnnihilate) pushes new edges onto this exact array. Iterating a
-    // live, growing array meant a newly-rewired edge got immediately
-    // reprocessed by this same loop, which could trigger further
-    // consumption on a different node's still-unspent ray, pushing more
-    // edges, reprocessed again — an unbounded same-tick cascade once it
-    // reached a high-weight, high-degree node. Newly-rewired edges now
-    // get their first chance on the NEXT tick instead, same as growShell.
-    const edgeCountAtTickStart = edges.length;
-    for (let ei = 0; ei < edgeCountAtTickStart; ei++) {
-      const [a, b] = edges[ei];
-      if (a._dead || b._dead) continue;
-      if (a.isPhoton && b.isPhoton) {
-        tryPairProduce(sim, a, b);
-        continue;
-      }
-      if (a.isPhoton || b.isPhoton) continue;
-      if (tryAnnihilate(sim, a, b)) continue;
-      tryConsume(sim, a, b);
-      tryConsume(sim, b, a);
-    }
-
-    // Repell-triggered spawning: any grid cell with a Repell-op ray tries
-    // to create a new cell one step further outward, using the exact
-    // same mechanism growShell uses (createGridCell). Most of these
-    // no-op — the target position is already filled by growShell's own
-    // systematic growth — except right at the frontier (genuinely empty)
-    // or over a gap left by consumption (regrows it). That self-limits
-    // the real work to roughly the frontier's surface area without
-    // needing an explicit frontier check. Bounded by n (the tick-start
-    // node count) so newly-created cells this tick aren't immediately
-    // rescanned — same reasoning as the edge-scan snapshot above.
-    if ((sim.gridNodeCount || 0) < MAX_NODES) {
-      for (let i = 0; i < n; i++) {
-        const cell = nodes[i];
-        if (cell._dead || cell.isCenter || !cell.gridPos) continue;
-        for (const ray of cell.rays) {
-          if (ray.boundaries[0].op !== Op.Repell) continue;
-          const outward = ray.direction.map((v) => -v);
-          const targetPos = cell.gridPos.map((v, k) => v + (outward[k] || 0));
-          createGridCell(sim, targetPos, dim);
-        }
-      }
-    }
-
-    if ((sim.gridNodeCount || 0) < MAX_NODES) growShell(sim, dim);
-  }
-  sim._lastTickMs = performance.now() - __tickT0;
-  sweep(sim);
-}
-
-/* ---------------------------------------------------------------------
- * Projection + drawing
- * ------------------------------------------------------------------- */
-
-function project(pos, dim, rot, tilt, camDist) {
-  const x = pos[0] || 0, y = pos[1] || 0, z = pos[2] || 0;
-  if (dim === 2) return { x, y, depth: 1, clipped: false };
-  const cosR = Math.cos(rot), sinR = Math.sin(rot);
-  const x1 = x * cosR - z * sinR;
-  const z1 = x * sinR + z * cosR;
-  const cosT = Math.cos(tilt), sinT = Math.sin(tilt);
-  const y1 = y * cosT - z1 * sinT;
-  const z2 = y * sinT + z1 * cosT;
-  // True perspective: camera sits at distance camDist from the origin
-  // along the view axis. Points nearer the camera than that (denom small
-  // or negative) are behind/at the lens and get clipped. Convergence
-  // toward a vanishing point is now the CORRECT result of an actual
-  // camera, not a bug — it's what "moving the camera closer" means.
-  const denom = z2 + camDist;
-  if (denom < camDist * 0.02) return { x: 0, y: 0, depth: 0, clipped: true };
-  const persp = camDist / denom;
-  return { x: x1 * persp, y: y1 * persp, depth: Math.min(Math.max(persp, 0.15), 6), clipped: false };
-}
-
-function draw(ctx, canvas, sim, dim, cam, dt, showGridLines) {
-  const w = canvas.clientWidth, h = canvas.clientHeight;
-
-  ctx.fillStyle = "#06070c";
-  ctx.fillRect(0, 0, w, h);
-  const vg = ctx.createRadialGradient(w / 2, h / 2, 0, w / 2, h / 2, Math.max(w, h) / 1.05);
-  vg.addColorStop(0, "rgba(20,22,34,0)");
-  vg.addColorStop(1, "rgba(0,0,0,0.55)");
-  ctx.fillStyle = vg;
-  ctx.fillRect(0, 0, w, h);
-
-  if (!sim) return;
-
-  // Raw world extent (unprojected) — this is what the base pixel scale
-  // tracks, deliberately independent of camera distance/perspective, so
-  // there's no feedback loop between "how far the camera has dollied" and
-  // "how much of the grid fits on screen". A real camera doesn't refit
-  // its FOV to guarantee everything stays visible as it moves closer.
-  let worldExtent = 1e-6;
-  for (const n of sim.nodes) {
-    const r = Math.hypot(...n.pos);
-    if (r > worldExtent) worldExtent = r;
-  }
-
-  // Scale/distance are always exactly proportional to the grid's current
-  // size — recomputed directly every frame, not smoothed toward a target.
-  // That matters for two reasons: (1) no lerp means nothing ever "chases"
-  // a moving target, which is what read as unwanted drift; (2) being
-  // exactly proportional means the camera can never fall behind the
-  // grid's exponential physical growth, which a genuinely fixed distance
-  // eventually does — that falling-behind is what looked like runaway
-  // automatic zoom-in with no way to scroll back out. The user's zoom
-  // level (scaleMult / distMult) is a stable multiplier riding on top,
-  // changed only by scroll — never reset or overridden automatically.
-  if (dim === 3) {
-    cam.dist = worldExtent * (cam.distMult || 1.5);
-    cam.scale = (Math.min(w, h) * 0.38) / worldExtent;
-  } else {
-    cam.scale = ((Math.min(w, h) * 0.38) / worldExtent) * (cam.scaleMult || 1);
-  }
-
-  // Cursor-anchored pan only applies in 2D — there's no camera distance to
-  // dolly there, so screen-space zoom-toward-cursor is the natural
-  // control. In 3D the camera orbits/dollies toward the origin, which is
-  // the standard convention for an orbit camera.
-  const panX = dim === 2 && cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
-  const panY = dim === 2 && cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
-  const cx = w / 2 + panX, cy = h / 2 + panY;
-
-  const projected = new Map();
-  for (const n of sim.nodes) {
-    projected.set(n, project(n.pos, dim, cam.rot, cam.tilt, cam.dist || 1));
-  }
-
-  const pts = new Map();
-  for (const [n, p] of projected) {
-    pts.set(n, { x: cx + p.x * cam.scale, y: cy + p.y * cam.scale, depth: p.depth, clipped: p.clipped });
-  }
-
-  // Viewport culling: skip the detailed rendering work (ray projection,
-  // shadowBlur, stroke/fill calls) for anything clearly off-screen. Once
-  // zoomed into part of a large structure, most of the population isn't
-  // actually visible — this is what stops paying for it anyway. Margin
-  // is generous (a couple of scale-units of screen space) so a node just
-  // outside the canvas edge doesn't have its still-visible ray tip
-  // prematurely clipped.
-  const cullMargin = cam.scale * 2;
-  const onScreen = (p) => p.x > -cullMargin && p.x < w + cullMargin && p.y > -cullMargin && p.y < h + cullMargin;
-
-  if (showGridLines) {
-    for (const [n, parent] of sim.edges) {
-      const a = pts.get(n), b = pts.get(parent);
-      if (a.clipped || b.clipped) continue;
-      if (!onScreen(a) && !onScreen(b)) continue;
-      const w = Math.max(n.weight, parent.weight);
-      if (w > 1) {
-        const boost = Math.min(w - 1, 6);
-        ctx.strokeStyle = `rgba(199,175,255,${Math.min(0.16 + boost * 0.1, 0.7)})`;
-        ctx.lineWidth = 1 + boost * 0.35;
-      } else {
-        ctx.strokeStyle = "rgba(120,130,160,0.16)";
-        ctx.lineWidth = 1;
-      }
-      ctx.beginPath();
-      ctx.moveTo(a.x, a.y);
-      ctx.lineTo(b.x, b.y);
-      ctx.stroke();
-    }
-  } else {
-    // Gravity flow: a continuous volumetric-style density cloud, not
-    // discrete particles or lines — sampled on a real 3D grid, colored
-    // by a dark→purple→orange→white intensity ramp, and blended
-    // additively so overlapping samples read as one smooth glow rather
-    // than visible individual blobs. Fully world-space: every sample
-    // point is a real 3D coordinate projected through the same camera
-    // pipeline as every node, so it's navigable exactly like the rest of
-    // the scene — rotate, zoom, or move through it and depth/perspective
-    // apply correctly, the same way they do for real structure.
-    const dims3 = sim.nodes[0].pos.length;
-    const sources = [];
-    for (const n of sim.nodes) {
-      if (n.isPhoton) continue;
-      if (isMatter(n)) continue; // both Attract and Repell at the same position/weight always cancel to zero net effect — neutral
-      for (const ray of n.rays) {
-        const op = ray.boundaries[0].op;
-        if (op === Op.Attract) sources.push({ pos: n.pos, sign: 1, w: n.weight });
-        else if (op === Op.Repell) sources.push({ pos: n.pos, sign: -1, w: n.weight });
-      }
-    }
-    const MAX_SOURCES = 220;
-    if (sources.length > MAX_SOURCES) {
-      sources.sort((a, b) => b.w - a.w);
-      sources.length = MAX_SOURCES;
-    }
-
-    if (sources.length > 0) {
-      const SOFTEN_SQ = (0.6 * worldExtent) ** 2 * 0.02 + 0.04;
-      const gridExtent = worldExtent * 1.05;
-      const RES = dims3 === 3 ? 7 : 18;
-      const step = (gridExtent * 2) / RES;
-      // With additive blending, up to RES samples can land at nearly the
-      // same screen position when stacked along the view ray — 2D has no
-      // such stacking (it's a flat plane), which is why 3D was reading
-      // dramatically brighter for the same underlying field strength.
-      const depthStackCompensation = dims3 === 3 ? 1 / (RES * 0.45) : 1;
-
-      // Intensity ramp: true black at low gravity through deep purple and
-      // orange to true white at high gravity — black is less, white is
-      // more.
-      function densityColor(t, alpha) {
-        t = Math.min(Math.max(t, 0), 1);
-        let r, g, b;
-        if (t < 0.4) {
-          const u = t / 0.4;
-          r = u * 60; g = u * 20; b = u * 70;
-        } else if (t < 0.75) {
-          const u = (t - 0.4) / 0.35;
-          r = 60 + u * 195; g = 20 + u * 95; b = 70 - u * 30;
-        } else {
-          const u = (t - 0.75) / 0.25;
-          r = 255; g = 115 + u * 140; b = 40 + u * 215;
-        }
-        return `rgba(${r | 0},${g | 0},${b | 0},${alpha})`;
-      }
-
-      const samples = [];
-      let maxMag = 0;
-      const pos = new Array(dims3);
-      const build = (axis) => {
-        if (axis === dims3) {
-          // Scalar potential, not a vector sum — sum of each source's
-          // weighted influence by magnitude (attract adds, repell
-          // subtracts), never letting opposite directions cancel out
-          // geometrically. A dense, symmetric cluster of attractors
-          // previously could read as near-zero here purely because their
-          // pull directions pointed every which way and summed to
-          // nothing as vectors — physically real for net force, but not
-          // what "concentrated attractors should look bright" means.
-          let potential = 0;
-          for (const src of sources) {
-            let distSq = SOFTEN_SQ;
-            for (let k = 0; k < dims3; k++) distSq += (src.pos[k] - pos[k]) ** 2;
-            potential += (src.w * src.sign) / distSq;
-          }
-          const mag = Math.max(potential, 0); // repell-dominated regions read as black, not negative
-          if (mag > maxMag) maxMag = mag;
-          samples.push({ pos: pos.slice(), mag });
-          return;
-        }
-        for (let i = 0; i < RES; i++) {
-          pos[axis] = -gridExtent + i * step + step / 2;
-          build(axis + 1);
-        }
-      };
-      build(0);
-
-      // Sort far-to-near so nearer glows layer on top — matters even
-      // with additive blending, for depth-based size/alpha falloff to
-      // read correctly.
-      const withDepth = samples.map((s) => {
-        const proj = project(s.pos, dim, cam.rot, cam.tilt, cam.dist || 1);
-        return { s, proj };
-      }).filter((x) => !x.proj.clipped);
-      withDepth.sort((x, y) => y.proj.depth - x.proj.depth);
-
-      const prevComposite = ctx.globalCompositeOperation;
-      ctx.globalCompositeOperation = "lighter";
-      for (const { s, proj } of withDepth) {
-        const x = cx + proj.x * cam.scale, y = cy + proj.y * cam.scale;
-        if (!onScreen({ x, y })) continue;
-        const depthFactor = dim === 3 ? Math.min(Math.max(proj.depth, 0.3), 1.8) : 1;
-        const norm = maxMag > 0 ? Math.min(s.mag / maxMag, 1) : 0;
-        if (norm < 0.015) continue; // relative, not absolute — adapts to whatever scale the field is currently at
-        const radius = (step * cam.scale * 0.9 + norm * cam.scale * 0.5) * depthFactor;
-        if (radius < 1.5) continue;
-        const alpha = Math.min(0.05 + norm * 0.35, 0.4) * Math.min(depthFactor, 1) * depthStackCompensation;
-        const grad = ctx.createRadialGradient(x, y, 0, x, y, radius);
-        grad.addColorStop(0, densityColor(norm, alpha));
-        grad.addColorStop(1, densityColor(norm, 0));
-        ctx.fillStyle = grad;
-        ctx.beginPath();
-        ctx.arc(x, y, radius, 0, Math.PI * 2);
-        ctx.fill();
-      }
-      ctx.globalCompositeOperation = prevComposite;
-    }
-  }
-
-  for (const n of sim.nodes) {
-    const p = pts.get(n);
-    if (p.clipped) continue;
-    if (!onScreen(p)) continue;
-    const depth = dim === 3 ? Math.min(Math.max(p.depth, 0.4), 1.6) : 1;
-
-    if (n.isCenter) {
-      const r = Math.min(Math.max(cam.scale * 0.16 * depth, 0.8), 26);
-      const g = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3);
-      g.addColorStop(0, "rgba(255,217,168,0.9)");
-      g.addColorStop(1, "rgba(255,217,168,0)");
-      ctx.fillStyle = g;
-      ctx.beginPath();
-      ctx.arc(p.x, p.y, r * 3, 0, Math.PI * 2);
-      ctx.fill();
-      ctx.fillStyle = "#FFE9CE";
-      ctx.beginPath();
-      ctx.arc(p.x, p.y, r, 0, Math.PI * 2);
-      ctx.fill();
-      continue;
-    }
-
-    if (n.isPhoton) {
-      const dir = n.rays[0].direction;
-      const tipPos = n.pos.map((v, k) => v + (dir[k] || 0) * 0.5);
-      const tip = project(tipPos, dim, cam.rot, cam.tilt, cam.dist || 1);
-      const tx = cx + tip.x * cam.scale, ty = cy + tip.y * cam.scale;
-      const rayLen = Math.hypot(tx - p.x, ty - p.y);
-      if (!tip.clipped && Number.isFinite(tx) && Number.isFinite(ty) && rayLen < cam.scale * 6) {
-        ctx.strokeStyle = "#FFE9A8";
-        ctx.lineWidth = 2 * depth;
-        ctx.shadowColor = "#FFE9A8";
-        ctx.shadowBlur = Math.min(Math.max(cam.scale * 0.06, 2), 16);
-        ctx.beginPath();
-        ctx.moveTo(p.x, p.y);
-        ctx.lineTo(tx, ty);
-        ctx.stroke();
-        ctx.shadowBlur = 0;
-      }
-      ctx.fillStyle = "#FFF6DC";
-      ctx.beginPath();
-      ctx.arc(p.x, p.y, Math.min(Math.max(cam.scale * 0.07 * depth, 0.6), 11), 0, Math.PI * 2);
-      ctx.fill();
-      continue;
-    }
-
-    // Draw each ray colored by its own op — Repell (amber) vs Attract
-    // (cyan) vs Neutral (not drawn). A node with both an Attract and a
-    // Repell ray gets a bright core, since it can both consume neighbors
-    // and sprout new structure.
-    let hasAttract = false, hasRepell = false;
-    for (const ray of n.rays) {
-      const op = ray.boundaries[0].op;
-      if (op === Op.Attract) hasAttract = true;
-      if (op === Op.Repell) hasRepell = true;
-      if (op === Op.Neutral) continue;
-
-      const dir = op === Op.Repell ? ray.direction.map((v) => -v) : ray.direction;
-      const tipPos = n.pos.map((v, k) => v + (dir[k] || 0) * 0.45);
-      const tip = project(tipPos, dim, cam.rot, cam.tilt, cam.dist || 1);
-      const tx = cx + tip.x * cam.scale, ty = cy + tip.y * cam.scale;
-      const rayLen = Math.hypot(tx - p.x, ty - p.y);
-      // The tip point sits farther from origin than the node itself, so
-      // under true perspective it can cross the near-clip plane (or blow
-      // up near it) even when the node doesn't — skip degenerate tips
-      // rather than draw a stray line to screen-center.
-      if (!(!tip.clipped && Number.isFinite(tx) && Number.isFinite(ty) && rayLen < cam.scale * 6)) continue;
-
-      // A Repell ray on an interior (non-frontier) cell still exists — it
-      // just stopped being "the active boundary". Rendered dim rather
-      // than hidden, so a node's true op composition (e.g. an attractor
-      // that also has a repell ray) is never visually lied about; only
-      // the frontier gets the bright glow.
-      const onFrontierNow = n.gridPos ? isOnFrontier(sim, n) : true;
-      const dim_ = op === Op.Repell && !onFrontierNow;
-      const color = op === Op.Repell ? "#FF7A45" : "#3DDCFF";
-      ctx.strokeStyle = dim_ ? "rgba(255,122,69,0.35)" : color;
-      ctx.lineWidth = (dim_ ? 1 : 1.6) * depth;
-      if (!dim_) {
-        ctx.shadowColor = color;
-        ctx.shadowBlur = Math.min(Math.max(cam.scale * 0.045, 1), 9);
-      }
-      ctx.beginPath();
-      ctx.moveTo(p.x, p.y);
-      ctx.lineTo(tx, ty);
-      ctx.stroke();
-      ctx.shadowBlur = 0;
-    }
-
-    const isMatter = hasAttract && hasRepell;
-    const weightBoost = 1 + Math.min(n.weight - 1, 6) * 0.12;
-    ctx.fillStyle = isMatter ? "#EDEFF5" : "#5A5F72";
-    ctx.beginPath();
-    ctx.arc(p.x, p.y, Math.min(Math.max(cam.scale * (isMatter ? 0.075 : 0.05) * depth * weightBoost, 0.5), 16), 0, Math.PI * 2);
-    ctx.fill();
-  }
-}
-
-/* ---------------------------------------------------------------------
- * Component
- * ------------------------------------------------------------------- */
-
-export default function ExpandingUniverse() {
-  const canvasRef = useRef(null);
-  const simRef = useRef(null);
-  const camRef = useRef({ scale: 44, rot: 0, tilt: 0.6155, anchor: null, dist: null, distMult: 1.5, scaleMult: 1 });
-  const lastReadoutRef = useRef(0);
-  const gpuFpsTrackRef = useRef({ count: 0, time: 0 });
-  const frameTimeRef = useRef({ step: null, draw: null });
-
-  const [dim, setDim] = useState(2);
-  const [running, setRunning] = useState(true);
-  const [showGridLines, setShowGridLines] = useState(false);
-  const [readout, setReadout] = useState({ tick: "0.0", factor: "1.00", nodes: 0, gridNodes: 0, ring: 1, gpuStatus: "checking...", gpuError: null, gpuTiming: null, frameBreakdown: null });
-
-  const reset = useCallback((d) => {
-    const prevGpu = simRef.current && simRef.current._gpuPhysics;
-    simRef.current = nD_Expanding(d, 3);
-    if (prevGpu) simRef.current._gpuPhysics = prevGpu; // reuse WebGL context/textures across resets
-    camRef.current.rot = d === 3 ? Math.PI / 4 : 0;
-    camRef.current.tilt = 0.6155;
-    camRef.current.anchor = null;
-    camRef.current.distMult = 1.5;
-    camRef.current.scaleMult = 1;
-  }, []);
-
-  useEffect(() => {
-    reset(dim);
-  }, [dim, reset]);
-
-  useEffect(() => {
-    const canvas = canvasRef.current;
-    const ctx = canvas.getContext("2d");
-    let raf;
-    let last = performance.now();
-
-    function resize() {
-      const parent = canvas.parentElement;
-      const w = parent.clientWidth, h = parent.clientHeight;
-      const ratio = window.devicePixelRatio || 1;
-      canvas.width = w * ratio;
-      canvas.height = h * ratio;
-      canvas.style.width = w + "px";
-      canvas.style.height = h + "px";
-      ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
-    }
-    resize();
-    window.addEventListener("resize", resize);
-
-    // Scroll to zoom. 2D: cursor-anchored zoom (screen-space, no depth to
-    // navigate) — modifies cam.scaleMult. 3D: real dolly — scrolling
-    // moves the camera closer/farther along the view axis, driving
-    // genuine perspective rather than a flat scale.
-    function onWheel(e) {
-      e.preventDefault();
-      const factor = Math.exp(-e.deltaY * 0.001);
-      const cam = camRef.current;
-
-      if (dim === 3) {
-        cam.distMult = Math.min(Math.max((cam.distMult || 1.5) / factor, 0.01), 200);
-        return;
-      }
-
-      const rect = canvas.getBoundingClientRect();
-      const rx = e.clientX - rect.left - rect.width / 2;
-      const ry = e.clientY - rect.top - rect.height / 2;
-      const curPanX = cam.anchor ? cam.anchor.screenX - cam.anchor.worldX * cam.scale : 0;
-      const curPanY = cam.anchor ? cam.anchor.screenY - cam.anchor.worldY * cam.scale : 0;
-      cam.anchor = {
-        worldX: (rx - curPanX) / cam.scale,
-        worldY: (ry - curPanY) / cam.scale,
-        screenX: rx,
-        screenY: ry,
-      };
-      cam.scaleMult = Math.min(Math.max((cam.scaleMult || 1) * factor, 1e-4), 1e4);
-    }
-    canvas.addEventListener("wheel", onWheel, { passive: false });
-
-    // Right-click drag to orbit (3D) — horizontal drag rotates, vertical
-    // drag adjusts tilt. Suppress the browser context menu so right-click
-    // is free to use as a drag button.
-    function onContextMenu(e) {
-      e.preventDefault();
-    }
-    canvas.addEventListener("contextmenu", onContextMenu);
-
-    let dragging = false;
-    let lastX = 0, lastY = 0;
-    function onMouseDown(e) {
-      if (e.button !== 2) return;
-      dragging = true;
-      lastX = e.clientX;
-      lastY = e.clientY;
-    }
-    function onMouseMove(e) {
-      if (!dragging) return;
-      const dx = e.clientX - lastX, dy = e.clientY - lastY;
-      lastX = e.clientX;
-      lastY = e.clientY;
-      const cam = camRef.current;
-      cam.rot += dx * 0.006;
-      cam.tilt = Math.min(Math.max(cam.tilt + dy * 0.006, -1.15), 1.15);
-    }
-    function onMouseUp(e) {
-      if (e.button === 2) dragging = false;
-    }
-    canvas.addEventListener("mousedown", onMouseDown);
-    window.addEventListener("mousemove", onMouseMove);
-    window.addEventListener("mouseup", onMouseUp);
-
-    function frame(now) {
-      const dt = Math.min((now - last) / 1000, 0.05);
-      last = now;
-      const sim = simRef.current;
-
-      const __fStepStart = performance.now();
-      if (sim && running) {
-        step(sim, dt * 1.3, dim);
-        sim.tick += dt;
-      }
-      const __fStepEnd = performance.now();
-      draw(ctx, canvas, sim, dim, camRef.current, dt, showGridLines);
-      const __fDrawEnd = performance.now();
-
-      const stepMs = __fStepEnd - __fStepStart;
-      const drawMs = __fDrawEnd - __fStepEnd;
-      const t = frameTimeRef.current;
-      t.step = t.step === null ? stepMs : t.step * 0.9 + stepMs * 0.1;
-      t.draw = t.draw === null ? drawMs : t.draw * 0.9 + drawMs * 0.1;
-      t.stepRaw = stepMs;
-
-      if (sim && now - lastReadoutRef.current > 200) {
-        lastReadoutRef.current = now;
-        const gpu = sim._gpuPhysics;
-        let gpuStatus, gpuError, gpuTiming = null;
-        if (!gpu) {
-          gpuStatus = "initializing...";
-          gpuError = null;
-        } else if (gpu.available && gpu.frameCount > 0) {
-          const track = gpuFpsTrackRef.current;
-          const dCount = gpu.frameCount - track.count;
-          const dTime = now - track.time;
-          const fps = track.time > 0 && dTime > 0 ? (dCount / dTime) * 1000 : 0;
-          track.count = gpu.frameCount;
-          track.time = now;
-          gpuStatus = "GPU active (" + (track.time > 0 ? fps.toFixed(0) : "…") + " fps, " + (gpu.usedOffscreenCanvas ? "OffscreenCanvas" : "regular canvas") + ")";
-          gpuError = null;
-          if (gpu.lastTiming) {
-            const t = gpu.lastTiming;
-            const fragCount = (gpu.texW || 0) * (gpu.texH || 0);
-            gpuTiming = `upload ${t.marshalUpload.toFixed(1)}ms · dispatch ${t.drawDispatch.toFixed(1)}ms (${fragCount} fragments) · readback ${t.readback.toFixed(1)}ms · total ${t.total.toFixed(1)}ms`;
-          }
-        } else if (gpu.available) {
-          gpuStatus = "GPU ready, not yet run";
-          gpuError = null;
-        } else {
-          gpuStatus = "CPU fallback";
-          gpuError = gpu.lastError;
-        }
-        const stepMs = frameTimeRef.current.step || 0;
-        const drawMs = frameTimeRef.current.draw || 0;
-        const totalMs = stepMs + drawMs;
-        const tickMs = sim._lastTickMs || 0;
-        const stepRawMs = frameTimeRef.current.stepRaw || 0;
-        setReadout({
-          tick: sim.tick.toFixed(1),
-          factor: sim.scaleFactor.toFixed(2),
-          nodes: sim.nodes.length,
-          gridNodes: sim.gridNodeCount || 0,
-          ring: sim.ringRadius,
-          gpuStatus,
-          gpuError,
-          gpuTiming,
-          frameBreakdown: `frame: step ${stepMs.toFixed(1)}ms smoothed / ${stepRawMs.toFixed(1)}ms raw (tick-logic ${tickMs.toFixed(1)}ms) + draw ${drawMs.toFixed(1)}ms = ${totalMs.toFixed(1)}ms (~${totalMs > 0 ? (1000 / totalMs).toFixed(0) : "…"} fps)`,
-        });
-      }
-      raf = requestAnimationFrame(frame);
-    }
-    raf = requestAnimationFrame(frame);
-
-    return () => {
-      cancelAnimationFrame(raf);
-      window.removeEventListener("resize", resize);
-      canvas.removeEventListener("wheel", onWheel);
-      canvas.removeEventListener("contextmenu", onContextMenu);
-      canvas.removeEventListener("mousedown", onMouseDown);
-      window.removeEventListener("mousemove", onMouseMove);
-      window.removeEventListener("mouseup", onMouseUp);
-    };
-  }, [dim, running, showGridLines]);
-
-  const pillStyle = (active) => ({
-    padding: "6px 14px",
-    borderRadius: 999,
-    fontSize: 12,
-    letterSpacing: 0.5,
-    fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-    border: `1px solid ${active ? "#FF7A45" : "rgba(255,255,255,0.15)"}`,
-    background: active ? "rgba(255,122,69,0.14)" : "rgba(255,255,255,0.03)",
-    color: active ? "#FFD9A8" : "#9BA0B3",
-    cursor: "pointer",
-  });
-
-  return (
-    <div
-      style={{
-        position: "relative",
-        width: "100%",
-        height: "100%",
-        minHeight: 560,
-        background: "#06070c",
-        borderRadius: 16,
-        overflow: "hidden",
-        fontFamily: "Inter, system-ui, sans-serif",
-      }}
-    >
-      <div style={{ position: "absolute", inset: 0 }}>
-        <canvas ref={canvasRef} style={{ display: "block", width: "100%", height: "100%", cursor: "grab" }} />
-      </div>
-
-      <div style={{ position: "absolute", top: 16, left: 16, display: "flex", gap: 8 }}>
-        {[2, 3].map((d) => (
-          <button key={d} onClick={() => setDim(d)} style={pillStyle(dim === d)}>
-            {d}D
-          </button>
-        ))}
-        <button onClick={() => reset(dim)} style={pillStyle(false)}>
-          reset
-        </button>
-        <button onClick={() => setRunning((r) => !r)} style={pillStyle(false)}>
-          {running ? "pause" : "resume"}
-        </button>
-        <button onClick={() => setShowGridLines((v) => !v)} style={pillStyle(showGridLines)}>
-          {showGridLines ? "grid lines" : "gravity flow"}
-        </button>
-        <span
-          title={readout.gpuError || ""}
-          style={{
-            alignSelf: "center",
-            display: "flex",
-            alignItems: "center",
-            gap: 6,
-            padding: "5px 10px",
-            borderRadius: 999,
-            fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-            fontSize: 10,
-            border: "1px solid rgba(255,255,255,0.12)",
-            background: "rgba(255,255,255,0.03)",
-            color: readout.gpuStatus && readout.gpuStatus.startsWith("GPU active") ? "#8BF0A8" : "#E0B15A",
-            cursor: readout.gpuError ? "help" : "default",
-          }}
-        >
-          <span
-            style={{
-              width: 7,
-              height: 7,
-              borderRadius: 999,
-              background: readout.gpuStatus && readout.gpuStatus.startsWith("GPU active") ? "#4ADE80" : readout.gpuStatus === "initializing..." ? "#5A5F72" : "#E0B15A",
-              boxShadow: readout.gpuStatus && readout.gpuStatus.startsWith("GPU active") ? "0 0 6px #4ADE80" : "none",
-            }}
-          />
-          {readout.gpuStatus}
-          {readout.gpuError ? " (hover for reason)" : ""}
-        </span>
-        <span
-          style={{
-            alignSelf: "center",
-            fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-            fontSize: 10,
-            color: "#4A4E5A",
-            marginLeft: 4,
-          }}
-        >
-          scroll to zoom · right-drag to orbit
-        </span>
-      </div>
-
-      <div
-        style={{
-          position: "absolute",
-          top: 16,
-          right: 16,
-          display: "flex",
-          gap: 12,
-          alignItems: "center",
-          fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-          fontSize: 10,
-          color: "#5A5F72",
-        }}
-      >
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FF7A45", boxShadow: "0 0 6px #FF7A45" }} />
-          repell
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#3DDCFF", boxShadow: "0 0 6px #3DDCFF" }} />
-          attract
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#EDEFF5", boxShadow: "0 0 6px #EDEFF5" }} />
-          matter
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#5A5F72" }} />
-          spark
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FFE9A8", boxShadow: "0 0 10px #FFE9A8" }} />
-          photon
-        </span>
-        <span style={{ display: "flex", alignItems: "center", gap: 5 }}>
-          <span style={{ width: 8, height: 8, borderRadius: 999, background: "#FFE9CE", boxShadow: "0 0 10px #FFE9CE" }} />
-          seed
-        </span>
-      </div>
-
-      <div
-        style={{
-          position: "absolute",
-          bottom: 14,
-          right: 16,
-          textAlign: "right",
-          fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-          fontSize: 11,
-          color: "#7B8093",
-          lineHeight: 1.7,
-        }}
-      >
-        <div>t = {readout.tick}</div>
-        <div>a(t) = {readout.factor}</div>
-        <div>
-          grid = {readout.gridNodes} · total = {readout.nodes} · ring = {readout.ring}
-        </div>
-        {readout.frameBreakdown && <div>{readout.frameBreakdown}</div>}
-        {readout.gpuTiming && <div style={{ color: "#4A4E5A" }}>{readout.gpuTiming}</div>}
-        <div style={{ color: "#4A4E5A" }}>
-          random repell/attract/neutral per ray · matter annihilates → photons → pair-produces back
-        </div>
-      </div>
-    </div>
-  );
-}
\ No newline at end of file

From 581003d8a2241e063363919ec90fcb5e2aca5dc7 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Thu, 13 Aug 2026 10:21:17 +0200
Subject: [PATCH 34/47] Bookkeeping, and writing the first sections for the
 physics booklet

---
 .../2026.RayCalculiAndPhysics/index.tsx       | 149 ------------------
 1 file changed, 149 deletions(-)
 delete mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx

diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
deleted file mode 100644
index 64a9cc3..0000000
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/index.tsx
+++ /dev/null
@@ -1,149 +0,0 @@
-import Post, {
-  Arc, BlueprintIcons16, BlueprintIcons20, BR, JetBrainsMono, PaperProps, Section,
-  useCounter,
-} from "../../../lib/post/Post";
-import { RAY_CALCULI_AND_PHYSICS } from "../../references";
-import { bySide, Graph } from "./discrete";
-import { Law } from "./law";
-import { lineGroups } from "./lines";
-import { Model } from "./model";
-import { asGroup, MODELS } from "./models";
-import { Polarity } from "./physics";
-import { Models } from "./views";
-
-/**
- * Ray calculi and physics.
- *
- * The article is a list of arrangements and nothing else. Each one is a
- * `Model` (see `model.ts`): what is in the world, said once, and drawn every
- * way it can be read — run on a lattice, written down as a closed form, or
- * both side by side where both apply.
- *
- * Which means there is nothing to edit here. To change an arrangement, add
- * one, or change the order they are read in, edit `models.ts`; to change what
- * an arrangement MEANS, edit `discrete.ts` and `metric.tsx`, which are the
- * two readings, and which share their vocabulary through `lattice.ts` and
- * `physics.ts` so that neither can drift from the other by redefining a term.
- *
- * The one thing that is not an arrangement is `law.tsx`, which states the
- * whole model as an equation before any of them — and, more to the point,
- * says which of its constants are put in and which come out. It reads its
- * numbers from `gravity.ts` rather than restating them, so there is no second
- * copy to drift.
- */
-const RayCalculiAndPhysics = () => {
-  const referenceCounter = useCounter();
-
-  const paper: Omit<PaperProps, 'children'> = {
-    ...RAY_CALCULI_AND_PHYSICS.reference,
-    pdf: {
-      fonts: [JetBrainsMono, BlueprintIcons20, BlueprintIcons16],
-    },
-    Reference: (props: {}) => (<></>),
-    references: referenceCounter,
-  };
-
-  // The same strips either way along: `backwards` lays the run out last-state
-  // first, with the arrow AND every charge's heading turned round — which is
-  // how the creation rule is drawn, annihilation being run the other way.
-  const strips = (backwards = false) => lineGroups(2).map((group, i) => asGroup(
-    '',
-    group,
-    { ticks: 1, filmstrip: true, height: 60, density: false, backwards },
-  ));
-
-  const DISCRETE = strips(), BACKWARD = strips(true);
-
-  return <Post {...paper}>
-    <Arc head="Introduction">
-      <Section>
-        I should probably preface this by saying that I am not a physicist by training. So my writing will likely not inheret the same culture as you would see in say a typical physics paper. My hope is that these ideas are useful enough to forgive those transgressions.
-        <BR/>
-        So here goes.
-        <BR/>
-        Emergence. That's the topic at play here. The question is: "How do you recover gravity and electromagnetism from local interactions?". I personally wanted a discrete model of physics I could point to which had such properties, and so birthed this idea.
-        <BR/>
-        Specifically, the idea would be the universe's tendency to exhibit XOR behavior on several scales. This is at least how I came to this idea. Two separate examples would be magnetism, and charged matter. In both cases: Opposites attract, Sameness repells. Hence my naming it XOR.
-        <BR/>
-        The model is essentially this idea taken to an extreme. Let me introduce the discrete model first, which (for someone like me) is much easier to understand the *why* of the thing. In order to later introduce the continuous model.
-        <BR/>
-      </Section>
-      <Section head="The Discrete Model">
-        It comes down to three essential rules:
-        <BR/>
-        (1) Annihilation: When two opposite polarities meet, they annihilate, leaving a single neutral spatial point behind. 
-
-        <Models models={[DISCRETE[5]]}/>
-        
-        (2) Repulsion: When two identical polarities meet, they turn around.
-
-        <Models models={[DISCRETE[4]]}/>
-        
-        (3) Creation: A neutral point expands into two points with opposite polarity in all directions. 
-
-        <Models models={[BACKWARD[5]]}/>
-
-        Then the other permutations of the rules are just movement rules (like these two).
-      
-        <Models models={[DISCRETE[1]]}/>
-
-        With this setup, we get aggregate behavior of groups of the same polarities, turning away from each other.
-
-        <Models models={([
-            // [Polarity.Positive, Polarity.Negative],
-            [Polarity.Positive, Polarity.Positive],
-            [Polarity.Negative, Polarity.Negative],
-        ] as [Polarity, Polarity][]).map(([left, right], i): Model => ({
-          name: '',
-          note: '',
-          lattice: {
-            seed: () => Graph.blocks({ charge: bySide(left, right) }),
-            ticks: 15, height: 140, density: false,
-          },
-        }))}/>
-
-        And ones with opposite polarities annihilating each-other.
-
-        <Models models={([
-            [Polarity.Positive, Polarity.Negative],
-            // [Polarity.Positive, Polarity.Positive],
-            // [Polarity.Negative, Polarity.Negative],
-        ] as [Polarity, Polarity][]).map(([left, right], i): Model => ({
-          name: '',
-          note: '',
-          lattice: {
-            seed: () => Graph.blocks({ charge: bySide(left, right) }),
-            ticks: 5, height: 140, density: false,
-          },
-        }))}/>
-
-        Then an interesting thing happens when you alternate polarities (the phase not mattering for this result). You get attraction.
-
-        <Models models={([
-          [Polarity.Positive, Polarity.Negative],
-          [Polarity.Positive, Polarity.Positive],
-        ] as [Polarity, Polarity][]).map(([left, right], i): Model => ({
-          name: '',
-          note: '',
-          lattice: {
-            seed: () => Graph.emitters({ left, right, gap: 20, every: 1, spin: true }),
-            ticks: 22, height: 140,
-          },
-        }))}/>
-
-        In 2D/3D these would of course get a little more complicated, but we can ignore that for now, this is only to form a basis for the idea. Instead: Based on these rules we can start extrapolating, let's continue to the continuous model for that, and afterwards return to the discrete.
-      </Section>
-      <Section head="The Continuous Model">
-
-      </Section>
-    </Arc>
-    <Arc head="">
-      <Section head="">
-        <Law />
-        <Models models={MODELS} />
-      </Section>
-    </Arc>
-  </Post>;
-};
-
-export default RayCalculiAndPhysics;

From 5912458699f91065b4bbc7c4ed5873d2b6c02b00 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Thu, 13 Aug 2026 10:21:52 +0200
Subject: [PATCH 35/47] Bookkeeping, and writing the first sections for the
 physics booklet

---
 orbitmines.com/app/archive/[item]/page.tsx    |    1 -
 orbitmines.com/app/not-found.tsx              |   14 +-
 .../app/thumbnail/ThumbnailClient.tsx         |    2 +-
 orbitmines.com/next-env.d.ts                  |    2 +-
 orbitmines.com/src/@ether/UI/data/articles.ts |    6 -
 .../@orbitmines/js/react/IEventListener.tsx   |    9 +-
 .../@orbitmines/js/react/hooks/useHotkeys.ts  |    7 +-
 orbitmines.com/src/lib/post/Post.tsx          |  333 +-
 orbitmines.com/src/lib/post/Thumbnail.tsx     |   65 +
 orbitmines.com/src/lib/post/highlight.tsx     |   33 +
 orbitmines.com/src/lib/post/pdf.tsx           |  251 +
 orbitmines.com/src/routes/Archive.tsx         |    2 -
 orbitmines.com/src/routes/Minimap.tsx         |    2 +-
 orbitmines.com/src/routes/Physics.tsx         | 1013 +++-
 .../2026.RayCalculiAndPhysics/GraphCanvas.tsx |  214 +-
 .../2026.RayCalculiAndPhysics/discrete.ts     |   78 +
 .../2026.RayCalculiAndPhysics/field.ts        |   18 +-
 .../2026.RayCalculiAndPhysics/figures.tsx     |  119 +
 .../2026.RayCalculiAndPhysics/gravity.ts      |  182 +-
 .../archive/2026.RayCalculiAndPhysics/law.tsx |  317 +-
 .../2026.RayCalculiAndPhysics/magnet.ts       |   10 +-
 .../2026.RayCalculiAndPhysics/magnetism.tsx   |    2 +-
 .../2026.RayCalculiAndPhysics/metric.tsx      |   12 +-
 .../2026.RayCalculiAndPhysics/model.ts        |   11 +
 .../2026.RayCalculiAndPhysics/models.ts       |    2 +-
 .../2026.RayCalculiAndPhysics/regimes.ts      |   16 +-
 .../2026.RayCalculiAndPhysics/tests/README.md |    4 +-
 .../tests/accumulate.ts                       |    4 +-
 .../tests/blocking.ts                         |    4 +-
 .../2026.RayCalculiAndPhysics/tests/budget.ts |    4 +-
 .../tests/combined.ts                         |    4 +-
 .../tests/coulomb.ts                          |   14 +-
 .../2026.RayCalculiAndPhysics/tests/dipole.ts |    2 +-
 .../tests/frontcheck.ts                       |    2 +-
 .../tests/genzel2.ts                          |    2 +-
 .../tests/magnets.ts                          |    4 +-
 .../tests/maxwell.ts                          |    6 +-
 .../2026.RayCalculiAndPhysics/tests/moment.ts |   12 +-
 .../tests/nopolarity.ts                       |   14 +-
 .../2026.RayCalculiAndPhysics/tests/poles.ts  |    2 +-
 .../2026.RayCalculiAndPhysics/tests/pulses.ts |    8 +-
 .../2026.RayCalculiAndPhysics/tests/scale.ts  |    4 +-
 .../tests/tradeoff.ts                         |    4 +-
 .../tests/which138.ts                         |   18 +-
 .../2026.RayCalculiAndPhysics/views.tsx       |    7 +-
 .../profiles/fadi-shawki/bibliography.ts      | 4789 +++++++++++++++++
 orbitmines.com/src/routes/references.tsx      |   18 -
 47 files changed, 7009 insertions(+), 638 deletions(-)
 create mode 100644 orbitmines.com/src/lib/post/Thumbnail.tsx
 create mode 100644 orbitmines.com/src/lib/post/highlight.tsx
 create mode 100644 orbitmines.com/src/lib/post/pdf.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/figures.tsx
 create mode 100644 orbitmines.com/src/routes/profiles/fadi-shawki/bibliography.ts

diff --git a/orbitmines.com/app/archive/[item]/page.tsx b/orbitmines.com/app/archive/[item]/page.tsx
index 6791dd9..9ecba5c 100644
--- a/orbitmines.com/app/archive/[item]/page.tsx
+++ b/orbitmines.com/app/archive/[item]/page.tsx
@@ -13,7 +13,6 @@ export const ITEM_SOURCES: Record<string, string> = {
   'on-orbits-equivalence-and-inconsistencies': 'src/routes/archive/2023.OnOrbits.tsx',
   'towards-a-universal-language': 'src/routes/archive/2025.TowardsAUniversalLanguage.tsx',
   'the-orbitmines-minecraft-server': 'src/routes/archive/2026.MinecraftArchive.tsx',
-  'ray-calculi-and-physics': 'src/routes/archive/2026.RayCalculiAndPhysics/index.tsx',
 };
 
 // Reads the reference object's `title` literal so the static <title> is owned
diff --git a/orbitmines.com/app/not-found.tsx b/orbitmines.com/app/not-found.tsx
index 9eae2d3..8b0fc12 100644
--- a/orbitmines.com/app/not-found.tsx
+++ b/orbitmines.com/app/not-found.tsx
@@ -1,10 +1,20 @@
 'use client';
 
-import EtherOrMinimap from '../src/@ether/UI/router/EtherOrMinimap';
+import React from 'react';
 
 // Cloudflare Pages routes unknown URLs to /index.html with 200 via the
 // _redirects rule, so this 404.html is rarely hit. We still wire it up to
 // the same SPA-routing component as a defensive fallback.
+//
+// Lazily, and that is not about this page. The App Router treats the root
+// not-found as part of every page's segment tree, so whatever this file names
+// statically is downloaded by every URL on the site — and what it names is the
+// minimap, which reaches the whole archive and, through it, three.js. An
+// article was fetching a WebGL renderer and a paper index in order to render a
+// 404 nobody was looking at. Behind a lazy import the fallback still works and
+// costs only the page that actually falls back to it.
+const EtherOrMinimap = React.lazy(() => import('../src/@ether/UI/router/EtherOrMinimap'));
+
 export default function NotFound() {
-  return <EtherOrMinimap />;
+  return <React.Suspense fallback={<></>}><EtherOrMinimap /></React.Suspense>;
 }
diff --git a/orbitmines.com/app/thumbnail/ThumbnailClient.tsx b/orbitmines.com/app/thumbnail/ThumbnailClient.tsx
index 2e9685f..69a2946 100644
--- a/orbitmines.com/app/thumbnail/ThumbnailClient.tsx
+++ b/orbitmines.com/app/thumbnail/ThumbnailClient.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import { ThumbnailPage } from '../../src/lib/post/Post';
+import { ThumbnailPage } from '../../src/lib/post/Thumbnail';
 
 export default function ThumbnailClient() {
   return <ThumbnailPage />;
diff --git a/orbitmines.com/next-env.d.ts b/orbitmines.com/next-env.d.ts
index 6ead643..1af4799 100644
--- a/orbitmines.com/next-env.d.ts
+++ b/orbitmines.com/next-env.d.ts
@@ -1,5 +1,5 @@
 /// <reference types="next" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
diff --git a/orbitmines.com/src/@ether/UI/data/articles.ts b/orbitmines.com/src/@ether/UI/data/articles.ts
index 76c3624..a356675 100644
--- a/orbitmines.com/src/@ether/UI/data/articles.ts
+++ b/orbitmines.com/src/@ether/UI/data/articles.ts
@@ -51,12 +51,6 @@ const ARTICLES: Article[] = [
     fileName: '2025.towards-a-universal-language',
     modified: '2025',
   },
-  {
-    slug: 'ray-calculi-and-physics',
-    title: '2026 — Notes on Ray Calculi & Physics',
-    fileName: '2026.ray-calculi-and-physics',
-    modified: '2026',
-  },
   {
     slug: '2025-09-ngi-grant-proposal',
     title: '2025.09 — NGI Grant Proposal (3)',
diff --git a/orbitmines.com/src/@orbitmines/js/react/IEventListener.tsx b/orbitmines.com/src/@orbitmines/js/react/IEventListener.tsx
index a5d0426..f430208 100755
--- a/orbitmines.com/src/@orbitmines/js/react/IEventListener.tsx
+++ b/orbitmines.com/src/@orbitmines/js/react/IEventListener.tsx
@@ -15,7 +15,14 @@ import React, {
   TouchEventHandler, TransitionEventHandler, UIEventHandler,
   useMemo, WheelEventHandler
 } from 'react';
-import _ from "lodash";
+// Three functions, one file each — see the note in `lib/post/Post.tsx`. This
+// one matters most: it is reached from the root layout, so whatever it names
+// is named by every page on the site.
+import entries from "lodash/entries";
+import mergeWith from "lodash/mergeWith";
+import pickBy from "lodash/pickBy";
+
+const _ = {entries, mergeWith, pickBy};
 
 export type IEventHandler<T = Element> = EventHandler<SyntheticEvent<T>>;
 
diff --git a/orbitmines.com/src/@orbitmines/js/react/hooks/useHotkeys.ts b/orbitmines.com/src/@orbitmines/js/react/hooks/useHotkeys.ts
index b5990ec..d006341 100755
--- a/orbitmines.com/src/@orbitmines/js/react/hooks/useHotkeys.ts
+++ b/orbitmines.com/src/@orbitmines/js/react/hooks/useHotkeys.ts
@@ -2,7 +2,12 @@ import IModule, {useModule} from "../IModule";
 import {HotkeyConfig} from "@blueprintjs/core/src/hooks/hotkeys/hotkeyConfig";
 import {useHotkeys as useBlueprintJSHotkeys} from '@blueprintjs/core';
 import {useState} from "react";
-import _ from "lodash";
+// Three functions, one file each — see the note in `lib/post/Post.tsx`.
+import compact from "lodash/compact";
+import isArray from "lodash/isArray";
+import uniq from "lodash/uniq";
+
+const _ = {compact, isArray, uniq};
 
 export type PressedKeys = string[];
 export type HotkeyEventOptions = { pressed: PressedKeys };
diff --git a/orbitmines.com/src/lib/post/Post.tsx b/orbitmines.com/src/lib/post/Post.tsx
index 6f41075..f60ec83 100644
--- a/orbitmines.com/src/lib/post/Post.tsx
+++ b/orbitmines.com/src/lib/post/Post.tsx
@@ -9,7 +9,22 @@ import ORGANIZATIONS, {
   TOrganization,
   TProfile
 } from "../organizations/ORGANIZATIONS";
-import _, {uniqueId} from "lodash";
+// Eight functions, imported one file each rather than as the whole library.
+// `import _ from "lodash"` is the entire seventy kilobytes of it, and nothing
+// downstream can tell which eight were meant; per-method imports are the same
+// eight and nothing else. Gathered back under `_` so that every call site below
+// still reads the way lodash reads everywhere else in this codebase.
+import compact from "lodash/compact";
+import entries from "lodash/entries";
+import flatMap from "lodash/flatMap";
+import fromPairs from "lodash/fromPairs";
+import isEmpty from "lodash/isEmpty";
+import isInteger from "lodash/isInteger";
+import isString from "lodash/isString";
+import uniqueId from "lodash/uniqueId";
+import values from "lodash/values";
+
+const _ = {compact, entries, flatMap, fromPairs, isEmpty, isInteger, isString, values};
 import {
   Button,
   Classes,
@@ -27,22 +42,18 @@ import {
 } from "@blueprintjs/core";
 import {toJpeg} from "html-to-image";
 import classNames from "classnames";
-import {PROFILES} from "../../routes/profiles/profiles";
-import {Highlight, Prism, themes} from "prism-react-renderer";
 import {IntentProps, Props} from "@blueprintjs/core/src/common";
 import {SVGIconProps} from "@blueprintjs/icons";
-import {CanvasContainer} from "../../routes/archive/2023.OnOrbits";
-import {BulkLoad, SingleLoad} from "@react-pdf/font";
+// Types only: `FontFamily` is the shape of a font declaration, and naming it
+// here must not drag @react-pdf into a page that is only being read.
+import type {BulkLoad, SingleLoad} from "@react-pdf/font";
 // Font URLs come from /public/fonts so they don't need a build-time loader.
 const _BlueprintIcons16 = '/fonts/blueprint-icons-16.ttf';
 const _BlueprintIcons20 = '/fonts/blueprint-icons-20.ttf';
 const JetBrainsMonoRegular = '/fonts/JetBrainsMono-Regular.ttf';
 const JetBrainsMonoSemiBold = '/fonts/JetBrainsMono-SemiBold.ttf';
 const JetBrainsMonoBold = '/fonts/JetBrainsMono-Bold.ttf';
-import {renderToStaticMarkup} from "react-dom/server";
-import {Document, Font, Image, Page, Path, PDFViewer, Svg, Link as PdfLink, Text, View} from "@react-pdf/renderer";
 import Book, {BookUtil, Navigation} from "./Book";
-import { log } from 'node:console';
 
 export const Profile = ({profile, children, head}: {profile: TProfile} & Children & { head?: any }) => {
   const location = useLocation();
@@ -160,206 +171,19 @@ export const Profile = ({profile, children, head}: {profile: TProfile} & Childre
   </div>
 }
 
-export const renderPdfRendererElement: DereferencedElementRenderer = (element: Element, parent: Element | undefined, initialProps: any) => {
-  const isTopLevel = parent === undefined;
-  const tagName = element.tagName.toLowerCase();
-
-  const isText = (initialProps.children?.length ?? 0) === 1 && _.isString(initialProps.children[0]);
-  const onlyContainsText = !_.isEmpty(initialProps.children) && React.Children.toArray(initialProps.children).every((child: any) => _.isString(child) || child.type === 'TEXT');
-
-  const styles =  _.transform(initialProps.style, (result, value, key: string) => {
-    key = _.camelCase(key);
-
-    if (_.isString(value) && ['auto'].includes(value))
-      return;
-
-    if (initialProps.center === "xs") {
-      result.textAlign = 'center';
-      result.width = '100%';
-      result.flexDirection = 'row';
-    }
-
-    if (['width'].includes(key)) {
-      // TODO ONLY IGNORE COMPUTED ONES
-      if (tagName !== 'img')
-        return;
-    }
-
-    if (['perspectiveOrigin', 'lineHeight', 'transformOrigin', 'flex'].includes(key))
-      return;
-    if (key === 'height' && tagName !== 'img')
-      return;
-
-    // ignore ad hoc styles
-    if (['fontStyle', 'textDecoration'].includes(key))
-      return;
-
-    if (['blockSize', 'inlineSize'].includes(key) || key.startsWith('webkit'))
-      return;
-
-    // Remove inferred lengths
-    if (['width', 'height', 'perspectiveOrigin'].includes(key) && _.isString(value) && /[0-9]+\.[0-9]+px/.test(value))
-      return;
-
-    result[key] = value;
-  }, {} as { [key: string]: string });
-
-  // if (key.includes('fontFamily'))
-  //   console.log(key, value);
-  //
-  // if ((key === 'maxHeight' || key === 'maxWidth') && value === 'none')
-  //   return false;
-
-  const renderChildren = () => initialProps.children?.map((child: string | ReactNode, index: number) => _.isString(child)
-      // @ts-ignore
-      ? (isText ? child : <Text key={index}>{child}</Text>)
-      : <Fragment key={index}>{child}</Fragment>
-  ) ?? undefined;
-
-  const props = {
-    ...initialProps,
-    style: styles,
-    tagName,
-
-
-    // TODO: BORDERS ARE GREEN FOR SOME REASON?
-
-    // Wraps children in text in order to inline
-    // @ts-ignore
-    children: onlyContainsText ? <Text>{renderChildren()}</Text> : renderChildren()
-  };
-
-  if (isTopLevel) {
-    // @ts-ignore
-    return <Document>
-      {/* @ts-ignore*/}
-      <Page wrap size="A4" dpi={150} {...{
-        ...props,
-        style: {
-          ...props.style,
-          paddingBottom: '40',
-          backgroundColor: '#1c2127'
-        }
-      }} />
-    </Document>
-  } else if (['img'].includes(tagName)) {
-    // @ts-ignore
-    // return <Image {...props} />
-    // } else if (['span'].includes(tagName)) {
-    //     // @ts-ignore
-    //     return <View {...props} />
-
-    const src = initialProps.src as string | undefined;
-    if (!src) {
-      // @ts-ignore
-      return <View />
-    }
-    const resolvedSrc = (src.startsWith('http://') || src.startsWith('https://') || src.startsWith('data:'))
-      ? src
-      : `${window.location.origin}${src.startsWith('/') ? '' : '/'}${src}`;
-    // react-pdf only supports PNG, JPG, TIFF — skip SVGs and other unsupported formats
-    if (resolvedSrc.startsWith('data:image/')) {
-      if (!(resolvedSrc.startsWith('data:image/png') || resolvedSrc.startsWith('data:image/jpeg') || resolvedSrc.startsWith('data:image/tiff'))) {
-        // @ts-ignore
-        return <View />
-      }
-    } else {
-      const ext = resolvedSrc.split(/[?#]/)[0].split('.').pop()?.toLowerCase() ?? '';
-      if (!['png', 'jpg', 'jpeg', 'tiff', 'tif'].includes(ext)) {
-        // Try PNG fallback for SVG images (react-pdf doesn't support SVG in Image)
-        if (ext === 'svg') {
-          const pngSrc = resolvedSrc.replace(/\.svg(\?|#|$)/, '.png$1');
-          // @ts-ignore
-          return <Image {...props} src={pngSrc} />
-        }
-        // @ts-ignore
-        return <View />
-      }
-    }
-    // @ts-ignore
-    return <Image {...props} src={resolvedSrc} />
-  } else if (['canvas'].includes(tagName)) {
-    if (props.style.backgroundImage.startsWith('url(')) {
-      const url = props.style.backgroundImage.replace(/^url\("/, '').replace(/"\)$/, '');
-      return <Image {...props} style={{...props.style, width: '992px'}} src={url} /> // TODO FIX
-    }
-
-    return <View {...props} />
-  } else if (['svg'].includes(tagName)) {
-    // @ts-ignore
-    return <Svg {...props} />
-  } else if (['path'].includes(tagName)) {
-    // @ts-ignore
-    return <Path {...props} />
-  } else if (['a'].includes(tagName)) {
-    // @ts-ignore
-    return <PdfLink {...props} />
-  } else if (isText || (tagName === 'span' && styles.display === 'inline')) {
-    // @ts-ignore
-    return <Text {...props} />
-  } else if (['span'].includes(tagName)) {
-    // @ts-ignore
-    return <View {...props} />
-  } else {
-    // console.log(props)
-    // @ts-ignore
-    return <View {...props} />
-  }
-  // @ts-ignore
-  // return <View></View>
-}
-
 export type PdfProps = {
   fonts?: FontFamily[]
 };
 
-export const registerFont = (font: FontFamily) => {
-  Font.register(font);
-
-  // React-pdf has poor support for deviations from family name, just split the family configs so:
-  // 'JetBrainsMono, monospace' -> 'JetBrainsMono', 'monospace', 'JetBrainsMono, monospace'
-  font.family.split(', ').forEach((family: string) => {
-    Font.register({
-      ...font,
-      family
-    })
-  })
-}
-
-export const ExportablePaper = (paper: PaperProps) => {
-  const [dereferenced, setDereferenced] = useState<JSX.Element | undefined>();
-  const renderElement = useCallback(renderPdfRendererElement, []);
-
-  let generate;
-  try {
-    const [params] = useSearchParams();
-
-    generate = params.get('generate');
-  } catch (e) {
-    generate = 'pdf';
-  }
-
-  const { pdf } = paper;
-
-  pdf.fonts?.forEach(registerFont);
-
-  const content = <MemoryRouter initialEntries={['/?generate=pdf']}>
-    <PaperContent {...paper}/>
-  </MemoryRouter>;
-
-  if (!dereferenced || generate === 'dereferenced_html')
-    return <DereferenceHtml
-        onDereference={setDereferenced}
-        renderElement={renderElement}
-        element={content}
-    />;
-
-  // console.log(renderToStaticMarkup(dereferenced))
-
-  return  <PDFViewer height={1754} width={1240}>
-    {dereferenced}
-  </PDFViewer>;
-};
+/**
+ * The same paper as a PDF — loaded only when one is asked for.
+ *
+ * `pdf.tsx` pulls in @react-pdf's layout engine and a second React renderer,
+ * which together are megabytes that a reader who is only reading never runs.
+ * Behind a lazy import they are fetched by the one path that reaches them,
+ * `?generate=pdf`, and a paper page costs nothing for having the option.
+ */
+const ExportablePaper = React.lazy(() => import('./pdf'));
 
 export type Attributes = { [key: string]: string };
 
@@ -426,31 +250,6 @@ export const dereferenceHtmlElement = (
   });
 }
 
-export type DereferenceHtmlProps = {
-  onDereference: (html: JSX.Element | undefined) => void
-  renderElement?: DereferencedElementRenderer
-  element: JSX.Element
-};
-
-export const DereferenceHtml = (props: DereferenceHtmlProps) => {
-  const {
-    element,
-    onDereference,
-    renderElement
-  } = props;
-
-  const ref = useRef<any>();
-
-  // More clean would be to walk the React tree, but just serializing and parsing to html makes our lives a lot easier,
-  // and is sufficient for now.
-  const html = renderToStaticMarkup(element);
-
-  useEffect(() => {
-    onDereference(dereferenceHtmlElement(ref.current, undefined, renderElement));
-  }, []);
-
-  return <div ref={ref} dangerouslySetInnerHTML={{__html: html}}></div>;
-}
 
 export type Styles = { [key: string]: string };
 
@@ -774,25 +573,16 @@ export function renderable<T extends ReactNode>(value: T, _default: (value: T) =
 
 export type Predicate<T> = (value: T, index: number, array: T[]) => unknown;
 
+// The colouring lives in `highlight.tsx` so that the tokenizer and its grammars
+// are fetched by the first code block drawn rather than by every paper. Until
+// it arrives the code is shown as it is, which is the same text in the same
+// place — so nothing moves when the colour lands on it.
+const Highlighted = React.lazy(() => import("./highlight"));
+
 export const highlight = (code: string) => (
-    // @ts-ignore
-    <Highlight prism={Prism} theme={themes.dracula} code={code} language="typescript">
-      {({className, style, tokens, getLineProps, getTokenProps}) => (
-          <>
-            {tokens.map((line, i) => {
-              const lp = getLineProps({line}) as any;
-              return (
-                <div key={i} className={lp.className} style={lp.style}>
-                  {line.map((token, ti) => {
-                    const tp = getTokenProps({token}) as any;
-                    return <span key={ti} className={tp.className} style={tp.style}>{tp.children}</span>;
-                  })}
-                </div>
-              );
-            })}
-          </>
-      )}
-    </Highlight>
+    <React.Suspense fallback={<>{code}</>}>
+      <Highlighted code={code} />
+    </React.Suspense>
 )
 
 export type CodeBlockProps = {
@@ -1668,56 +1458,15 @@ export const PaperView = (paper: PaperProps) => {
     generate = 'pdf';
   }
 
+  // Nothing to show while the renderer is on its way: what follows it is a
+  // blank page being measured, not a page, and a spinner in its place would
+  // only be a second thing to look at before the first one appears.
   if (generate === 'pdf')
-    return <ExportablePaper {...paper} />
+    return <React.Suspense fallback={<></>}><ExportablePaper {...paper} /></React.Suspense>
 
   return <Browser paper={paper}/>;
 };
 
-export const ThumbnailPage = () => {
-  const [params] = useSearchParams();
-
-  const title = params.get('title') ?? 'OrbitMines - Stream';
-  const subtitle = params.get('subtitle') ?? '';
-  const date = params.get('date') ?? new Date().toISOString().split('T')[0];
-
-  const referenceCounter = useCounter();
-
-  const paper: Omit<PaperProps, 'children'> = {
-    title,
-    subtitle,
-    date,
-    pdf: {
-      fonts: [JetBrainsMono, BlueprintIcons20, BlueprintIcons16],
-    },
-    organizations: [ORGANIZATIONS.orbitmines_research],
-    authors: [{
-      ...PROFILES.fadi_shawki,
-      external: PROFILES.fadi_shawki.external?.filter((profile) => PLATFORMS.includes(profile.organization.key))
-    }],
-    draft: false,
-    Reference: (props: {}) => (<></>),
-    references: referenceCounter,
-    header: <CanvasContainer style={{height: '140px', paddingBottom: 0}}>
-      <canvas
-        style={{
-          width: '100%',
-          height: '100%',
-          backgroundImage: `url('/archive/on-orbits-equivalence-and-inconsistencies/images/header.png')`,
-          backgroundPosition: 'center center',
-          backgroundRepeat: 'no-repeat'
-        }}
-      />
-    </CanvasContainer>
-  }
-
-  return <div>
-    <PaperThumbnail {...paper}>
-      <></>
-    </PaperThumbnail>
-  </div>
-}
-
 export const PaperThumbnail = (
   {size, header, ...props}: PaperProps & { size?: { width: number, height: number } }
 ) => {
diff --git a/orbitmines.com/src/lib/post/Thumbnail.tsx b/orbitmines.com/src/lib/post/Thumbnail.tsx
new file mode 100644
index 0000000..79a7a51
--- /dev/null
+++ b/orbitmines.com/src/lib/post/Thumbnail.tsx
@@ -0,0 +1,65 @@
+import {useSearchParams} from "react-router-dom";
+
+import ORGANIZATIONS, {PLATFORMS} from "../organizations/ORGANIZATIONS";
+import {PROFILES} from "../../routes/profiles/profiles";
+import {CanvasContainer} from "../../routes/archive/2023.OnOrbits";
+import {
+  BlueprintIcons16, BlueprintIcons20, JetBrainsMono, PaperProps, PaperThumbnail, useCounter,
+} from "./Post";
+
+/**
+ * The social-card page — `/thumbnail`, rendered to an image and never read.
+ *
+ * It lives here rather than in `Post.tsx` for one reason: its header is a
+ * `CanvasContainer`, and that is three.js, react-three-fiber and drei — a
+ * three-megabyte dependency reached by exactly this one page. Named inside
+ * `Post.tsx` it was named by every paper that imports `Post`, which is all of
+ * them, and each of them downloaded a WebGL renderer to draw an article.
+ *
+ * Nothing about the page changed in moving it. What changed is who pays for it.
+ */
+export const ThumbnailPage = () => {
+  const [params] = useSearchParams();
+
+  const title = params.get('title') ?? 'OrbitMines - Stream';
+  const subtitle = params.get('subtitle') ?? '';
+  const date = params.get('date') ?? new Date().toISOString().split('T')[0];
+
+  const referenceCounter = useCounter();
+
+  const paper: Omit<PaperProps, 'children'> = {
+    title,
+    subtitle,
+    date,
+    pdf: {
+      fonts: [JetBrainsMono, BlueprintIcons20, BlueprintIcons16],
+    },
+    organizations: [ORGANIZATIONS.orbitmines_research],
+    authors: [{
+      ...PROFILES.fadi_shawki,
+      external: PROFILES.fadi_shawki.external?.filter((profile) => PLATFORMS.includes(profile.organization.key))
+    }],
+    draft: false,
+    Reference: (props: {}) => (<></>),
+    references: referenceCounter,
+    header: <CanvasContainer style={{height: '140px', paddingBottom: 0}}>
+      <canvas
+        style={{
+          width: '100%',
+          height: '100%',
+          backgroundImage: `url('/archive/on-orbits-equivalence-and-inconsistencies/images/header.png')`,
+          backgroundPosition: 'center center',
+          backgroundRepeat: 'no-repeat'
+        }}
+      />
+    </CanvasContainer>
+  }
+
+  return <div>
+    <PaperThumbnail {...paper}>
+      <></>
+    </PaperThumbnail>
+  </div>
+}
+
+export default ThumbnailPage;
diff --git a/orbitmines.com/src/lib/post/highlight.tsx b/orbitmines.com/src/lib/post/highlight.tsx
new file mode 100644
index 0000000..0c30d60
--- /dev/null
+++ b/orbitmines.com/src/lib/post/highlight.tsx
@@ -0,0 +1,33 @@
+import {Highlight, Prism, themes} from "prism-react-renderer";
+
+/**
+ * A code block, coloured — and the only thing on the site that needs a parser.
+ *
+ * `prism-react-renderer` ships the tokenizer and its grammars, some eighty
+ * kilobytes, and most papers here have no code in them at all. `Post` loads
+ * this module from the first block that is actually drawn (see `highlight`),
+ * so a page without code never asks for it and a page with code shows the
+ * source unstyled for the moment it takes to arrive.
+ */
+const Highlighted = ({code}: {code: string}) => (
+  // @ts-ignore
+  <Highlight prism={Prism} theme={themes.dracula} code={code} language="typescript">
+    {({className, style, tokens, getLineProps, getTokenProps}) => (
+      <>
+        {tokens.map((line, i) => {
+          const lp = getLineProps({line}) as any;
+          return (
+            <div key={i} className={lp.className} style={lp.style}>
+              {line.map((token, ti) => {
+                const tp = getTokenProps({token}) as any;
+                return <span key={ti} className={tp.className} style={tp.style}>{tp.children}</span>;
+              })}
+            </div>
+          );
+        })}
+      </>
+    )}
+  </Highlight>
+);
+
+export default Highlighted;
diff --git a/orbitmines.com/src/lib/post/pdf.tsx b/orbitmines.com/src/lib/post/pdf.tsx
new file mode 100644
index 0000000..9e79acf
--- /dev/null
+++ b/orbitmines.com/src/lib/post/pdf.tsx
@@ -0,0 +1,251 @@
+import React, {Fragment, ReactNode, useCallback, useEffect, useRef, useState} from "react";
+import {MemoryRouter, useSearchParams} from "react-router-dom";
+import _ from "lodash";
+import {renderToStaticMarkup} from "react-dom/server";
+import {Document, Font, Image, Page, Path, PDFViewer, Svg, Link as PdfLink, Text, View} from "@react-pdf/renderer";
+
+import {
+  DereferencedElementRenderer, dereferenceHtmlElement, FontFamily, PaperContent, PaperProps,
+} from "./Post";
+
+/**
+ * A paper as a PDF, and everything that only a PDF needs.
+ *
+ * Which is the whole reason this is a file rather than four more functions in
+ * `Post.tsx`. `@react-pdf/renderer` carries its own layout engine, its own font
+ * machinery and a table of glyph widths for every standard face; `react-dom/server`
+ * is a second renderer beside the one already running. Together they are the
+ * larger part of what a paper page used to download — and no reader ever runs
+ * either of them: they are reached only through `?generate=pdf`.
+ *
+ * So `Post` loads this module when someone asks for a PDF and not before — see
+ * `PaperView` — and the split is along the one seam that matters, which is what
+ * imports react-pdf. The dereferencing helpers that turn a rendered page into
+ * plain styles and attributes stay in `Post.tsx`, because they are about HTML
+ * rather than about print.
+ */
+
+export const renderPdfRendererElement: DereferencedElementRenderer = (element: Element, parent: Element | undefined, initialProps: any) => {
+  const isTopLevel = parent === undefined;
+  const tagName = element.tagName.toLowerCase();
+
+  const isText = (initialProps.children?.length ?? 0) === 1 && _.isString(initialProps.children[0]);
+  const onlyContainsText = !_.isEmpty(initialProps.children) && React.Children.toArray(initialProps.children).every((child: any) => _.isString(child) || child.type === 'TEXT');
+
+  const styles =  _.transform(initialProps.style, (result, value, key: string) => {
+    key = _.camelCase(key);
+
+    if (_.isString(value) && ['auto'].includes(value))
+      return;
+
+    if (initialProps.center === "xs") {
+      result.textAlign = 'center';
+      result.width = '100%';
+      result.flexDirection = 'row';
+    }
+
+    if (['width'].includes(key)) {
+      // TODO ONLY IGNORE COMPUTED ONES
+      if (tagName !== 'img')
+        return;
+    }
+
+    if (['perspectiveOrigin', 'lineHeight', 'transformOrigin', 'flex'].includes(key))
+      return;
+    if (key === 'height' && tagName !== 'img')
+      return;
+
+    // ignore ad hoc styles
+    if (['fontStyle', 'textDecoration'].includes(key))
+      return;
+
+    if (['blockSize', 'inlineSize'].includes(key) || key.startsWith('webkit'))
+      return;
+
+    // Remove inferred lengths
+    if (['width', 'height', 'perspectiveOrigin'].includes(key) && _.isString(value) && /[0-9]+\.[0-9]+px/.test(value))
+      return;
+
+    result[key] = value;
+  }, {} as { [key: string]: string });
+
+  // if (key.includes('fontFamily'))
+  //   console.log(key, value);
+  //
+  // if ((key === 'maxHeight' || key === 'maxWidth') && value === 'none')
+  //   return false;
+
+  const renderChildren = () => initialProps.children?.map((child: string | ReactNode, index: number) => _.isString(child)
+      // @ts-ignore
+      ? (isText ? child : <Text key={index}>{child}</Text>)
+      : <Fragment key={index}>{child}</Fragment>
+  ) ?? undefined;
+
+  const props = {
+    ...initialProps,
+    style: styles,
+    tagName,
+
+
+    // TODO: BORDERS ARE GREEN FOR SOME REASON?
+
+    // Wraps children in text in order to inline
+    // @ts-ignore
+    children: onlyContainsText ? <Text>{renderChildren()}</Text> : renderChildren()
+  };
+
+  if (isTopLevel) {
+    // @ts-ignore
+    return <Document>
+      {/* @ts-ignore*/}
+      <Page wrap size="A4" dpi={150} {...{
+        ...props,
+        style: {
+          ...props.style,
+          paddingBottom: '40',
+          backgroundColor: '#1c2127'
+        }
+      }} />
+    </Document>
+  } else if (['img'].includes(tagName)) {
+    // @ts-ignore
+    // return <Image {...props} />
+    // } else if (['span'].includes(tagName)) {
+    //     // @ts-ignore
+    //     return <View {...props} />
+
+    const src = initialProps.src as string | undefined;
+    if (!src) {
+      // @ts-ignore
+      return <View />
+    }
+    const resolvedSrc = (src.startsWith('http://') || src.startsWith('https://') || src.startsWith('data:'))
+      ? src
+      : `${window.location.origin}${src.startsWith('/') ? '' : '/'}${src}`;
+    // react-pdf only supports PNG, JPG, TIFF — skip SVGs and other unsupported formats
+    if (resolvedSrc.startsWith('data:image/')) {
+      if (!(resolvedSrc.startsWith('data:image/png') || resolvedSrc.startsWith('data:image/jpeg') || resolvedSrc.startsWith('data:image/tiff'))) {
+        // @ts-ignore
+        return <View />
+      }
+    } else {
+      const ext = resolvedSrc.split(/[?#]/)[0].split('.').pop()?.toLowerCase() ?? '';
+      if (!['png', 'jpg', 'jpeg', 'tiff', 'tif'].includes(ext)) {
+        // Try PNG fallback for SVG images (react-pdf doesn't support SVG in Image)
+        if (ext === 'svg') {
+          const pngSrc = resolvedSrc.replace(/\.svg(\?|#|$)/, '.png$1');
+          // @ts-ignore
+          return <Image {...props} src={pngSrc} />
+        }
+        // @ts-ignore
+        return <View />
+      }
+    }
+    // @ts-ignore
+    return <Image {...props} src={resolvedSrc} />
+  } else if (['canvas'].includes(tagName)) {
+    if (props.style.backgroundImage.startsWith('url(')) {
+      const url = props.style.backgroundImage.replace(/^url\("/, '').replace(/"\)$/, '');
+      return <Image {...props} style={{...props.style, width: '992px'}} src={url} /> // TODO FIX
+    }
+
+    return <View {...props} />
+  } else if (['svg'].includes(tagName)) {
+    // @ts-ignore
+    return <Svg {...props} />
+  } else if (['path'].includes(tagName)) {
+    // @ts-ignore
+    return <Path {...props} />
+  } else if (['a'].includes(tagName)) {
+    // @ts-ignore
+    return <PdfLink {...props} />
+  } else if (isText || (tagName === 'span' && styles.display === 'inline')) {
+    // @ts-ignore
+    return <Text {...props} />
+  } else if (['span'].includes(tagName)) {
+    // @ts-ignore
+    return <View {...props} />
+  } else {
+    // console.log(props)
+    // @ts-ignore
+    return <View {...props} />
+  }
+  // @ts-ignore
+  // return <View></View>
+}
+
+export const registerFont = (font: FontFamily) => {
+  Font.register(font);
+
+  // React-pdf has poor support for deviations from family name, just split the family configs so:
+  // 'JetBrainsMono, monospace' -> 'JetBrainsMono', 'monospace', 'JetBrainsMono, monospace'
+  font.family.split(', ').forEach((family: string) => {
+    Font.register({
+      ...font,
+      family
+    })
+  })
+}
+
+export type DereferenceHtmlProps = {
+  onDereference: (html: JSX.Element | undefined) => void
+  renderElement?: DereferencedElementRenderer
+  element: JSX.Element
+};
+
+export const DereferenceHtml = (props: DereferenceHtmlProps) => {
+  const {
+    element,
+    onDereference,
+    renderElement
+  } = props;
+
+  const ref = useRef<any>();
+
+  // More clean would be to walk the React tree, but just serializing and parsing to html makes our lives a lot easier,
+  // and is sufficient for now.
+  const html = renderToStaticMarkup(element);
+
+  useEffect(() => {
+    onDereference(dereferenceHtmlElement(ref.current, undefined, renderElement));
+  }, []);
+
+  return <div ref={ref} dangerouslySetInnerHTML={{__html: html}}></div>;
+}
+
+export const ExportablePaper = (paper: PaperProps) => {
+  const [dereferenced, setDereferenced] = useState<JSX.Element | undefined>();
+  const renderElement = useCallback(renderPdfRendererElement, []);
+
+  let generate;
+  try {
+    const [params] = useSearchParams();
+
+    generate = params.get('generate');
+  } catch (e) {
+    generate = 'pdf';
+  }
+
+  const { pdf } = paper;
+
+  pdf.fonts?.forEach(registerFont);
+
+  const content = <MemoryRouter initialEntries={['/?generate=pdf']}>
+    <PaperContent {...paper}/>
+  </MemoryRouter>;
+
+  if (!dereferenced || generate === 'dereferenced_html')
+    return <DereferenceHtml
+        onDereference={setDereferenced}
+        renderElement={renderElement}
+        element={content}
+    />;
+
+  // console.log(renderToStaticMarkup(dereferenced))
+
+  return  <PDFViewer height={1754} width={1240}>
+    {dereferenced}
+  </PDFViewer>;
+};
+
+export default ExportablePaper;
diff --git a/orbitmines.com/src/routes/Archive.tsx b/orbitmines.com/src/routes/Archive.tsx
index a76fa77..e3f211a 100644
--- a/orbitmines.com/src/routes/Archive.tsx
+++ b/orbitmines.com/src/routes/Archive.tsx
@@ -6,7 +6,6 @@ import OnIntelligibility from "./archive/2022.OnIntelligibility";
 import OnOrbits from "./archive/2023.OnOrbits";
 import TowardsAUniversalLanguage from "./archive/2025.TowardsAUniversalLanguage";
 import MinecraftArchive from "./archive/2026.MinecraftArchive";
-import RayCalculiAndPhysics from './archive/2026.RayCalculiAndPhysics';
 
 const ITEMS: { [key: string]: any } = {
     '2024-02-orbitmines-as-a-game-project': _2024_02_OrbitMines_as_a_Game_Project,
@@ -14,7 +13,6 @@ const ITEMS: { [key: string]: any } = {
     'on-orbits-equivalence-and-inconsistencies': OnOrbits,
     'towards-a-universal-language': TowardsAUniversalLanguage,
     'the-orbitmines-minecraft-server': MinecraftArchive,
-    'ray-calculi-and-physics': RayCalculiAndPhysics,
 }
 
 const Archive = () => {
diff --git a/orbitmines.com/src/routes/Minimap.tsx b/orbitmines.com/src/routes/Minimap.tsx
index cbac2e7..143b604 100644
--- a/orbitmines.com/src/routes/Minimap.tsx
+++ b/orbitmines.com/src/routes/Minimap.tsx
@@ -6,7 +6,7 @@ import {Author, Col, CustomIcon, Layer, pageStyles, Reference, Row} from "../lib
 import {PROFILES} from "./profiles/profiles";
 import {Button} from "@blueprintjs/core";
 import {download, DownloadButton, LoginButton, os} from "../@orbitmines/ether/Ether";
-import {ON_INTELLIGIBILITY, ON_ORBITS, _2024_02_ORBITMINES_AS_A_GAME_PROJECT, TOWARDS_A_UNIVERSAL_LANGUAGE, ETHERS_ALMANAC, ORBITMINES_MINECRAFT_ARCHIVE, RAY_CALCULI_AND_PHYSICS, PHYSICS} from "./references";
+import {ON_INTELLIGIBILITY, ON_ORBITS, _2024_02_ORBITMINES_AS_A_GAME_PROJECT, TOWARDS_A_UNIVERSAL_LANGUAGE, ETHERS_ALMANAC, ORBITMINES_MINECRAFT_ARCHIVE, PHYSICS} from "./references";
 
 
 const Minimap = () => {
diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index 88d3293..aa08c10 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -6,19 +6,44 @@ import Post, {
 import { PHYSICS } from "./references";
 
 import { bySide, Graph } from "./archive/2026.RayCalculiAndPhysics/discrete";
+import { Echoes } from "./archive/2026.RayCalculiAndPhysics/echoes";
+import { Beam, Sheet } from "./archive/2026.RayCalculiAndPhysics/figures";
 import {
-  Because, Eq, F, Frac, K, Law, MagnetismLaw, Paren, Step, Sup, V,
-  WithoutPolarity,
+  B, Bar, Because, CLOCK, CONSTANTS, Eq, F, Frac, FULL, Hat, Head, K, LAW,
+  MADE_FROM, MEETINGS, MET, METRIC, Paren, REACH, Rows, SPACE, Step, Sub, Sup, V,
 } from "./archive/2026.RayCalculiAndPhysics/law";
 import { lineGroups } from "./archive/2026.RayCalculiAndPhysics/lines";
 import { Model } from "./archive/2026.RayCalculiAndPhysics/model";
-import { ALONE_FOR, asGroup, MODELS, weighed } from "./archive/2026.RayCalculiAndPhysics/models";
+import { asGroup, MODELS, weighed } from "./archive/2026.RayCalculiAndPhysics/models";
 import { PACE, Polarity } from "./archive/2026.RayCalculiAndPhysics/physics";
+import {
+  Apart, Discs, HighRedshift, HighZCurves, HighZDiscs, Rotation, Split,
+} from "./archive/2026.RayCalculiAndPhysics/rotation";
+import { Overlay, Routes, Seam, Shadows } from "./archive/2026.RayCalculiAndPhysics/shadow";
 import { Models } from "./archive/2026.RayCalculiAndPhysics/views";
 import {
-  BarField, Ceiling, Fields, Kinds, Lopsided, Pairs,
+  BarField, Ceiling, Fields, Kinds, Ladder, Lopsided, Pairs,
 } from "./archive/2026.RayCalculiAndPhysics/magnetism";
 
+/** The colour the rest of the article uses for an aside inside a set line. */
+const FAINT = '#6c7080';
+
+/**
+ * A paragraph that has anything but text in it.
+ *
+ * `Paragraph` in `Post.tsx` groups consecutive STRINGS into one block and
+ * gives anything else a centred row of its own, so a sentence with an <Eq>
+ * symbol or an emphasis in it would arrive centred and on its own line. This
+ * is the same left-aligned span the sections above already write out by hand,
+ * named once instead of repeated.
+ */
+const Para = ({ children }: { children: React.ReactNode }) =>
+  <span style={{ textAlign: 'left', width: '100%' }}>{children}</span>;
+
+/** Pick arrangements out of `models.ts` by name, in the order asked for. */
+const named = (...names: string[]): Model[] =>
+  names.map(n => MODELS.find(m => m.name === n)).filter(Boolean) as Model[];
+
 /**
  * OrbitMines: Notes on Physics — a booklet rather than a paper.
  *
@@ -43,6 +68,19 @@ import {
  *
  * The subsections inside each arc are not written yet; the arcs are the
  * skeleton they will hang from.
+ *
+ * WHERE THE PARTS LIVE. Everything drawn here comes out of
+ * `archive/2026.RayCalculiAndPhysics/`, which used to be an article of its own
+ * and is now only the model this booklet is written from. Nothing in this file
+ * decides what an arrangement IS: a `Model` (see `model.ts`) says what is in a
+ * world once, and is drawn every way it can be read — run on a lattice, written
+ * down as a closed form, or both side by side. To change an arrangement, add
+ * one, or reorder them, edit `models.ts`; to change what an arrangement MEANS,
+ * edit `discrete.ts` and `metric.tsx`, the two readings, which share their
+ * vocabulary through `lattice.ts` and `physics.ts` so neither can drift from the
+ * other by redefining a term. `law.tsx` states the model as an equation and says
+ * which of its constants are put in and which come out, reading its numbers from
+ * `gravity.ts` rather than restating them, so there is no second copy to drift.
  */
 const Physics = () => {
   const referenceCounter = useCounter();
@@ -72,14 +110,22 @@ const Physics = () => {
   // The same strips either way along: `backwards` lays the run out last-state
   // first, with the arrow AND every charge's heading turned round — which is
   // how the creation rule is drawn, annihilation being run the other way.
-  const strips = (backwards = false) => lineGroups(2).map((group) => asGroup(
+  const strips = (backwards = false, polarities = true) => lineGroups(2).map((group) => asGroup(
     '',
     group,
-    { ticks: 1, filmstrip: true, height: 60, density: false, backwards },
+    { ticks: 1, filmstrip: true, height: 60, density: false, backwards, polarities },
   ));
 
   const DISCRETE = strips(), BACKWARD = strips(true);
 
+  // The same runs again, with the charges NOT drawn as charges. Gravity is the
+  // arc that has no polarity in it — the two kinds are introduced later, and
+  // the whole claim of the magnetism arc is that adding them to these very
+  // runs is what makes the difference. Drawn amber and cyan from the start,
+  // the pictures answer that before it has been asked, so in this arc every
+  // ray is the plain grey of space.
+  const PLAIN = strips(false, false), PLAIN_BACK = strips(true, false);
+
   return <Post {...book}>
 
     <Arc head="2026. ">
@@ -100,15 +146,15 @@ const Physics = () => {
         <BR/>
         (G/1) Annihilation: When two rays meet, they annihilate, leaving a single neutral spatial point behind.
 
-        <Models models={[DISCRETE[5]]}/>
+        <Models models={[PLAIN[5]]}/>
 
         (G/2) Creation: On all axis, a neutral point expands into two points with oppositely pointing rays.
 
-        <Models models={[BACKWARD[5]]}/>
+        <Models models={[PLAIN_BACK[5]]}/>
 
         Then the other permutations of the rules are just movement rules (like these two).
 
-        <Models models={[DISCRETE[3]]}/>
+        <Models models={[PLAIN[3]]}/>
 
         This is only to form a basis for the idea. In 2D/3D and when we want to recover magnetism these would of course get a little more complicated, but we can ignore that for now. 2D/3D is more easily understood as the continous model for starters. And this theory of gravity can be (mostly) understood separately from the theory of magnetism; later we'll unify them.
         
@@ -128,7 +174,9 @@ const Physics = () => {
 
         Let's first imagine something which travels at the speed of light. We can imagine that as something which travels every tick of the universe.
         <BR/>
-        TODO
+
+        <Beam />
+
         <BR/>
         So whatever the maximum speed is any universe we can imagine, it is limited by this property. Something which travels every tick.
 
@@ -137,39 +185,41 @@ const Physics = () => {
         So since speed of light is 'c' in physics, we'll need some way to reference any kind of physics concept in its discrete form. Let's mark them by just putting a line on top of any variable when we want to reference its discrete form. (This will likely create some ambiguities - but at least in the context of this project that will be the case.)
 
         <Eq>
-          <K>c̄</K> = <Frac over={<><K>S̅T̅E̅P̅</K> = 1</>} under={<><K>T̅I̅C̅K̅</K> = 1</>} /> =
-          1 <F>(x̅/t̅)</F>
+          <K><Bar>c</Bar></K> = <Frac over={<><K><Bar>STEP</Bar></K> = 1</>} under={<><K><Bar>TICK</Bar></K> = 1</>} /> =
+          1 <F>(<Bar>x</Bar>/<Bar>t</Bar>)</F>
         </Eq>
 
-        These variables couldn't really be anything other than this, but this elementary thing is pretty important. Speed of light is just phrased as a single lattice step per tick. These don't need any units since we're not comparing them to anything else, but if one really wanted, you could use the x̅/t̅. x̅ meaning distance. t̅ meaning a light tick.
+        <span style={{textAlign: 'left', width: '100%'}}>These variables couldn't really be anything other than this, but this elementary thing is pretty important. Speed of light is just phrased as a single lattice step per tick. These don't need any units since we're not comparing them to anything else, but if one really wanted, you could use the <Bar>x</Bar>/<Bar>t</Bar>. <Bar>x</Bar> meaning distance. <Bar>t</Bar> meaning a light tick.</span>
 
         <BR/>
 
         Next up we have dimensions, now the trouble with this, is that generally we could have a fraction in this number. So one would only be able to make a judgement on this number locally, or regionally. Instead these following variables will only be judged locally always (the current position). We denote that with a 'l.' in front of the variable. Unless otherwise mentioned the local variable has a default, which is the same variable name without the 'l.'.
 
         <Eq>
-          <K>l.D̅</K> = number of dimensions
+          <K>l.<Bar>D</Bar></K> = number of dimensions
           <span style={{ padding: '0 1.6em' }} />
-          <K>D̅</K> = 3
+          <K><Bar>D</Bar></K> = 3
         </Eq>
 
-        <span style={{textAlign: 'left', width: '100%'}}>You're allowed to change the <K>D̅</K> ofc. But unless otherwise specified variables have these default values.</span>
+        <span style={{textAlign: 'left', width: '100%'}}>You're allowed to change the <K><Bar>D</Bar></K> ofc. But unless otherwise specified variables have these default values.</span>
 
         <BR/>
 
-        <span style={{textAlign: 'left', width: '100%'}}>There's one important piece of gravity that we'll discover and that is in order to reach the desired 1/R<Sup><K>D̅</K> - 1</Sup> of the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "inverse-square law", link: "https://en.wikipedia.org/wiki/Inverse-square_law"}}/>. It happens that as we'll discover in a moment, if we'd send out discrete pulses of our 'gravity-rays' (so the ones causing annihilation). That we can recover the intensity of gravity in a neat way based on the dimensionality of our space. This is our sheet. The sheet we pulse a beam towards. In order to cover our whole space, we'll be rotating this sheet in 1 more dimension than it's defined. Whenever there's a derived equation, you can click on it to see how it was derived! Try it!</span>
+        <span style={{textAlign: 'left', width: '100%'}}>There's one important piece of gravity that we'll discover and that is in order to reach the desired 1/R<Sup><K><Bar>D</Bar></K> - 1</Sup> of the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "inverse-square law", link: "https://en.wikipedia.org/wiki/Inverse-square_law"}}/>. It happens that as we'll discover in a moment, if we'd send out discrete pulses of our 'gravity-rays' (so the ones causing annihilation). That we can recover the intensity of gravity in a neat way based on the dimensionality of our space. This is our sheet. The sheet we pulse a beam towards. In order to cover our whole space, we'll be rotating this sheet in 1 more dimension than it's defined.</span>
+
+        <Sheet />
 
         <Eq derive={{
-          label: 'l.S̅H̅E̅E̅T̅',
+          label: 'l.SHEET',
           title: <>the sheet — what the inverse square asks for</>,
           body: <>
             <Because>(1) the thing we are trying to end up with</Because>
             <Step eq={<>
               intensity ∝
               <Frac over={<>1</>}
-                under={<><V>r̅</V><Sup><K>l.D̅</K> - 1</Sup></>} />
+                under={<><V><Bar>r</Bar></V><Sup><K>l.<Bar>D</Bar></K> - 1</Sup></>} />
               <span style={{ padding: '0 1.2em', color: '#6c7080' }}>
-                = 1/<V>r̅</V><Sup>2</Sup> where <K>l.D̅</K> = 3
+                = 1/<V><Bar>r</Bar></V><Sup>2</Sup> where <K>l.<Bar>D</Bar></K> = 3
               </span>
             </>}>
               This one is not derived — it is the target, the inverse-square law
@@ -181,14 +231,14 @@ const Physics = () => {
 
             <Because>(2) what a falloff can even be here, since nothing pushes</Because>
             <Step eq={<>
-              chance(<V>r̅</V>) =
-              <Frac over={<>what was let go of</>} under={<>shell(<V>r̅</V>)</>} />
+              chance(<V><Bar>r</Bar></V>) =
+              <Frac over={<>what was let go of</>} under={<>shell(<V><Bar>r</Bar></V>)</>} />
             </>}>
               There is no force in the rules — only rays that step and meet. So
               the only way something can weaken with distance is by being{' '}
               <i>spread thinner</i>: a source lets go of some charges, they step
-              outward a cell a tick (that is <K>c̄</K>), and after <V>r̅</V>{' '}
-              ticks they are somewhere on the shell at <V>r̅</V>. None is made
+              outward a cell a tick (that is <K><Bar>c</Bar></K>), and after <V><Bar>r</Bar></V>{' '}
+              ticks they are somewhere on the shell at <V><Bar>r</Bar></V>. None is made
               and none is destroyed on the way, so what is on that shell is what
               left, however far it has got. The chance a given cell out there is
               holding one is that count over the size of the shell.
@@ -196,26 +246,26 @@ const Physics = () => {
 
             <Because>(3) so the target is really a statement about what it spreads over</Because>
             <Step eq={<>
-              shell(<V>r̅</V>) = 4<V>π</V> <V>r̅</V><Sup><K>l.D̅</K> - 1</Sup>
+              shell(<V><Bar>r</Bar></V>) = 4<V>π</V> <V><Bar>r</Bar></V><Sup><K>l.<Bar>D</Bar></K> - 1</Sup>
               <span style={{ padding: '0 1.2em', color: '#6c7080' }}>
-                a surface: <K>l.D̅</K> - 1 dimensional
+                a surface: <K>l.<Bar>D</Bar></K> - 1 dimensional
               </span>
             </>}>
               Put (1) and (2) together and the demand is that a fixed count be
-              diluted by <V>r̅</V><Sup><K>l.D̅</K> - 1</Sup> — and a thing whose
-              size goes up by <V>r̅</V><Sup><V>n</V></Sup> when you scale it
-              by <V>r̅</V> is an <V>n</V> dimensional thing, because that is what
+              diluted by <V><Bar>r</Bar></V><Sup><K>l.<Bar>D</Bar></K> - 1</Sup> — and a thing whose
+              size goes up by <V><Bar>r</Bar></V><Sup><V>n</V></Sup> when you scale it
+              by <V><Bar>r</Bar></V> is an <V>n</V> dimensional thing, because that is what
               having a dimension <i>means</i>. So what the emission is spread
-              over has to be <K>l.D̅</K> - 1 dimensional: a surface, and the one
+              over has to be <K>l.<Bar>D</Bar></K> - 1 dimensional: a surface, and the one
               surrounding the source, or there are directions the pull never
-              reaches. In three dimensions that is 4π<V>r̅</V><Sup>2</Sup>.
+              reaches. In three dimensions that is 4π<V><Bar>r</Bar></V><Sup>2</Sup>.
             </Step>
 
             <Because>(4) and it has to get onto that surface by turning</Because>
             <Step eq={<>
-              emitted + 1 <F>(the turn)</F> = <K>l.D̅</K>
+              emitted + 1 <F>(the turn)</F> = <K>l.<Bar>D</Bar></K>
               <span style={{ padding: '0 1.2em' }} />
-              emitted = <K>l.D̅</K> - 1 = 2
+              emitted = <K>l.<Bar>D</Bar></K> - 1 = 2
             </>}>
               A source cannot pulse into a whole sphere at once — a pulse leaves
               along lattice directions, and the sphere is not a set of them. It
@@ -228,27 +278,27 @@ const Physics = () => {
 
             <Because>(5) not more, not less — both alternatives fail, differently</Because>
             <Step eq={<>
-              <K>l.D̅</K>: nothing left to turn
+              <K>l.<Bar>D</Bar></K>: nothing left to turn
               <span style={{ padding: '0 1.2em' }} />
-              <K>l.D̅</K> - 2: the sweep is a surface, not a space
+              <K>l.<Bar>D</Bar></K> - 2: the sweep is a surface, not a space
             </>}>
               Emit into all of space — every way out of the point, which is the
-              full 3<Sup><K>l.D̅</K></Sup> - 1 = 26 — and there is no dimension
+              full 3<Sup><K>l.<Bar>D</Bar></K></Sup> - 1 = 26 — and there is no dimension
               left for the turn to happen in; the sphere is covered by the pulse
               itself and never gets thinner in the right way. Emit into a line
               instead, two directions, and one turn sweeps a surface — a disc
               through the source, with the rest of the space untouched. Only{' '}
-              <K>l.D̅</K> - 1 both covers the space and needs the turn.
+              <K>l.<Bar>D</Bar></K> - 1 both covers the space and needs the turn.
             </Step>
 
             <Because>(6) so count the directions that lie in the sheet</Because>
             <Step eq={<>
-              <K>l.S̅H̅E̅E̅T̅</K> = 3<Sup><K>l.D̅</K> - 1</Sup> - 1 = 8
+              <K>l.<Bar>SHEET</Bar></K> = 3<Sup><K>l.<Bar>D</Bar></K> - 1</Sup> - 1 = 8
             </>}>
               Along any one axis a ray can go down it, up it, or not along it —
               three, and no more, because two steps in a tick is faster
-              than <K>c̄</K>. The axes do not constrain each other, so the
-              choices multiply: three of them over the <K>l.D̅</K> - 1 axes
+              than <K><Bar>c</Bar></K>. The axes do not constrain each other, so the
+              choices multiply: three of them over the <K>l.<Bar>D</Bar></K> - 1 axes
               lying in the sheet, less the one that is zero on all of them,
               which is standing still and is not a direction to leave in. In
               three dimensions that is the 3×3 around the point with its middle
@@ -259,16 +309,16 @@ const Physics = () => {
 
             <Because>(7) and reading it back the way a pulse actually runs</Because>
             <Step eq={<>
-              chance(<V>m</V>, <V>r̅</V>) =
-              <Frac over={<><V>m</V> · <K>l.S̅H̅E̅E̅T̅</K></>}
-                under={<>4<V>π</V> <V>r̅</V><Sup><K>l.D̅</K> - 1</Sup></>} />
+              chance(<V>m</V>, <V><Bar>r</Bar></V>) =
+              <Frac over={<><V>m</V> · <K>l.<Bar>SHEET</Bar></K></>}
+                under={<>4<V>π</V> <V><Bar>r</Bar></V><Sup><K>l.<Bar>D</Bar></K> - 1</Sup></>} />
               &nbsp;=&nbsp;
-              <Frac over={<>8<V>m</V></>} under={<>4<V>π</V> <V>r̅</V><Sup>2</Sup></>} />
+              <Frac over={<>8<V>m</V></>} under={<>4<V>π</V> <V><Bar>r</Bar></V><Sup>2</Sup></>} />
             </>}>
               Eight charges leave, the sheet they left in comes round as the
               source turns so that over a revolution the space around it has all
               been pulsed into, and those same eight are on the shell at{' '}
-              <V>r̅</V> a moment later. Eight over 4π<V>r̅</V><Sup>2</Sup>:{' '}
+              <V><Bar>r</Bar></V> a moment later. Eight over 4π<V><Bar>r</Bar></V><Sup>2</Sup>:{' '}
               <b>the inverse square, back out</b>, which it had better be — this
               step is the check, not the derivation.
             </Step>
@@ -280,26 +330,621 @@ const Physics = () => {
               eight is what a sheet in three dimensions has in it, and a sheet is
               what an inverse square asks for: <b>not the 26 and not the 2</b>.
               The argument never mentioned three, so it runs the same in any{' '}
-              <K>l.D̅</K> — sheet one dimension short of the space, count{' '}
-              3<Sup><K>l.D̅</K> - 1</Sup> - 1, diluted over the surface
+              <K>l.<Bar>D</Bar></K> — sheet one dimension short of the space, count{' '}
+              3<Sup><K>l.<Bar>D</Bar></K> - 1</Sup> - 1, diluted over the surface
               surrounding the source — and three is only where that comes out as
-              eight and an inverse <i>square</i>. And <K>l.D̅</K> is{' '}
+              eight and an inverse <i>square</i>. And <K>l.<Bar>D</Bar></K> is{' '}
               <i>local</i>, which is what the l. is for: it is the dimension
               where the pulsing is happening, not a number set once for the
               universe.
             </Step>
           </>,
         }}>
-          <K>l.S̅H̅E̅E̅T̅</K> = <>3<Sup><K>l.D̅</K> - 1</Sup> - 1</>
+          <K>l.<Bar>SHEET</Bar></K> = <>3<Sup><K>l.<Bar>D</Bar></K> - 1</Sup> - 1</>
+        </Eq>
+
+        Whenever there's a derived equation, you can click on it to see how it was derived! Try it!
+
+        <BR/>
+
+        Then the related number, all possible paths out of point (the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "degree", link: "https://en.wikipedia.org/wiki/Degree_(graph_theory)"}}/> assuming diagonals are included). 
+
+        <Eq>
+          <K>l.<Bar>DEG</Bar></K> = <>3<Sup><K>l.<Bar>D</Bar></K></Sup> - 1</>
         </Eq>
 
+        It turns out that this is all the machinary we need to derive gravitational laws that approximate <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "Newtonian gravity", link: "https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation"}}/> and <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "General relativity", link: "https://en.wikipedia.org/wiki/General_relativity"}}/> and go beyond them.
+
+        <BR/>
+
+        Let's dive into the continuous model to show you how.
+
         <Section head="The Continuous Model">
 
         </Section>
         <Section head="The Discrete Model">
         </Section>
         <Section head="TODO">
-          <Law />
+
+          <Head>the rule, and there is only one</Head>
+
+          Everything up to here has been about one source letting go of things. What is still missing is what happens when two of them arrive at the same place, and that turns out to be the whole of gravity.
+
+          <BR/>
+
+          <Para>
+            So here is the rule, before it gets dressed up. Two charges arriving at the same point annihilate if they are opposite — both points go, and whatever was behind each is joined onto whatever was behind the other. If they are alike, they leave along each other's headings instead. That is it. <b>Nothing is pushed.</b> There is no force anywhere in the rules, and I want to keep saying that because everything below is what its absence comes to.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What there is instead is <i>less space than there was</i>. Two points became one, so everything behind them got closer together without anything having moved. Gravity here is that piece of bookkeeping, done often enough to notice. A body's momentum is then just its share of the meetings it took part in — <K>BIAS</K> of a step each, and <K>BIAS</K> is one meeting out of the <K><Bar>DEG</Bar></K> ways there were to go.
+          </Para>
+
+          <Eq derive={LAW}
+            note="the momentum a body gains is BIAS times the annihilations it took part in, and what one is worth depends on where it happened">
+            <Frac over={<>d</>} under={<>d<V>t</V></>} />
+            ( <V>γ</V> <V>m</V><Sub>a</Sub> <B>v</B><Sub>a</Sub> )
+            &nbsp;=&nbsp; <K>BIAS</K> · <span style={{ fontSize: '1.3em' }}>Σ</span>
+            <Sub>b ≠ a</Sub> &nbsp;<V>S</V><Sub>ab</Sub> <Hat>r</Hat><Sub>ab</Sub>
+            &nbsp;· carry
+          </Eq>
+
+          <Para>
+            Click it. The whole point of writing the model this way is that a page of counted constants and a page of six fitted ones look identical once they are typeset, and the only way to tell them apart is to be able to ask any line where it came from.
+          </Para>
+
+          <Head>and what mass turns out to be</Head>
+
+          <Para>
+            Mass is not a property something has in this model. It is <i>how often it lets go</i> — one pulse every <V>X</V> ticks, with <V>X</V> = 1/<V>m</V>, and nothing lets go more than once a tick because nothing does anything more than once a tick.
+          </Para>
+
+          <Eq derive={CLOCK}
+            note="a heavier thing pulses more often, and nothing pulses more than once a tick">
+            <V>X</V> = 1/<V>m</V>
+            <span style={{ padding: '0 1.4em', color: FAINT }}>ticks between pulses</span>
+            <V>X</V>·<V>c</V> = <V>G</V> · <V>λ</V><Sub>Compton</Sub>
+          </Eq>
+
+          <Para>
+            Two things fall out of that and neither was aimed at. The first is the <b>equivalence principle</b>: what bends a body is the <i>fraction</i> of its own paths that got biased, and its count of paths is its mass, so the mass divides straight back out and everything falls the same way. It was never put in.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The second is that "period = 1/mass" in lattice units <i>is</i> the Compton relation, at every mass, across twenty orders. The ratio comes out at 0.062351 exactly for an electron, a proton, an iron atom and a neodymium atom alike, because <V>m</V><Sub>P</Sub><V>l</V><Sub>P</Sub> = ħ/<V>c</V> — and that number is the gravitational constant in the lattice's own units, which by the bar convention above is <K><Bar>G</Bar></K>, the discrete form of <V>G</V>.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And there is a ceiling: one pulse a tick is the fastest anything can be, so there is a heaviest elementary thing, <K><Bar>G</Bar></K>·<V>m</V><Sub>Planck</Sub> ≈ 1.36 µg. Anything heavier is <i>many</i> emitters, which is what matter is. At the ceiling the beat is one tick, and that tick comes out at 5.391246·10<Sup>−44</Sup> s against a Planck time of 5.391246·10<Sup>−44</Sup> s. Ratio 1.000000000. <b>The lattice's tick is the Planck time</b>, and it is an identity rather than a coincidence — <K><Bar>G</Bar></K> cancels out of it.
+          </Para>
+
+          <Head>what one body does to another</Head>
+
+          <Para>
+            Now put two of them in a world. Body <V>a</V> is spraying <V>m</V><Sub>a</Sub><K>l.<Bar>SHEET</Bar></K> charges a tick over shells that grow as <V>r</V><Sup>2</Sup>; so is body <V>b</V>; and the pull is the rate at which one of each finds the same cell.
+          </Para>
+
+          <Eq derive={MEETINGS}>
+            <V>S</V><Sub>ab</Sub> &nbsp;=&nbsp; <K>BITE</K> ·
+            <Paren><Frac over={<K>SHEET</K>} under={<>4<V>π</V></>} /></Paren><Sup>2</Sup>
+            · share · screen · <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> ·
+            met(<V>R</V>)
+          </Eq>
+
+          <Para>
+            The only awkward piece is met(<V>R</V>), which is that rate integrated along the whole line between them rather than evaluated at one point — and it collapses. One inverse square, times a bracket that goes to one.
+          </Para>
+
+          <Eq derive={MET} note="one inverse square, times one bracket that goes to one">
+            met(<V>R</V>) &nbsp;=&nbsp;
+            <Frac over={<>4</>} under={<><V>c R</V><Sup>2</Sup></>} />
+            <Paren>
+              1 &nbsp;+&nbsp; <Frac over={<V>c</V>} under={<V>R</V>} /> ln
+              <Frac over={<><V>R</V> − <V>c</V></>} under={<V>c</V>} />
+            </Paren>
+          </Eq>
+
+          <Para>
+            Which leaves the constants, and this is the part I actually care about. <K>BIAS</K> is one way out of <K><Bar>DEG</Bar></K>. <V>c</V> is a step over a tick. And <V>G</V> is not measured, chosen or fitted — it is written entirely in counts we already have.
+          </Para>
+
+          <Eq derive={CONSTANTS}>
+            <K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>DEG</K>} /> =
+            <Frac over={<>1</>} under={<>26</>} />
+            <span style={{ padding: '0 1.6em' }} />
+            <V>c</V> = <Frac over={<K>HALF</K>} under={<K>GRAIN</K>} />
+          </Eq>
+
+          <Eq derive={FULL}
+            note={<>the bracket is 1.08 at a core of half a lattice step and Mercury's
+              separation — and 1 + 10⁻³⁸ at the grain a real lattice would have</>}>
+            <Frac over={<>d<V>p</V></>} under={<>d<V>t</V></>} /> &nbsp;=&nbsp;
+            <V>G</V> ·
+            <Frac over={<><V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub></>}
+              under={<><V>R</V><Sup>2</Sup></>} />
+            <Paren>
+              1 &nbsp;+&nbsp; <Frac over={<V>c</V>} under={<V>R</V>} /> ln
+              <Frac over={<><V>R</V> − <V>c</V></>} under={<V>c</V>} />
+            </Paren>
+            <Hat>r</Hat>
+            <span style={{ padding: '0 1.4em' }} />
+            <V>G</V> =
+            <Frac over={<><K>SHEET</K><Sup>2</Sup></>}
+              under={<>4<V>π</V><Sup>2</Sup> <V>c</V> <K>DEG</K></>} />
+          </Eq>
+
+          <Para>
+            <b>Newton, times a bracket that goes to one.</b> The whole of the departure from Newton at a distance is that bracket, and its size is the ratio of a source's core to the separation — so it is 1.08 for a source half a lattice step across at Mercury's distance, and 1 + 10<Sup>−38</Sup> at the grain a real lattice would have. There is nothing left in the expression to tune.
+          </Para>
+
+          <BR/>
+
+          And the honest way to check that is to run it rather than to admire it. Same rules, no orbital mechanics anywhere, only bodies letting go of charges and charges meeting.
+
+          <Models models={named('the Sun and Mercury', 'the inner solar system', 'the Earth and the Moon')} />
+
+          <Para>
+            Three panels each: Newton on the left, general relativity in the middle, this model on the right. Everything here runs at a tenth to a third of the speed of light — an orbit worth watching has to be tens of cells across and come round inside a few hundred ticks, and 2π<V>R</V>/<V>T</V> at those numbers is what it is — so the two classical answers are visibly different curves and there is something to land between.
+          </Para>
+
+          <BR/>
+
+          And the same rule with three bodies in it, which is where I stopped expecting anything and got the known closed solutions back anyway.
+
+          <Models models={named(
+            'three bodies: figure eight',
+            'three bodies: Lagrange, equilateral',
+            'three bodies: Euler, collinear',
+          )} />
+
+          <Head>and the same count read a second way</Head>
+
+          <Para>
+            Everything above reads a meeting as a <i>direction</i> — which way the leaning went. But an annihilation is also a statement about <i>how much space a point holds</i>, and nobody had read it that way. That second reading is the metric, and it is the other five sixths of Mercury.
+          </Para>
+
+          <Eq derive={METRIC}
+            note="the same count read as a size rather than a direction — which is a metric, and is the other five sixths">
+            <V>A</V>(<V>s</V>) =
+            <Paren><Frac over={<>1 − <V>s</V></>} under={<>1 + <V>s</V></>} /></Paren><Sup>2</Sup>
+            <span style={{ padding: '0 1.4em' }} />
+            <V>B</V>(<V>s</V>) = (1 + <V>s</V>)<Sup>4</Sup>
+            <span style={{ padding: '0 1.4em' }} />
+            <V>s</V> = <Frac over={<V>u</V>} under={<>2</>} />
+          </Eq>
+
+          <Para>
+            The bit that makes it work is that <b>edges point both ways</b>. A node that has taken <V>n</V> annihilations has <K><Bar>DEG</Bar></K> + <V>n</V> ways out — and those same extra edges point <i>into</i> it, so a charge nearby is (<K><Bar>DEG</Bar></K>+<V>n</V>)/<K><Bar>DEG</Bar></K> times likelier to arrive there. More arrivals, more annihilations, more folding, more arrivals. The increment is proportional to what is already there, which is what makes it compound: d<V>u</V> = d<V>u</V><Sub>0</Sub>(1 + <V>u</V>), which integrates to an exponential with nothing chosen. <V>A</V> = <V>e</V><Sup>−2<V>u</V></Sup>, <V>B</V> = <V>e</V><Sup>+2<V>u</V></Sup>, <V>A</V>·<V>B</V> = 1, so β = γ = 1 both fall out.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <V>B</V> needs one thing the pull did not, though, and it is worth being explicit about. The pull only ever asked what a meeting does to a <i>lean</i>. <V>B</V> asks what it does to the <i>amount</i> of space, and that is three rewrites and nothing else:
+          </Para>
+
+          <Eq derive={SPACE}
+            note="making a charge makes space; a meeting takes it back; a move carries it">
+            neutral &nbsp;→&nbsp; + &nbsp;−
+            <span style={{ padding: '0 1.4em', color: FAINT }}>+1</span>
+            + &nbsp;− &nbsp;→&nbsp; neutral
+            <span style={{ padding: '0 1.4em', color: FAINT }}>−1</span>
+            move
+            <span style={{ padding: '0 0.8em', color: FAINT }}>0</span>
+          </Eq>
+
+          <Eq derive={MADE_FROM}
+            note="a point source settles to a potential — if something carries the surplus away, and that is the whole difficulty">
+            <V>δ</V>(<V>r</V>) = <Frac over={<V>S</V>}
+              under={<>4<V>π D r</V></>} /> = 3<V>u</V>
+            <span style={{ padding: '0 1.6em' }} />
+            ⇒ <V>u</V> = <Frac over={<V>Gm</V>}
+              under={<><V>r c</V><Sup>2</Sup></>} />
+          </Eq>
+
+          <Para>
+            A body emitting <V>m</V><K>l.<Bar>SHEET</Bar></K> charges a tick is a <b>point source of space</b> — at the body, not spread through its field, which matters because a source spread as 1/<V>r</V><Sup>2</Sup> gives a logarithm and a point gives a potential. I should say plainly that this is the shakiest step on the page: the identification ∫<V>δ</V> = 3<V>u</V> is a choice, and the transport constant behind it wants a hopping charge to keep its heading about 85% of the time, which the lattice may simply do and nothing here derives.
+          </Para>
+
+          <Head>Mercury, and light</Head>
+
+          <Para>
+            Mercury is where this gets a number rather than a story. The <i>lean</i> alone — the force law, with the count read as a direction — advances the perihelion by <b>+1.66°</b> an orbit where 6π<V>GM</V>/<V>c</V><Sup>2</Sup><V>a</V>(1−<V>e</V><Sup>2</Sup>) is +9.93°. That is the right sign and <b>exactly a sixth</b> of the size, and it is a sixth to a part in a hundred on Venus, Earth and Mars too, and on a second panel drawn at a different scale.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Read the same annihilations a second time as a <i>size</i> and the same orbit advances <b>+3.41° an orbit</b> — 1.01 of the measured advance — and a ray grazing the Sun bends by the whole 4<V>GM</V>/<V>bc</V><Sup>2</Sup> rather than half of it. Measured through the model's own dynamics rather than off the metric, the five orbits come to <b>6.05, 6.08, 6.07, 6.11 and 6.22 sixths</b>, and the ellipse comes back at −0.00% on every one. Nothing is added to get the other five sixths: <V>A</V> and <V>B</V> carry the same <V>u</V> with the same coefficient, which is the statement that a point's lean and a point's thickness are one event seen twice.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            That is also the sharpest thing here to be wrong about, since it is what fixes γ<Sub>PPN</Sub> = 1 — and Cassini has that to 2·10<Sup>−5</Sup>.
+          </Para>
+
+          <Head>so is that general relativity</Head>
+
+          <Para>
+            No, and I think the difference is the interesting part. Nothing is borrowed any more, but what came out is not Einstein's metric — it is the <i>exponential</i> one, and the two agree exactly where general relativity has been tested and part company where it has not.
+          </Para>
+
+          <Rows of={[
+            [<>where they agree</>,
+              <>β = γ = 1, so every first-post-Newtonian test is identical: the
+                perihelion advance, light's deflection, Shapiro delay, the Cassini
+                bound on γ. <V>A</V> agrees to <V>O</V>(<V>u</V><Sup>3</Sup>).</>],
+            [<>where they differ</>,
+              <><V>B</V> parts company at <V>O</V>(<V>u</V><Sup>2</Sup>), which shows in
+                the perihelion at <V>O</V>(<V>u</V>) — 10<Sup>−6</Sup> arcseconds a
+                century at Mercury, and 0.13% to 0.56% in these panels, which run at
+                exaggerated depth so the effect is visible at all.</>],
+            [<>and where they part outright</>,
+              <><V>e</V><Sup>−2<V>u</V></Sup> never reaches nought, so <b>no
+                horizons</b>; the shadow is <b>4.6% larger</b> at the same mass; and a
+                neutron star shows about two thirds of its mass, which is outside any
+                equation of state and is the one place the model is probably just
+                wrong.</>],
+          ]} />
+
+          <Para>
+            So the claim is not "general relativity, rederived". It is: <b>a metric theory built from counting, agreeing with general relativity on everything general relativity has passed, and disagreeing where nobody has looked closely yet.</b> That is a better position than agreement would be, because it can be shot at.
+          </Para>
+
+          <Head>what a black hole is here</Head>
+
+          <Para>
+            √<V>A</V> = 0 would need 1 + <V>u</V> = ∞, so <V>n</V> = ∞ — a node with <i>infinitely many ways out</i> — and each annihilation adds one while a finite mass sends finitely many charges. At what general relativity calls the horizon the node has 6.4 extra ways out per <K><Bar>DEG</Bar></K>: a lot, and not infinity. Light leaves, redshifted by <V>e</V><Sup>2</Sup> = 7.4. <b>Nothing is ever cut off.</b> Things get arbitrarily red and arbitrarily slow and never quite vanish.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What makes something dark, then, is not the metric but <i>screening</i>: a body's charges annihilate against its own field on the way out, so only a skin of thickness <V>λ</V> ever reaches the outside and a body looks lighter than it is. Ordinary matter is transparent — <V>R</V>/<V>λ</V> is 10<Sup>−8</Sup> for the Earth and 3·10<Sup>−5</Sup> for the Sun, so nothing anywhere the model was tested moves. Push it to the lattice's own ceiling of one emitter a cell and <V>R</V>/<V>R</V><Sub>s</Sub> = 0.7219 at <i>every</i> size, flat from 10<Sup>5</Sup> to 10<Sup>30</Sup> cells: <b>the densest thing the lattice permits sits inside its own Schwarzschild radius</b>, and inside its own photon sphere, so it casts a shadow of the full size.
+          </Para>
+
+          <Eq derive={METRIC}
+            note="the area does not shrink to nothing — it has a narrowest point, and inside that it grows again">
+            <Frac over={<>d</>} under={<>d<V>r</V></>} />
+            <Paren><V>r e</V><Sup><V>GM</V>/<V>r</V></Sup></Paren> = 0
+            <span style={{ padding: '0 1.2em', color: FAINT }}>at</span>
+            <V>r</V> = <V>GM</V>/<V>c</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>r</V><Sub>areal</Sub> = <V>e</V>·<V>GM</V>/<V>c</V><Sup>2</Sup> =
+            1.3591 <V>R</V><Sub>s</Sub>
+          </Eq>
+
+          <Para>
+            <b>The area has a throat.</b> Inside it the area grows again without bound, so the geometry is a narrow neck opening into something vast, at a ratio that is the same at every scale. A solar mass two cells across carries a node with 10<Sup>39</Sup> edges — two cells across and enormous at once, and those are one fact rather than two.
+          </Para>
+
+          <Eq derive={METRIC}
+            note="and this is the one number in the whole model that an instrument can settle now">
+            <V>b</V> = 2<V>e</V>·<V>GM</V>/<V>c</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>against</span>
+            3√3·<V>GM</V>/<V>c</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            1.0463
+          </Eq>
+
+          <Shadows />
+
+          <Para>
+            Same mass, same camera, same disc — the only difference between the two panels is <V>A</V> and <V>B</V>. Rays are traced backwards from the eye until they escape or run into the matter, which is the only thing that stops one here, there being no horizon to fall through. The solid ring is general relativity's critical impact parameter and the dashed one is this model's, both drawn on both panels.
+          </Para>
+
+          <Seam />
+
+          <Para>
+            Two panels ask the eye to carry a radius between them, which it is bad at. Cut down the middle instead — relativity left of the seam, the counted metric right of it, everything else identical — and the shadow's edge and the photon ring both <i>step</i> as they cross. A step is something the eye is very good at.
+          </Para>
+
+          <Overlay />
+
+          <Para>
+            And laid on top of each other rather than beside: amber and blue cancel to pale wherever the two agree, so what is left over is the difference. Nothing is exaggerated — it is the same 4.6% at its true size. Traced rather than derived, the two edges come out at 5.196153 and 5.436619 against closed forms of 5.196152 and 5.436564.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>Measure the mass from orbits and the shadow from imaging, and this predicts a constant mismatch between them.</b> It sits inside the Event Horizon Telescope's present ~10% systematic error and outside what it is aiming for, which makes it a near-term test rather than a philosophical one, and the only claim on this page an existing instrument can settle.
+          </Para>
+
+          <Routes />
+
+          <Para>
+            There are two ways to a dark object here — the spatial density above, or a boost on the emission that restores a genuine horizon — and I should say outright that <b>they cannot be told apart</b>. Both share the whole exterior down to the photon sphere, and nothing returns from inside a photon sphere carrying information. The third panel is the ungated boost, drawn not because the model says it but to show what being wrong would look like.
+          </Para>
+
+          <Echoes />
+
+          <Para>
+            The usual fallback is a ringdown: a surface reflects, so the wave trapped under the photon sphere should leak back out as late echoes. This page used to say that separates the two routes. <b>It does not.</b> The delay is the round trip at the coordinate speed of light, and with the surface at 1.96 <i>cells</i> a solar mass carries a factor <V>e</V><Sup>(9·10³⁷)</Sup> in it. The echoes never come back — not late, never. So the model does not predict echoes, and it would be wrong to advertise horizonlessness as though it did.
+          </Para>
+
+          <Head>how far it reaches</Head>
+
+          <Para>
+            Every source is putting charges everywhere, so any place holds a thin fog of everyone else's — and a body's charges annihilate against that fog on the way to wherever they were going. Beyond a mean free path, none of them arrive. So the pull is <i>Yukawa</i>, which nothing in it was designed to be.
+          </Para>
+
+          <Eq derive={REACH}
+            note="the pull is Yukawa, and its range is a fixed fraction of the horizon">
+            <V>S</V>(<V>a</V>,<V>b</V>) ∝
+            <Frac over={<>e<Sup>−<V>R</V>/<V>λ</V></Sup></>}
+              under={<><V>R</V><Sup>2</Sup></>} />
+            <span style={{ padding: '0 1.6em' }} />
+            <Frac over={<V>λ</V>} under={<><V>R</V><Sub>h</Sub></>} /> =
+            √<Paren><Frac over={<>8<V>π G</V></>}
+              under={<>3 <K>BITE</K>·share·<K>SHEET</K></>} /></Paren> = 0.361
+          </Eq>
+
+          <Para>
+            I liked this one a great deal and then had to take most of it back, so it is worth walking through. Getting the density to cancel — "gravity reaches a third of the way to the horizon in <i>any</i> universe this model describes" — used <V>ρ</V> = 3<V>H</V><Sup>2</Sup>/8π<V>G</V>. <b>That is Friedmann, and this model has no Friedmann equation.</b> What survives is <V>λ</V>/<V>R</V><Sub>h</Sub> = 0.361/√<V>Ω</V>, and the model has no dark matter and no dark energy, so the density doing the screening is the <i>baryon</i> one — <V>Ω</V> = 0.049, hence 1.63, hence gravity reaching half again past the horizon. The prediction does not become wrong. It becomes unfalsifiable, which here is the worse of the two.
+          </Para>
+
+          <Head>and then the cosmology, which I did not want</Head>
+
+          <Para>
+            The rules fix a cosmology whether or not one was wanted, because matter makes space and meetings unmake it and the net is what escapes. Asked for the <i>observed</i> <V>H</V>, the version where space is made throughout the bulk fails seven separate ways, and the fatal one is that the pairs which make the space <i>are</i> the fog that stops the gravity. One <V>Φ</V>, two jobs, opposite values, thirty-five orders apart.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The way out is to notice that "space is made in the bulk" was an assumption nobody argued for. Put the creation only where there is <i>no space yet</i>: a cell on the <b>frontier</b> has nothing on one side, so a charge emitted outward meets nothing ever and never gives its point back, and that point is new space. A charge emitted inward meets the bulk and annihilates. The interior makes none at all — which dissolves five of the seven at once, since all five were consequences of a bulk vacuum.
+          </Para>
+
+          <Eq derive={REACH}
+            note="one emission a cell a tick is the ceiling — so it is also the rate">
+            <Frac over={<>d<V>R</V></>} under={<>d<V>t</V></>} /> = 1
+            <span style={{ padding: '0 0.6em', color: FAINT }}>cell/tick</span> = <V>c</V>
+            <span style={{ padding: '0 1.4em', color: FAINT }}>⇒</span>
+            <V>R</V> = <V>ct</V>
+          </Eq>
+
+          <Para>
+            And then a Hubble law by pure kinematics: matter that left the origin at <V>t</V> = 0 and free-streams sits at <V>x</V> = <V>vt</V>, so any two of them separate at <V>r</V>/<V>t</V> and <b>every</b> observer inside sees <V>v</V> = <V>Hr</V> with <V>H</V> = 1/<V>t</V>. No metric expansion, no stretched wavelengths, no tired light — the redshift is ordinary Doppler. And the age is then <i>forced</i>, not fitted: <V>t</V> = 1/<V>H</V><Sub>0</Sub> exactly, which is 14.51 Gyr at <V>H</V><Sub>0</Sub> = 67.4 and 13.39 at 73.0, against a measured 13.80 ± 0.02. <b>The Hubble tension brackets it.</b> A model with no freedom to miss does not miss.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            In its own units the universe is 8.49·10<Sup>60</Sup> ticks old and 8.49·10<Sup>60</Sup> cells in radius — the same number, which is what <V>R</V> = <V>ct</V> means and is worth seeing written down.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>And then it fails the supernovae, which is the honest end of this section.</b> A coasting universe is <V>q</V><Sub>0</Sub> = 0 exactly, with no <V>Ω</V>, no <V>Λ</V> and no freedom anywhere; the measured value is −0.55 ± 0.05. The defence — that a supernova's absolute magnitude is a nuisance parameter, so a constant offset is free and only the <i>shape</i> counts — is a real one, so marginalise the offset away and look at what is left. The residual runs +0.072 mag at <V>z</V> = 0.02, through zero near 0.18, to −0.130 at <V>z</V> = 1: <b>0.061 mag rms and monotonic</b>, where Pantheon+ bins carry 0.02–0.03. And the shape of that residual — nearby too bright, distant too faint — is precisely the one the 1998 measurements found and named acceleration. The same construction, asked a second question, gets it wrong by the width of the discovery that started modern cosmology.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            There is worse, and it is structural rather than numerical. A charge arriving at an occupied cell has exactly two outcomes and no third — annihilate, or reverse — and both are extinction. A step is one cell and a heading is one of <K><Bar>DEG</Bar></K>, so there is no soft forward channel anywhere in the rules: <b>the lattice can dim light and it cannot redden it</b>, and by the same missing channel it cannot move energy between frequencies either. FIRAS has the microwave background as a blackbody to a part in 10<Sup>5</Sup>, and this model has no mechanism that would produce one <i>at any temperature</i>. No thermal history, no light elements, no acoustic peaks. That is not a small number coming out wrong; it is an absence.
+          </Para>
+
+          <Head>and whether any of that is dark matter</Head>
+
+          <Para>
+            Now the part I spent longest on and got wrong most often. Below is the Milky Way put through the model's own force law, summed directly over its baryons ring by ring and angle by angle — no shell theorem, no enclosed-mass shortcut, so nothing about what the outside does is assumed.
+          </Para>
+
+          <Rotation />
+
+          <Para>
+            It peaks at 193 km/s and falls to 104 by 30 kpc, against a curve Gaia measures at 229 at the Sun and 200 at 25. That is a shortfall in the pull of 52% at the Sun and 242% at 30 kpc. And <b>it is not this model's shortfall in particular</b>, which is the honest way to put it.
+          </Para>
+
+          <Apart />
+
+          <Para>
+            Two lines at 10<Sup>−7</Sup>, one at 10<Sup>−10</Sup>, and the discrepancy at 10<Sup>0</Sup>. <b>The entire difference between Newton, Einstein and this model is six orders below the thing all three of them miss.</b> Whatever dark matter is, no correction of that size was ever going to reach it — so read this panel as closing off the obvious direction, not as closing the question.
+          </Para>
+
+          <Split />
+
+          <Para>
+            One tempting escape closes here too. The exterior mass does <i>not</i> cancel — a disc is not a sphere — but it pulls <b>outward</b>, because the near arc of an exterior ring is closer than the far arc and wins the inverse square. It takes 27% off the pull at 2 kpc. So the missing gravity cannot come from the outside failing to cancel: the outside is already counted, already fails to cancel, and already subtracts.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            After that I stopped testing mechanisms one at a time, because they kept dying on the same number. Enumerate instead every dimensionless quantity the model can build at 20 kpc — <V>GM</V>/<V>rc</V><Sup>2</Sup> = 1.70·10<Sup>−7</Sup>, <V>v</V><Sup>2</Sup>/<V>c</V><Sup>2</Sup> = 5.39·10<Sup>−7</Sup>, <V>r</V>/<V>λ</V><Sub>reach</Sub> = 1.25·10<Sup>−5</Sup>, <V>r</V>/<V>ct</V><Sub>0</Sub> = 4.73·10<Sup>−6</Sup>, the lattice spacing at 10<Sup>−56</Sup> — and closing a gap of +195% needs an <V>O</V>(1) number. <b>Exactly one of the eight is anywhere near unity</b>, and it is <V>g·t</V><Sub>0</Sub>/<V>c</V> = 3.86·10<Sup>−2</Sup>. Which closes the whole family at once rather than one idea at a time, and is worth more than any of the individual tests.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And there is a theorem underneath, which I would rather have found earlier. Action and reaction gives <V>m</V><Sub>a</Sub><V>h</V>(<V>m</V><Sub>b</Sub>) = <V>m</V><Sub>b</Sub><V>h</V>(<V>m</V><Sub>a</Sub>); equivalence gives <V>F</V> = <V>m</V><Sub>a</Sub>·<V>h</V>(<V>m</V><Sub>b</Sub>); together they force <V>F</V> ∝ <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> exactly, with no freedom at all. So <b>no two-body force law can give √<V>M</V></b>, which is what a Tully–Fisher slope of 3.85 ± 0.09 demands — not a modified one, not a screened one, not one with a different geometry. Every mechanism I built put the nonlinearity in the <i>source</i>, and each found a different way of being told it could not.
+          </Para>
+
+          <Head>what does work — the carriers slow where they are thin</Head>
+
+          <Para>
+            It has to go in the <i>transport</i>, then: in how the carriers travel rather than in how hard anything pulls. And <K>inStep</K> already says when a carrier gets to travel cheaply — emitters within a common phase pay the update once between them — so a dense field is a fast one and a thin field is a slow one. No new rule.
+          </Para>
+
+          <Eq note="the drift, and flux conservation with it">
+            <V>v</V> = <V>c</V>·min(1, <V>n</V>/<V>n</V><Sub>c</Sub>)
+            <span style={{ padding: '0 1.6em', color: FAINT }}>,</span>
+            <V>Φ</V> = 4π<V>r</V><Sup>2</Sup>·<V>n</V>·<V>v</V> = constant
+          </Eq>
+
+          <Para>
+            Dense, and <V>v</V> = <V>c</V>, so <V>n</V> ∝ 1/<V>r</V><Sup>2</Sup>: Newton. Thin, and <V>v</V> ∝ <V>n</V>, so flux conservation goes <i>quadratic</i> and <V>n</V> ∝ √<V>Φ</V>/<V>r</V> — which is <b>both halves at once</b>, the 1/<V>r</V> law and, since <V>Φ</V> ∝ <V>M</V>, an effective source going as √<V>M</V>. Measured by integrating the transport: slope −2.0000 inside, −1.0000 outside, and the outer density against √<V>Φ</V> comes to 10.0000 for a hundredfold mass. That is the nonlinearity the theorem demanded, living where the theorem allows it.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The turnover between the two is not borrowed either, which is the part every earlier version of this section quietly assumed. <K>through</K> says a point already carrying a charge is <i>busy</i> — an arriving charge annihilates or reverses, and either way that point does not split this tick — so splitting is suppressed exactly where the carrier density is high, which by <V>g</V> ∝ <V>n</V> is where the field is strong.
+          </Para>
+
+          <Eq note="occupancy θ = g/a₀, free fraction 1/(1+θ), and it closes">
+            <V>g</V> = <V>g</V><Sub>N</Sub>·(1 + <V>a</V><Sub>0</Sub>/<V>g</V>)
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>g</V> = <Frac over={<><V>g</V><Sub>N</Sub></>} under={<>2</>} /> + √(
+            <Frac over={<><V>g</V><Sub>N</Sub><Sup>2</Sup></>} under={<>4</>} /> +{' '}
+            <V>g</V><Sub>N</Sub><V>a</V><Sub>0</Sub>)
+          </Eq>
+
+          <Para>
+            <b>That is MOND's "simple" interpolation function, and here it is derived rather than chosen.</b> Over six decades <V>g</V>/<V>g</V><Sub>N</Sub> runs 32.1, 10.5, 3.70, 1.62, 1.09, 1.010, 1.0010 against a deep limit √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>) of 31.6, 10.0, 3.16 — agreeing where it should and parting where it should. Every MOND paper picks that function by hand out of a family; this one picks itself out of the counting statistics of the mechanism.
+          </Para>
+
+          <Head>and the scale is not fitted either</Head>
+
+          <Para>
+            What sets the threshold is the thing the model is <i>about</i>: space being made. Making space has a rate, that rate is <V>H</V>, an acceleration built from it is <V>cH</V>, and the frontier already forces <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> exactly — so <V>cH</V><Sub>0</Sub> is a count of ticks and not a constant anybody chose. The 2π is <K>inStep</K>'s own.
+          </Para>
+
+          <Eq note="the acceleration scale, with nothing fitted in it">
+            <V>a</V><Sub>0</Sub> = <Frac over={<><V>c</V> <V>H</V><Sub>0</Sub></>} under={<>2π</>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            1.096·10<Sup>−10</Sup> m/s²
+            <span style={{ padding: '0 1.2em', color: FAINT }}>vs</span>
+            1.200·10<Sup>−10</Sup> measured
+          </Eq>
+
+          <Para>
+            <b>Nine percent, with nothing fitted anywhere.</b> And it explains a coincidence that is an embarrassment everywhere else — why should a galaxy know the age of the universe? Here it is not being told the age; it is being told the rate at which space is made, which is the same number because the frontier makes it so. <b>The cosmology and the rotation curves become one fact.</b>
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Run on the Milky Way with that predicted <V>a</V><Sub>0</Sub> and nothing fitted at all, the ratio to Gaia goes 0.977 · 0.997 · 0.999 · 0.995 · 0.987 · 0.987 · 1.002 · 1.028 from 6 to 30 kpc — <b>1.1% rms</b>, with a Tully–Fisher slope of 3.42 against a measured 3.85 ± 0.09. Newton alone runs 0.83 down to 0.54 over the same range. Which is worth <i>looking</i> at rather than reading, because a rotation curve is a graph and a graph hides what it means:
+          </Para>
+
+          <Discs />
+
+          <Para>
+            Four spokes of stars laid down along one radius and left to shear, under each law, with the measured curve dashed and repeated in every panel. General relativity falls visibly behind it within one turn of the Sun.
+          </Para>
+
+          <Head>the sharpest test, and it nearly failed</Head>
+
+          <Para>
+            A first reading made <V>a</V><Sub>0</Sub> a <i>clock reading</i> — <V>c</V>/2π<V>t</V>, so three times larger at <V>z</V> = 2 — which is a dated, falsifiable prediction MOND cannot make. Genzel and co. measure five massive discs at <V>z</V> = 0.85–2.24 with <i>declining</i> outer curves and <V>f</V><Sub>DM</Sub>(&lt;<V>R</V><Sub>e</Sub>) &lt; 0.2, which is a boost under about 1.118. That reading predicts 1.18, 1.17, 1.16, 1.24 — four of five over the line — and refuses it.
+          </Para>
+
+          <HighZDiscs />
+
+          <Para>
+            The blocking above rescues it, and at a price. <V>a</V><Sub>0</Sub> is a function of the field at the point and nothing else, so it is <i>local</i> rather than cosmological and does not move with redshift — there is nothing in it that could. That removes the refutation. <b>It does not make the discs agree</b>, and an earlier version of this section said it did, on a calculation that was wrong.
+          </Para>
+
+          <HighRedshift />
+
+          <HighZCurves />
+
+          <Para>
+            Drawn as curves rather than as a boost factor, the disagreement is immediate: <b>four of five overshoot</b>. The earlier pass took <V>g</V><Sub>N</Sub> = <V>GM</V>/<V>R</V><Sub>e</Sub><Sup>2</Sup>, a <i>point mass</i>, and these are discs — at one effective radius a disc has enclosed about half its mass, so its real <V>g</V><Sub>N</Sub> is roughly half that, which sits deeper in the boosted regime and gives a <i>larger</i> boost. The shortcut was generous in exactly the direction that made the model pass. Done properly: 1.174, 1.131, 1.122, 1.158 and 1.033 against a ceiling of 1.118.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            But "overshoots four of five" is an adjective and not a measurement. <V>f</V><Sub>DM</Sub> &lt; 0.2 is an <i>upper limit</i>, so the true boost lies somewhere in 1.000…1.118 — Newton sits at the bottom of that band by construction and the model just above the top of it, and which is closer depends where in the band the truth is. At <V>f</V><Sub>DM</Sub> = 0 Newton is exact and the model is 13.3% high; at 0.10 it is 5.1% low against 8.1% high; at 0.20 it is <b>10.6% low against 4.4% high</b> and the model wins. Meanwhile on the Milky Way the model is <b>1.1% rms against Newton's 32.5%</b>, worst case 2.6% against 43.1%. So the high-<V>z</V> discs are a real tension and not a refutation — and the thing that had to go for the model to survive them is the dated prediction, which should be read as the model becoming <i>harder</i> to test.
+          </Para>
+
+          <Head>the prediction the lattice hands back</Head>
+
+          <Para>
+            One thing does come back, and it is sharper than what was lost. The pair is emitted with the field direction <i>removed</i>, so the space made around a mass is not a sphere — and the obvious worry is that an anisotropy varying with radius would change the <i>shape</i> of the curve and not just its scale.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            It does not, and the lattice is why. The 26 exits from a cell have only <b>three distinct direction cosines</b> — 1 for the six faces, 1/√2 for the twelve edges, 1/√3 for the eight corners — so the projection is a <i>step</i> function with four values: 0.4721, 0.4510, 0.4022, 0.3610. A galaxy spans <V>g</V>/<V>a</V><Sub>0</Sub> from 0.34 at 30 kpc to 4.84 at 2 kpc and never crosses a step. The expansion around it is genuinely not a sphere, but it is one of <i>four discrete shapes</i>, and a galaxy sits in one of them throughout.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>But a galaxy is not the whole of anything.</b> Far enough out the occupancy does cross a step, and when it does <V>a</V><Sub>0</Sub> jumps by a fixed ratio — which is a <b>discontinuity in a rotation curve, at a radius the model computes</b>. For the Milky Way that is <b>33 and 52 kpc</b>, where the Sagittarius stream lives and where the satellite population is measured; for a big spiral 58 and 90; for a dwarf <b>6 and 9 kpc</b>, inside the stellar body where a curve is easiest to measure. The size is small and the shape is the point: <V>v</V> ∝ <V>a</V><Sub>0</Sub><Sup>¼</Sup>, so the plateau ratios give jumps of 1.1%, 2.8% and 2.7% — two to six km/s on a 200 km/s curve, <i>sharp</i>, at a radius fixed by the baryons alone with nothing to tune. MOND has no reason for a curve to be anything but smooth, and a halo is smooth by construction.
+          </Para>
+
+          <Head>and whether it is dark matter at all</Head>
+
+          <Para>
+            No, and this is the test that decides it. Clusters need 6.0× their baryons — Coma 6.0, A1689 6.8, A2029 5.3, Perseus 5.9, Virgo 6.0 — and the model supplies 3.32, 3.59, 3.52, 3.75, 5.54, a mean of 3.94 against a mean of 6.0. <b>Short by 1.53×</b>, systematically rather than scattered.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And the reason is structural rather than a matter of tuning. In the boosted regime the mass ratio is √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>), so a factor of six needs <V>g</V><Sub>N</Sub>/<V>a</V><Sub>0</Sub> = 1/36, and clusters sit at 0.04 to 0.13 — near the turnover rather than deep in it, where the ceiling is about 3×. <b>The square root is a hard ceiling and clusters are above it</b>, so no interpolation function and no value of <V>a</V><Sub>0</Sub> reaches them. Worse, the demands point opposite ways: clusters want <V>a</V><Sub>0</Sub> up to 4× larger and the compact high-<V>z</V> discs want it 0.6× smaller.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>So this is not a dark-matter theory. It is a mechanism for the rotation-curve regime.</b> In the deep limit it <i>is</i> MOND — that is what deriving the interpolation rather than choosing it means — so it inherits MOND's cluster problem exactly, for the same reason and by the same factor. What it adds is that <V>a</V><Sub>0</Sub> is computed rather than fitted, the interpolation is derived rather than chosen, and there is a step nobody else predicts. What it does not add is any reach beyond galaxies: no microwave background at all, a failed supernova diagram, no source for the light elements, and clusters short by half. <b>Four of the five things dark matter was invented for are untouched or failed</b>, and a galaxy fitted to 1.1% by a computed constant is one regime out of five.
+          </Para>
+
+          <Head>the ledger</Head>
+
+          <Para>
+            Which leaves the thing I most want kept honest — what went in, what came out, and what is still owed.
+          </Para>
+
+          <Rows of={[
+            [<>what is put in</>,
+              <>Six countable facts and nothing else. <K>DEG</K> = 3<Sup>3</Sup> − 1 = 26,
+                ways out of a point. <K>SHEET</K> = 3<Sup>2</Sup> − 1 = 8, charges in one
+                pulse. <K>BITE</K> = 1, points an annihilation removes, so that making and
+                unmaking a ± pair are exact inverses. <K>LIGHT</K> = 1, points per tick.{' '}
+                <K>HALF</K> = ½, a shell being never smaller than the cell its source sits
+                in. And <V>m</V>, which is how <i>often</i> a thing emits rather than a
+                property it has.</>],
+            [<>what comes out</>,
+              <>The inverse square, as a fixed count over a growing shell. The equivalence
+                principle. <V>G</V>, every symbol of it a count. Special relativity's own
+                1/<V>γ</V><Sup>3</Sup> and 1/<V>γ</V>. The metric, <V>A</V> and <V>B</V>{' '}
+                from one compounding count, with β = γ = 1. The geodesic equation, matching
+                Euler–Lagrange to 10<Sup>−7</Sup>. Mercury's advance and light's deflection
+                in full. <V>E</V> = ħω from what mass is, and λ = <V>h</V>/<V>p</V> from not
+                knowing where it is. A screening term Newton has no name for. And the tick,
+                which is the Planck time by identity.</>],
+            [<>what is owed</>,
+              <>One link, and it is arithmetic rather than astronomy: that a carrier's
+                update cost goes as its accumulated phase. <K>through</K> gives the
+                blocking, <K>inStep</K> gives the budget, and nothing here derives the join.
+                Then the ambient sea, which is 2.65× the crossover density even after{' '}
+                <K>reach</K> cuts it off, so the MOND regime switches on only <i>barely</i>{' '}
+                where every fit above assumed it switches on cleanly. And the two
+                derivations of <V>a</V><Sub>0</Sub>, which differ by exactly{' '}
+                <K>DEG</K>/2<K>SHEET</K> = 13/8 — so one of them miscounts, and finding
+                which turns a 9% agreement into a derivation or kills it outright.</>],
+            [<>and four things to shoot at</>,
+              <>The <b>shadow</b>, 4.6% larger than general relativity's at the same mass,
+                parameter-free and inside the reach of an instrument that exists. The{' '}
+                <b>age</b>, forced to 1/<V>H</V><Sub>0</Sub> with no freedom to miss, which
+                the Hubble tension brackets. <b><V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π</b>,
+                computed rather than fitted. And <b>the step</b> — a discontinuity in a
+                rotation curve at 6 and 9 kpc in a dwarf, which nothing else in physics
+                predicts.</>],
+            [<>and one that is probably just wrong</>,
+              <>A neutron star shows about two thirds of its mass, which is outside any
+                equation of state, and pulsar timing measures those directly.</>],
+          ]} />
+
+          <Para>
+            The rest of the arrangements the model has been run on are below — every one of them the same rules, differing only in what was put in the world and how it was watched.
+          </Para>
 
           <Models models={MODELS} />
         </Section>
@@ -372,16 +1017,280 @@ const Physics = () => {
         </Section>
 
         <Section head="TODO2">
+
+          <Head>the same emission, with the signs kept</Head>
+
+          <Para>
+            Everything in the gravity arc counts <i>one</i> thing about an emitter: how often it lets go. That is mass. But a source has a second property that has nothing to do with the first — <b>which way round it is when it does</b> — and the gravitational half never once looked at it. Keep the signs instead of throwing them away and the very same emission answers a different question.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            I want to say what that question is before going any further, because it is narrower than the section title suggests. There is no account of <i>matter</i> in this model, so nothing here says what an electron or a positron would be, and the electric half — charge, how matter interacts with it — is not attempted. What the signs give is a <b>bias</b>, and a bias is magnetism.
+          </Para>
+
+          <Eq note="one emission, two moments of it — the count is mass, the signed first moment is a bias">
+            <V>m</V> = ⟨1⟩<span style={{ padding: '0 1.6em' }} />
+            <V>q</V> = ⟨<V>s</V>⟩<span style={{ padding: '0 1.6em' }} />
+            <V>µ</V> = ⟨<V>s</V> <V>d̂</V>⟩
+          </Eq>
+
+          <Para>
+            Which is why the two behave so differently, and it is not a coincidence. <b>A count always adds</b>, so gravity has one sign and cannot be screened. <b>A signed sum cancels</b>, so a bias comes in two kinds and ordinary matter has none of it while still having all of its mass.
+          </Para>
+
+          <Head>four emitters, and each of the four is something</Head>
+
           <Kinds />
+
+          <Para>
+            A source has exactly two switches and they are independent: whether it has <i>sides</i> (an axis) and whether it <i>comes round</i> (turns, or flips). Crossing them gives four distinguishable emissions — nothing signed at all, one sign in every direction, nothing signed again, and + out of one side with − out of the other. That much is structure, and it was not arranged for.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What those four <i>are</i> is a different question and I am not going to pretend to answer it. Calling the second an electric charge and the fourth a magnet is a guess — reasonable, and not earned — so the panel says what each one emits and stops. Everything below concerns the fourth, which is a bias.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And whatever they turn out to be, <b>none of them can be a sided source with a net</b>: there is no way to be sided without having two sides. Checked over twenty thousand axes, the net emission is exactly nought every time, because the lattice's exits come in ± pairs so a direction and its opposite always get opposite signs. That is ∇·<V>B</V> = 0 and the absence of monopoles — a symmetry electromagnetism <i>observes</i>, and this model cannot avoid.
+          </Para>
+
+          <Head>a magnet is a lopsided default, not a stopped one</Head>
+
+          <Para>
+            The constraint that decides this whole section is that <b>a magnet still has to pulse its weight</b>. The two clocks are independent — <K>beat</K> = 1/<V>m</V> is how often it lets go, <K>rate</K> is how fast its axis comes round — so magnetising a thing cannot change what it weighs, and an emitter never has to stop. Both go on at once, and the magnet is the amount by which the alternation fails to come out even.
+          </Para>
+
+          <Eq note="a lopsided default, not a stopped one — and dwell is a count of ticks, so P is quantised">
+            <V>P</V> = 2·<K>dwell</K> − 1,<span style={{ padding: '0 1.2em' }} />
+            <K>dwell</K> = <V>k</V>/<K>CYCLE</K><span style={{ padding: '0 1.2em' }} />
+            ⇒ <V>P</V> ∈ {'{'}0, ¼, ½, ¾, 1{'}'}
+          </Eq>
+
           <Lopsided />
+
+          <Para>
+            <K>dwell</K> is a count of ticks, so the smallest magnetisation a single emitter can carry is 2/<K>CYCLE</K> = <b>a quarter</b>. Magnetisation comes in units, with nothing free in it. Against that, a saturated neodymium magnet measures <V>P</V> = 1.51·10<Sup>−5</Sup> in bulk: <b>99.9985% of what it emits cancels</b>, and what a magnet <i>is</i> is the fifteen parts per million that failed to.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The count behind that is a check rather than a fit, and worth spelling out because it is the only place the two halves of the model touch a laboratory. It is a measured remanence divided by a measured <V>µ</V><Sub>B</Sub>, read against the moment per atom measured a different way — iron <b>2.17</b> against 2.22, cobalt 1.69 against 1.72, nickel 0.57 against 0.61, Nd<Sub>2</Sub>Fe<Sub>14</Sub>B 29.8 against about 32. So whatever carries magnetisation has an electron's moment and an electron's abundance, in four materials at once. <b><V>µ</V><Sub>B</Sub> and the electron are inputs here, not results.</b>
+          </Para>
+
+          <Head>the sign law was already inside G</Head>
+
+          <Para>
+            Here is the thing I did not expect. <K><Bar>G</Bar></K>'s derivation carries a factor it has never had to justify: <i>half of them opposite</i>. That half is the chance two charges landing in the same cell have opposite sign — and it is not a constant, it is a fact about the matter involved. Half is what you get when both bodies are unbiased. Ordinary matter is unbiased. <b>That is the whole reason it ever looked like a number.</b> Put the bias back and the sign law falls out with no new rule at all.
+          </Para>
+
+          <Eq note="like biases attract less, opposite attract more — and at P = 0 it is Newton exactly">
+            <V>F</V> = <Frac
+              over={<><K>G</K> <V>m</V><Sub>a</Sub> <V>m</V><Sub>b</Sub></>}
+              under={<><V>R</V><Sup>2</Sup></>} />
+            <span style={{ padding: '0 0.5em' }} />
+            (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)
+          </Eq>
+
+          <Para>
+            Read off the split: unbiased against unbiased is one half and one half, which <i>is</i> the ½ in <K><Bar>G</Bar></K>, so Newton is the <V>P</V> = 0 case and not a separate claim. Biased against unbiased is also one half — a bias does nothing to something with no bias of its own, which comes out of the arithmetic rather than being put in by hand. Same bias gives nought, opposite bias gives twice. <b>Opposites attract and sameness repels, derived</b>, which is where this whole idea started.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which is worth stopping on: <b>the gravitational constant carries a factor of one half because ordinary matter is unbiased.</b> If matter had a net bias, <V>G</V> would be a different number. The half was already there and unexplained; this is what it was — and that needs no reading whatever of what the bias <i>is</i>.
+          </Para>
+
+          <Head>and where the bias lives decides everything</Head>
+
+          <Para>
+            There are two places the bias could sit and only one of them is a magnet, and getting that wrong cost me a long time. Put it on a <i>direction</i> — one emitter, + out of its north half and − out of its south, from a single place — and it fails: pole to pole gives <b>exactly nothing</b>, by an exact cancellation, and the fall-off is 1/<V>R</V><Sup>2</Sup> where two magnets are 1/<V>R</V><Sup>4</Sup>. Giving the emitter a ring does not rescue it, at any phase.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Put it on a <i>place</i> and everything works. A bar magnet is then a lump biased + at one end and − at the other — net zero because the two ends cancel, <b>separated in space rather than in direction</b> — which is what magnetostatics has always called the pole model. Nothing else changes: the same <K>chance</K>, the same co-location rule, the same (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)/2 XOR whose unbiased case is the half inside <K><Bar>G</Bar></K>.
+          </Para>
+
           <Fields />
+
           <Pairs />
+
+          <Para>
+            Measured over the whole of space, by integrating the annihilation excess: <b>3cos²<V>θ</V> − 1 to three decimals</b> at every angle including both sign changes, <b>slope −2.00</b> on gravity's own 1/<V>R</V><Sup>2</Sup> so the force between two of them is 1/<V>R</V><Sup>4</Sup>, and all five orientations right — N–S facing, N–N facing, side by side either way, and one across the other giving nought to 10<Sup>−19</Sup>. That is magnetostatics, out of the same machinery that gave the rotation curve, with <b>nothing added to it</b>.
+          </Para>
+
           <BarField />
+
+          <Para>
+            And the field lines there are integrated from the model's own signed emission — Σ sign·<K>SHEET</K>/4π<V>r</V><Sup>2</Sup> over the two pole faces — rather than from a textbook formula. They come out as a dipole because that sum <i>is</i> a dipole, which is the whole of the point.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            It also says why <b>cutting a magnet gives two magnets</b> rather than two monopoles: the sign belongs to a region's boundary, so a new cut makes a new pair of faces. And ∇·<V>B</V> = 0 survives for the same reason — a body's two poles are the same emitters counted at both ends, so they are equal and opposite by construction.
+          </Para>
+
+          <Head>scale is not the problem</Head>
+
           <Ceiling />
 
-          <MagnetismLaw />
+          <Para>
+            One emitter's ring has radius (<K>CYCLE</K>·<K>G</K>/2<V>π</V>)·<V>λ̄</V><Sub>C</Sub>, and <V>λ̄</V><Sub>C</Sub> goes as 1/<V>m</V>, so a <i>heavier</i> emitter is a <i>smaller</i> loop. Per kilogram the moment therefore goes as 1/<V>m</V><Sup>2</Sup> in whatever the body is made of, so <b>the lightest constituent wins by the square</b>. That is a scaling law and not a claim about what emitters are — what it buys is that if a body has light and heavy ones, the light ones carry the magnetism, which is the fact <V>µ</V><Sub>B</Sub>/<V>µ</V><Sub>N</Sub> = 1836 records.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And a big body screens itself, so only a skin gets out and the aggregate is an <i>area</i> law rather than a volume one. Run backwards against what is measured, a fully aligned skin of <b>4.5 mm carries the whole of the Earth's field</b>, 3.9 m the Sun's, and 0.16 µm a neutron star's. Nothing anywhere reaches 10<Sup>−4</Sup> of the ceiling. <b>Scale is not what stops this</b>, at any size from an electron to a magnetar — which is a null result in the useful direction.
+          </Para>
+
+          <Head>and how many pulses that takes</Head>
+
+          <Para>
+            The mechanism is settled and the <i>size</i> is not, so it is worth asking the question the gravitational half answered: how much emission does a magnet actually need? First, it cannot come from the mass stream. If the biased pulses were a subset of the mass pulses, the whole effect would be the (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>) factor, which runs 0 to 2 — <b>so the most magnetism could ever be is one times gravity</b>, the pull switched off or doubled and nothing further. Two touching N52 cubes pull 2.2·10<Sup>12</Sup> times their own gravity. That is settled, and cleanly: magnetism is its own layer.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            So it has its own budget, and the budget is a number. Equating the two channels gives one conversion with no material in it — <V>m</V><Sub>eff</Sub> = <V>q</V>·√(<V>µ</V><Sub>0</Sub>/4<V>π</V><K>G</K>) = 38.7 kg per A·m — so a 1 cm N52 cube must emit as if it weighed <b>four and a half tonnes</b>, six hundred thousand times its own mass.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And the ratio is not a constant, which is the informative part: it runs 6·10<Sup>3</Sup> to 6·10<Sup>5</Sup> across six magnets, going as <V>M</V>/<V>ρL</V>, because <b>a pole is a surface and mass is a volume</b>. Divide the geometry out and what is left <i>is</i> constant — 4.5·10<Sup>7</Sup> kg/m² of pole face for saturated N52, one number reproducing all six geometries with no residual. What sets that number is the open question, and it is the same shape as <V>a</V><Sub>0</Sub> was before <V>cH</V><Sub>0</Sub>/2π: a coupling waiting for a count.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And because there is one ceiling, the budget is <i>shared</i>: pulses spent being a magnet are not being mass, so <b>magnetising a thing makes it lighter</b>, by exactly the fraction diverted. Which is a prediction that can be shot at — and the cheap version of it is already dead, because if the diverted fraction were the bulk bias itself, 1.5·10<Sup>−5</Sup>, a kilogram bar would lose 10 mg on being saturated, five orders above what a comparator would miss. So the magnetic layer's pulses are worth at least 10<Sup>14</Sup> gravitational ones, and that floor comes from a weighing rather than from a choice.
+          </Para>
+
+          <Head>and the one number the whole thing owes</Head>
+
+          <Ladder />
+
+          <Para>
+            Every force in this model is second order in the emission — nothing happens to a charge that does not <i>meet</i> another charge — so the electric force is capped at the size of gravity, and measurement puts it 4.166·10<Sup>42</Sup> above. What is worth saying is that <b>the hierarchy itself is not the mystery</b>. <i>If</i> the coupling were a count of order one where gravity is a product of two rates, the gap would be the mass in Planck units squared: <V>α</V>/(<V>m</V><Sub>e</Sub>/<V>m</V><Sub>P</Sub>)<Sup>2</Sup> = 4.166·10<Sup>42</Sup>, which is the measured ratio to five figures. <b>The bill is exactly one number, <V>α</V></b>, and nothing here derives it. Of 117,649 lattice monomials searched, 51 land within half a percent of 137.036 — so a hit would not be evidence, and none is claimed.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And the bias is not electric charge, which is sharper than the factor and has to be answered first. Emission rate goes as mass, so if charge were the signed emission rate a proton would carry <b>1836 times</b> an electron's, where measurement has the two equal to 10<Sup>−21</Sup>. Whatever <V>P</V> is, it is not <V>q</V>.
+          </Para>
+
+          <Head>the audit</Head>
+
+          <Rows of={[
+            [<>what comes out</>,
+              <>The 1/<V>r</V><Sup>2</Sup>, as flux over a growing shell — exactly{' '}
+                <K>SHEET</K> = 8 through any sphere, to the last digit. The sign law, for a
+                bias. Two signs that cancel. A ± ledger that balances, which is what{' '}
+                <K>BITE</K> = 1 exists for. Magnetisation quantised in quarters. ∇·<V>B</V> = 0
+                and the absence of monopoles. That the lightest constituent wins by the
+                square. Superposition. The dipole angular law 3cos²<V>θ</V> − 1, the
+                1/<V>R</V><Sup>4</Sup> force, all five orientations, and that cutting a magnet
+                halves it. <b>Thirteen of twenty-nine.</b></>],
+            [<>what is assumed</>,
+              <><K>LIGHT</K> = 1 is an axiom rather than a result, so <V>c</V> being finite
+                and universal is built in — and with it, that radiation exists at all.</>],
+            [<>what is owed</>,
+              <>One number: <b>the magnetic coupling</b>, the 4.5·10<Sup>7</Sup> kg/m² of
+                pole face. Measured, not counted. Everything else here follows once it is
+                fixed.</>],
+            [<>what is not started</>,
+              <>The electric half, entirely: charge, <V>ε</V><Sub>0</Sub>, <V>α</V>, Faraday,
+                Ampère–Maxwell, the Lorentz force. Those need a model of matter <i>and</i> a
+                first-order channel, and neither exists — a force here is a <i>meeting</i>,
+                which is second order. That one fact is the whole of the missing column.</>],
+            [<>and what is refuted</>,
+              <><V>g</V> = 1, where the electron's is 2.0023 — and that one survives every
+                choice, since <V>µ</V>/<V>L</V> = <V>q</V>/2<V>m</V> with the radius
+                cancelling out. The anisotropy predicts ⟨111⟩ by 11.1% in every cubic
+                crystal, which is right for nickel, wrong for iron, and flat where
+                measurement runs from 2.6% to 32%. And a magnet cannot be made of{' '}
+                <i>sided</i> emitters, however they are ordered.</>],
+          ]} />
+
+          <Head>where the poles come from, which is not settled</Head>
+
+          <Para>
+            A magnet needs its bias on a place, and something has to <i>put</i> it there. The natural answer is ordering: emitters pointed the same way and held there, so inside the body every + has a − sitting on it and at a face it does not. <b>Measured, that happens</b> — the signed emission is nought in the middle of a cylinder and largest at its ends.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And it still does not make a magnet. Axial, radial and cylindrical orderings all give a far field falling as 1/<V>r</V><Sup>2</Sup> where a magnet is 1/<V>r</V><Sup>3</Sup>, because <b>the cancellation is a near-field fact</b>: a distant body does not see neighbours cancelling, it sees every emitter's chosen side at once. The sign of a sided emitter's pulse is decided by where the observer <i>is</i>, so the sides add instead of cancelling.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which turns the open question into one line of the source. <K>emission</K> is <code>sided ? along() : cos(2πβ)</code>, and <K>along</K> resolves the direction against the axis <i>at the destination</i>. A pulse whose polarity were fixed <b>when it left</b> would carry it, the near-field cancellation would survive to infinity, and the faces would be poles. So: <b>is a pulse's sign fixed when it leaves, or when it arrives?</b> Nothing else about the mechanism changes either way, which makes it the cheapest open question on the page.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            So the honest sentence here is the opposite shape to the gravitational one. There, the scale came out unfitted and the structure was the fight. Here it is the other way round: <b>the whole structure of magnetostatics comes out of the same XOR that gave gravity</b>, and the one thing it owes is the scale. <b>Magnetostatics derived, its coupling owed, and electric charge not started.</b>
+          </Para>
+
+          <Head>and the same theory with the XOR turned off</Head>
+
+          <Para>
+            Which is worth asking because it makes this a <i>family</i> rather than a single thing. Take the polarity away — no signs, no opposites, just discrete directions, and a meeting counted when two charges come at each other head on. Does gravity notice?
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Two things change in the rules and they pull opposite ways. The <b>share</b> goes from ½ to 1, because every meeting now annihilates where before only the opposite ones did. And the <b>angular gate comes back</b> — with no sign to decide the outcome there is nothing left but the angle, so <K>closing</K> returns and the folding is bounded to a lens again.
+          </Para>
+
+          <Eq note="G doubles — and that is the whole of it">
+            <K>G</K> = <Frac
+              over={<><K>BITE</K>·<i>share</i>·<K>SHEET</K><Sup>2</Sup></>}
+              under={<>4<V>π</V><Sup>2</Sup>·<K>CORE</K>·<K>DEG</K></>} />
+            <span style={{ padding: '0 1.4em' }} />
+            0.062351 → 0.124703
+          </Eq>
+
+          <Para>
+            And the factor of two is not observable. Every mass in the model is carried in units of <K>GRAVITY</K>, so a body of physical mass <V>M</V> holds <V>M</V>/<K>G</K> and the dynamics compute <K>G</K>·(<V>M</V>/<K>G</K>). The constant is gone before it is used — <b>a change of the mass unit, not of a prediction</b>. Measured on the line integral: exactly two at every separation, with <V>S</V>·<V>R</V><Sup>2</Sup> flat in both.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <K>SHEET</K>, <K>DEG</K>, <K>BITE</K>, <K>BIAS</K>, <K>MADE</K>, <K>SPREAD</K>, <K>REACHES</K> and the tick do not move at all. And neither does anything predicted: Mercury's sixth, the other five sixths, light's deflection, <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π, the Milky Way to 1.1%, the transport turnover, the interpolation function, the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>. <b>All identical, to every digit quoted</b> — because every one of them is computed from something that never mentions a sign.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>So gravity is the same theory.</b> Not approximately. What is lost is magnetism entirely — the sign law, 3cos²<V>θ</V> − 1, 1/<V>R</V><Sup>4</Sup>, ∇·<V>B</V> = 0, the quantised magnetisation — and one <i>explanation</i>: with polarity the ½ in <V>G</V> is derived, being the chance two charges disagree. Without it, the share is 1 by fiat and there is nothing to explain.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which leaves the XOR as a <b>tunable parameter, and a free one on the gravitational side</b>. Turning it on costs nothing and buys magnetism; turning it off costs magnetism and buys nothing. That is a better position than this page was in before the question was asked, because it means the magnetic half cannot break the gravitational one — there is no shared number for it to get wrong.
+          </Para>
 
-          <WithoutPolarity />
         </Section>
       </Section>
       
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx
index 0e408fa..0b15944 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/GraphCanvas.tsx
@@ -27,7 +27,7 @@ import { Boundary, Graph, node } from "./discrete";
 import { BOUNDARY_STUB, CYCLE, LATTICE_STEP, Vec } from "./lattice";
 import { outcome, Polarity } from "./physics";
 import {
-  AMBER, channels, CYAN, ground, HALO, rgba, SOURCE, source, tintOf,
+  AMBER, channels, CYAN, ground, HALO, NEUTRAL, rgba, SOURCE, source, tintOf,
 } from "./paint";
 
 /**
@@ -56,6 +56,44 @@ import {
  */
 export type RenderMode = 'lattice' | 'shells' | 'field';
 
+/**
+ * The sheet, for the pictures that are about it.
+ *
+ * `SHEET` is the count of ways out of a point that lie in one — 3^(d−1) − 1,
+ * which is eight in three dimensions — and the whole of the gravity argument is
+ * that a source emits into a sheet and TURNS, one rotation carrying the
+ * emission through exactly one more dimension than it already has. Drawn: the
+ * plane, and the eight directions in it.
+ */
+export type SheetView = { turning?: boolean };
+
+const AXIS = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+
+/**
+ * How far out the sheet is drawn, in its own two directions.
+ *
+ * One, exactly — which is what keeps it inside the picture. Its four corners
+ * are then the four cells at ±u±v and nothing is drawn past a point of the
+ * lattice, so a sheet cannot stick out of the box the camera framed. Anything
+ * over one is a promise that the frame does not know about.
+ */
+const SHEET_EDGE = 1;
+
+/**
+ * Seconds a snap of the turn holds for.
+ *
+ * SNAPPED, NOT SWEPT, and snapped onto the lattice rather than through it. A
+ * plane turned by an eighth is a real plane of this space — it is the one
+ * spanned by an axis and a DIAGONAL, whose eight are the same eight cells read
+ * out of the neighbourhood at a different angle. A plane turned by an eighth
+ * while its two directions are held rigid is not: the directions leave the
+ * lattice, land between cells, reach √2 out where every cell is at 1, and hang
+ * over the edge of the box. Which is the same error the argument itself is
+ * careful not to make — there are nine sheets in a 3×3×3 and the picture is
+ * only allowed to be in one of them.
+ */
+const SHEET_SNAP = 0.5;
+
 /**
  * One canvas showing one universe.
  *
@@ -71,6 +109,8 @@ export const GraphCanvas = ({
   animate = false,
   density = true,
   mode = 'lattice',
+  polarities = true,
+  sheet,
   onFrame,
   onVisible,
 }: {
@@ -82,6 +122,23 @@ export const GraphCanvas = ({
   animate?: boolean;
   density?: boolean;
   mode?: RenderMode;
+
+  /**
+   * Whether a charge is drawn as a charge.
+   *
+   * There is no polarity in the gravity half of the argument — it is
+   * introduced later, and the whole claim of the magnetism arc is that adding
+   * it changes what these same runs mean. Drawn amber and cyan from the start,
+   * the pictures answer a question the reader has not been asked yet. Off,
+   * every boundary is the plain grey of space that has not been charged by
+   * anything, and what is left to see is the one thing gravity is about: what
+   * meets what, and what is left afterwards.
+   */
+  polarities?: boolean;
+
+  /** The sheet drawn over the lattice, where the picture is of one. */
+  sheet?: SheetView;
+
   onFrame?: (dt: number) => void;
 
   // Called as the view comes on and off screen, so that whoever owns the
@@ -97,7 +154,10 @@ export const GraphCanvas = ({
   const latest = useRef({ current, onFrame, onVisible });
   latest.current = { current, onFrame, onVisible };
 
-  return <CanvasView animate={animate} deps={[animate, density, mode]} paint={() => {
+  return <CanvasView
+    animate={animate}
+    deps={[animate, density, mode, polarities, !!sheet, !!sheet?.turning]}
+    paint={() => {
     const cam = {
       scale: 44, rot: Math.PI / 4, tilt: 0.6155,
       dist: null as number | null, distMult: 1.5, scaleMult: 1,
@@ -108,6 +168,62 @@ export const GraphCanvas = ({
     // of what makes the animation flow rather than step.
     let eased: Float32Array | null = null;
 
+    // How far the sheet has turned, counted in snaps rather than in radians —
+    // the one thing in this file that moves without the universe moving, since
+    // nothing is ticking in those pictures and the turning IS the picture. The
+    // seconds since the last one are kept beside it, because a frame is not a
+    // snap and the two have nothing to do with each other.
+    let turned = 0;
+    let held = 0;
+
+    // What colour a charge is drawn, which is a question about which half of
+    // the argument the picture belongs to — see `polarities`.
+    const hue = (p: Polarity) => polarities ? tintOf(p) : NEUTRAL;
+
+    /**
+     * The sheet at a given snap: the two lattice directions it is spanned by.
+     *
+     * THE NINE SHEETS OF A 3×3×3, visited four at a time. A plane through the
+     * middle cell holds eight of the twenty-six exactly when it is spanned by
+     * an axis and one of {b−c, c, c+b, b} — the two flat ones and the two
+     * diagonal ones that contain that axis — and turning through those four in
+     * order is a half turn about it, an eighth at a time, without ever leaving
+     * the lattice. Which is what a source does. The other half turn is the same
+     * four planes again, since a plane turned over is the plane it was.
+     *
+     * Then the next axis takes over, so it goes round in x, then y, then z: one
+     * axis is enough to sweep the space and it is not enough to SAY so, because
+     * a picture that only ever turns about x leaves open whether x was special.
+     *
+     * IT STARTS ON A DIAGONAL, and on the one of the two that can be SEEN. The
+     * camera here is the isometric three-quarter view, so it looks along (1,1,1)
+     * — and the plane of x and (0,1,1) has that direction lying in it, which
+     * means it is drawn exactly edge-on, as a line. Its opposite number, x and
+     * (0,−1,1), is the most face-on plane of all nine (twice the projected area
+     * of a flat one, and the other diagonal's is nought).
+     */
+    const sheetAt = (step: number) => {
+      const axis = Math.floor(step / 4) % 3;
+      const k = step % 4;
+
+      const u = AXIS[axis];
+      const b = AXIS[(axis + 1) % 3];
+      const c = AXIS[(axis + 2) % 3];
+
+      const v = k === 0 ? c.map((z, i) => z - b[i])
+        : k === 1 ? c
+          : k === 2 ? c.map((z, i) => z + b[i])
+            : b;
+
+      return { u, v };
+    };
+
+    // A place in the sheet, said in the sheet's own two directions.
+    const inSheet = ({ u, v }: { u: Vec, v: Vec }, p: number, q: number): Vec =>
+      [0, 1, 2].map(i => (p * u[i] + q * v[i]) * LATTICE_STEP);
+
+    const CORNERS = [[-1, -1], [1, -1], [1, 1], [-1, 1]];
+
     function project(pos: Vec, rot: number, tilt: number, camDist: number) {
       const x = pos[0] || 0, y = pos[1] || 0, z = pos[2] || 0;
       const cosR = Math.cos(rot), sinR = Math.sin(rot);
@@ -275,6 +391,14 @@ export const GraphCanvas = ({
           }
         }
       }
+      // The sheet needs nothing here, and that is worth saying rather than
+      // leaving to be noticed: every orientation it turns through is spanned by
+      // lattice steps and drawn to ±u±v, so its four corners ARE four of the
+      // points measured above. It cannot reach anywhere the lattice does not,
+      // in any orientation, so the frame that holds the one holds the other —
+      // and holds it identically in both pictures, which is what lets them be
+      // read side by side.
+
       if (loX > hiX) { loX = hiX = loY = hiY = 0; } // nothing survived clipping
 
       // The camera frames what is actually there, rather than the world
@@ -601,7 +725,7 @@ export const GraphCanvas = ({
         ctx.globalCompositeOperation = "lighter";
 
         for (const shell of shells) {
-          const tint = channels(tintOf(shell.polarity));
+          const tint = channels(hue(shell.polarity));
           const h = shell.hull;
           const at = (i: number) => h[(i % h.length + h.length) % h.length];
 
@@ -1891,7 +2015,7 @@ export const GraphCanvas = ({
           const hull = outline(wave.at);
           if (hull.length < 3) continue;
 
-          const tint = channels(tintOf(wave.polarity));
+          const tint = channels(hue(wave.polarity));
           const at = (i: number) => hull[(i % hull.length + hull.length) % hull.length];
 
           ctx.beginPath();
@@ -2088,7 +2212,7 @@ export const GraphCanvas = ({
         // Center seed: a soft glow marking where the universe started. In
         // field mode the origin is only the point halfway between the two
         // sources, and glowing there would read as a third one.
-        if (!field && isCenterNode(n)) {
+        if (!field && graph.seeded && isCenterNode(n)) {
           const r = Math.min(Math.max(cam.scale * 0.16 * depth, 0.8), 26);
           const g = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 3);
           g.addColorStop(0, "rgba(255,217,168,0.9)");
@@ -2132,7 +2256,7 @@ export const GraphCanvas = ({
           // by anything a plain grey — the same three the closed form leans
           // its pixels towards. The one it is moving along at full strength,
           // the rest faded down.
-          const tint = tintOf(bd.polarity);
+          const tint = hue(bd.polarity);
 
           ctx.strokeStyle = moving
             ? rgba(tint, 1)
@@ -2211,6 +2335,74 @@ export const GraphCanvas = ({
         ctx.lineCap = "butt";
       }
 
+      /**
+       * The sheet, laid in the lattice it is a sheet OF.
+       *
+       * Drawn over the points rather than out of them, because it is not a
+       * thing the universe contains: it is the set of directions a pulse
+       * leaves along, which is a fact about the point in the middle. So it is
+       * a surface through that point, and the eight ways out of it that lie in
+       * that surface — 3^(d−1) − 1 of them, and in three dimensions the 3×3
+       * around the point with its middle taken out.
+       *
+       * TURNED IN EVERY AXIS, a revolution at a time. One axis is enough to
+       * sweep the space and it is not enough to SAY so: turned only about x,
+       * the picture leaves open whether that axis was special, and the whole
+       * claim is that no direction here is. So it goes round in x, then in y,
+       * then in z, and every one of them sweeps the same space.
+       */
+      if (sheet) {
+        const plane = sheetAt(turned);
+        const put = (p: number, q: number) => inSheet(plane, p, q);
+
+        const corners = CORNERS
+          .map(([p, q]) => screenOf(put(p * SHEET_EDGE, q * SHEET_EDGE)));
+
+        if (!corners.some(c => c.clipped)) {
+          ctx.beginPath();
+          corners.forEach((c, i) => i ? ctx.lineTo(c.x, c.y) : ctx.moveTo(c.x, c.y));
+          ctx.closePath();
+
+          // Transparent, because everything it is a sheet through has to stay
+          // readable through it — it is where the lattice is being pulsed
+          // into, not a lid on top of it.
+          ctx.fillStyle = rgba(NEUTRAL, 0.13);
+          ctx.fill();
+
+          ctx.strokeStyle = rgba(NEUTRAL, 0.32);
+          ctx.lineWidth = 1;
+          ctx.stroke();
+        }
+
+        const middle = screenOf([0, 0, 0]);
+
+        ctx.lineCap = "round";
+
+        for (let p = -1; p <= 1; p++)
+          for (let q = -1; q <= 1; q++) {
+            // Standing still, which is not a direction to leave in — and is
+            // the −1 of the count.
+            if (!p && !q) continue;
+
+            const end = screenOf(put(p, q));
+            if (end.clipped) continue;
+
+            ctx.strokeStyle = rgba(NEUTRAL, 0.8);
+            ctx.lineWidth = 1.6;
+            ctx.beginPath();
+            ctx.moveTo(middle.x, middle.y);
+            ctx.lineTo(end.x, end.y);
+            ctx.stroke();
+
+            ctx.fillStyle = rgba(NEUTRAL, 0.95);
+            ctx.beginPath();
+            ctx.arc(end.x, end.y, 2.6, 0, Math.PI * 2);
+            ctx.fill();
+          }
+
+        ctx.lineCap = "butt";
+      }
+
       // What is about to happen — and only ever one thing.
       //
       // Everything in this universe is charges moving, and almost all of the
@@ -2397,6 +2589,16 @@ export const GraphCanvas = ({
         // advances the dynamics itself.
         latest.current.onFrame?.(dt);
 
+        // Except the sheet, which is nobody's dynamics — there is no universe
+        // ticking under those pictures, and the turning is the picture. It
+        // holds an orientation and then is in the next one, the way the thing
+        // it is a picture of does.
+        if (sheet?.turning) {
+          held += dt;
+
+          while (held >= SHEET_SNAP) { held -= SHEET_SNAP; turned++; }
+        }
+
         draw(surface);
       },
 
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
index e98b5ee..a3b76e6 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/discrete.ts
@@ -165,6 +165,17 @@ export class Graph {
   dims = 3;
   ringRadius = 0;
 
+  /**
+   * Whether the cell at the origin is where this universe started.
+   *
+   * It is marked on the picture when it is — a soft glow saying `here is what
+   * all of this grew out of`, which is worth having in a universe that grew.
+   * A patch drawn to show what a lattice IS did not grow out of anything, and
+   * a glow in the middle of it is a claim about a cell that is exactly like
+   * every other cell.
+   */
+  seeded = true;
+
   /**
    * What the camera is for, if it isn't for everything: a radius in grid
    * coordinates, and everything inside it is the subject.
@@ -1816,6 +1827,72 @@ export class Graph {
    * roughly one point per moving ray per tick, so what you seed is what you
    * pay for on every tick thereafter.
    */
+  /**
+   * A patch of space, with nothing in it and at most one thing crossing it.
+   *
+   * The pictures that are about the LATTICE rather than about what happens on
+   * it — a strip of cells with a single ray going through, the twenty-seven
+   * cells around a point — want a lattice that stays a lattice. So every point
+   * is neutral and nothing is moving except the one thing named: what is drawn
+   * is the space, and anything in the picture besides the space is there
+   * because it was asked for.
+   *
+   * `shape` is how many cells along each axis, centred on the origin, and it
+   * is also what says how many dimensions there are: [10, 3] is a strip ten by
+   * three, [3, 3, 3] is the neighbourhood of a point. `moving` names the one
+   * ray that is going anywhere, by the cell it is in and the way it faces.
+   */
+  static patch(
+    { shape, moving }: {
+      shape: number[],
+      moving?: { at: number[], towards: number[] },
+    },
+  ): Graph {
+    const graph = new Graph();
+
+    graph.dims = shape.length;
+    // Drawn where the coordinates say it is. `sphereLayout` morphs a cube
+    // towards a ball as the seed gets bigger, and this is a picture OF a cube.
+    graph.ringRadius = 1;
+    // And nothing grew out of the middle of it: every cell here is a cell.
+    graph.seeded = false;
+
+    const coords: number[][] = [];
+
+    (function build(prefix: number[]) {
+      const axis = prefix.length;
+
+      if (axis === shape.length) { coords.push(prefix); return; }
+
+      for (let i = 0; i < shape[axis]; i++)
+        build([...prefix, i - Math.floor(shape[axis] / 2)]);
+    })([]);
+
+    const { at, facing } = Graph.lay(graph, coords);
+
+    if (moving) {
+      const from = at(moving.at);
+      const to = at(moving.at.map((v, i) => v + (moving.towards[i] || 0)));
+
+      if (from && to) from[0].moving = facing.get(from)!.get(to);
+      else if (from) {
+        // At the rim, facing out. There is nothing on the far side to point
+        // at, and a way out is still a way out — an open world is exactly one
+        // that has them. Drawn as the bare stub it is, which is what says the
+        // thing is about to leave rather than that it has stopped.
+        const out = new Boundary(from[0]);
+
+        out.polarity = Polarity.Neutral;
+        out.outward = moving.towards.slice();
+
+        from[0].boundaries.push(out);
+        from[0].moving = out;
+      }
+    }
+
+    return graph;
+  }
+
   static grid({ dims = 3, size = 5 }: { dims?: number, size?: number } = {}): Graph {
     const graph = new Graph();
     graph.dims = dims;
@@ -2836,6 +2913,7 @@ export class Graph {
     const graph = new Graph();
     graph.dims = this.dims;
     graph.ringRadius = this.ringRadius;
+    graph.seeded = this.seeded;
     graph._tickId = this._tickId;
     graph.onTick = this.onTick;
     graph.relax = this.relax;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
index 34522fe..9cb188f 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/field.ts
@@ -21,7 +21,7 @@
  *   R(d̂)         = (gap/2) / (d̂·û)   for d̂·û > HEAD_ON, else ∞
  *                                                 where a wave MAY stop
  *   SHEET  = 3^(d−1) − 1 = 8      how many charges one pulse is
- *   WAYS   = 3^d − 1     = 26      how many ways out of a point there are —
+ *   DEG   = 3^d − 1     = 26      how many ways out of a point there are —
  *                                  a DIFFERENT number, and the one the
  *                                  counting argument in `gravity.ts` needs
  *   FLOOR                          the innermost shell is not nought cells
@@ -176,7 +176,7 @@ export const SHEET = Math.pow(3, DIMS - 1) - 1;
  * along. `gravity.ts` used `SHEET` for both, which understated the denominator
  * by a factor of 3.25 in three dimensions.
  */
-export const WAYS = Math.pow(3, DIMS) - 1;
+export const DEG = Math.pow(3, DIMS) - 1;
 
 /**
  * The chance that a given cell at radius r is holding one of this source's
@@ -1378,18 +1378,18 @@ export const wave = (v: number, omega: number, sync = 1) =>
  * propagator is, and the pattern is one of its consequences.
  *
  * WHAT IS STILL ASSUMED, and it is now ONE thing rather than a gap: every path
- * gets the SAME MODULUS. Feynman postulates it. `WAYS` looked like the obvious
+ * gets the SAME MODULUS. Feynman postulates it. `DEG` looked like the obvious
  * candidate — every way out of a point equally available — and the argument is
  * three lines:
  *
- *   1. every way out of a point is equally available; that is what WAYS is
+ *   1. every way out of a point is equally available; that is what DEG is
  *   2. a charge takes exactly one step per tick, so path length ∝ time
  *   3. so all paths from A to B in time T have N = T/τ steps and probability
- *      (1/WAYS)^N — the same for every one of them
+ *      (1/DEG)^N — the same for every one of them
  *
  * IT DOES NOT WORK, and the reason is worth more than the argument was. Summed
  * over every 8-neighbour lattice path of 130 steps in two dimensions, with each
- * step weighted 1/WAYS and phased by k·|δ|:
+ * step weighted 1/DEG and phased by k·|δ|:
  *
  *     x       |A|          arg(A)     k·x     fitted k_eff = 0.01616
  *     40      3.17e−7      −3.036     12.0    against k = 0.30
@@ -1406,12 +1406,12 @@ export const wave = (v: number, omega: number, sync = 1) =>
  * exactly c, so every step is LIGHTLIKE and every path has the same proper
  * time: nought. A massive particle's phase is `−mc²∫dτ/ħ`, which along a
  * lightlike path is also nought. A CHARGE'S PATH IS NOT A PARTICLE'S PATH, and
- * `WAYS` counts a charge's options. The path integral needs the worldlines of
+ * `DEG` counts a charge's options. The path integral needs the worldlines of
  * the EMITTER, which moves at v < c and whose available directions are not
- * WAYS at all.
+ * DEG at all.
  *
  * So the flat modulus is not derived, and it failed by exactly the error the
- * `SHEET`/`WAYS` audit in `gravity.ts` was looking for elsewhere: a count used
+ * `SHEET`/`DEG` audit in `gravity.ts` was looking for elsewhere: a count used
  * for a job it is not the count for. Two independent things now point at the
  * same structural gap — the lattice has one kind of mover, and both quantum
  * mechanics and the metric want statements about the other kind.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/figures.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/figures.tsx
new file mode 100644
index 0000000..591d1fc
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/figures.tsx
@@ -0,0 +1,119 @@
+import { useMemo, useRef } from "react";
+
+import { Graph } from "./discrete";
+import { GraphCanvas } from "./GraphCanvas";
+import { Model } from "./model";
+import { ModelView } from "./views";
+
+/**
+ * The two pictures that are about the LATTICE rather than about what happens
+ * on it.
+ *
+ * Everything in `models.ts` is an arrangement of charges and a claim about
+ * what the rules make of it. These two are neither: one is what a cell a tick
+ * looks like, and the other is what a sheet is. They are drawn through the
+ * same canvas as everything else — same camera, same lattice, same grey for
+ * space that has not been charged by anything — because a reader who has been
+ * looking at these pictures for ten screens should not have to work out
+ * whether a new one is the same kind of thing. It is.
+ */
+
+/**
+ * Something travelling at the speed of light: one cell, one tick.
+ *
+ * REMADE EVERY STEP RATHER THAN TICKED, which is the one thing about this
+ * worth knowing. Movement in this model is a swap — the mover eats the point
+ * in front and puts a fresh one down behind — and a fresh point has only the
+ * two connections it was made with, so a ray ticked across a three-deep strip
+ * leaves the row behind it stripped of its transverse connections. The picture
+ * would show the grid coming apart in the wake of the thing crossing it, which
+ * is a true fact about moving through space and completely the wrong sentence
+ * for a diagram that is only saying `a cell a tick`.
+ *
+ * So each step is a fresh patch with the ray one cell further along, and the
+ * loop comes round when it reaches the rim — where it is drawn facing out of
+ * the world, since that is what it is about to do. `ticks: 0` is what asks the
+ * player for that: the frame loop re-seeds every interval instead of ticking,
+ * and the seed is what carries the position. (The transport's step button
+ * still ticks the universe for real, which is the rule rather than the
+ * diagram; reset puts the diagram back.)
+ */
+export const Beam = ({
+  length = 10, rows = 3, height = 120, interval = 0.4,
+}: {
+  length?: number, rows?: number, height?: number, interval?: number,
+} = {}) => {
+  // How far along it has got. A ref rather than state: nothing re-renders when
+  // it changes, since what reads it is the seed and the seed is called by the
+  // frame loop.
+  const at = useRef(0);
+
+  const model = useMemo((): Model => ({
+    name: '',
+    lattice: {
+      seed: () => Graph.patch({
+        shape: [length, rows],
+        moving: {
+          at: [(at.current++ % length) - Math.floor(length / 2), 0],
+          towards: [1, 0],
+        },
+      }),
+      ticks: 0,
+      interval,
+      height,
+      density: false,
+      polarities: false,
+    },
+  }), [length, rows, height, interval]);
+
+  return <ModelView model={model} />;
+};
+
+/**
+ * The sheet: the twenty-seven cells around a point, and the eight of them a
+ * pulse leaves into — still, and then turning.
+ *
+ * Side by side rather than one picture with a control on it, because the two
+ * are a single sentence: THIS is what is emitted, and THIS is what emitting it
+ * over and over while turning covers. The still one is where the eight can be
+ * counted (the 3×3 with its middle taken out); the turning one is where it can
+ * be seen that one rotation is enough to reach everywhere, which is the step of
+ * the derivation that fixes the count at eight rather than at twenty-six.
+ *
+ * Neither of them ticks. There is no universe running here — the lattice is a
+ * still 3×3×3 patch with nothing moving in it, and the only thing that moves
+ * is the sheet, which `GraphCanvas` turns itself.
+ */
+export const Sheet = ({ height = 240 }: { height?: number } = {}) => {
+  // One each, so neither canvas is drawing a graph the other is also holding.
+  // Nothing ticks them, so this is only tidiness — but a shared universe
+  // between two views is exactly the sort of thing that stops being tidiness
+  // the moment one of them is given something to do.
+  const still = useMemo(() => Graph.patch({ shape: [3, 3, 3] }), []);
+  const turning = useMemo(() => Graph.patch({ shape: [3, 3, 3] }), []);
+
+  return <div style={{
+    display: 'grid',
+    // Two columns, and not `auto-fit` with a minimum: the pair IS the sentence
+    // — this, and this turned — and a reader who has to scroll from one to the
+    // other to compare them is being shown two pictures instead of one
+    // comparison. Half a narrow column each is still a legible 3×3×3.
+    gridTemplateColumns: '1fr 1fr',
+    gap: '1rem',
+    alignItems: 'start',
+  }}>
+    <div style={{ height }}>
+      <GraphCanvas graph={() => still} density={false} polarities={false} sheet={{}} />
+    </div>
+
+    <div style={{ height }}>
+      <GraphCanvas
+        graph={() => turning}
+        animate
+        density={false}
+        polarities={false}
+        sheet={{ turning: true }}
+      />
+    </div>
+  </div>;
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index fd66c6d..bd3ff32 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -26,7 +26,7 @@
  *   two things are is the only thing that has ever moved it. See `GRAIN`.
  *
  *   what a count of annihilations does to a body:
- *     BIAS        = LIGHT / WAYS                   what one of them buys, and
+ *     BIAS        = LIGHT / DEG                   what one of them buys, and
  *                                                  the only constant here
  *     u̇_a         = BIAS · S(a,b) / m_a · carry    ÷ its OWN mass, which is
  *                                                  the equivalence principle
@@ -43,7 +43,7 @@
  *   a carried point source has a steady state, which is a Green's function:
  *
  *     S           = m·SHEET                        what a body makes a tick
- *     D           = π·WAYS·c/(3·BITE·SHEET) = 3.4  how fast a move spreads it
+ *     D           = π·DEG·c/(3·BITE·SHEET) = 3.4  how fast a move spreads it
  *     δ(r)        = S/(4π·D·r) = 3u                STATIC, and 1/r
  *     ⇒  u        = G·m/(r c²)                     the metric's own potential,
  *                                                  out of a rate and a spread
@@ -63,7 +63,7 @@
  *   across it, which is special relativity's own response; and ÷ m_a leaves
  *   a_a ∝ m_b/R², so a feather and a hammer fall together.
  *
- *   G           = BITE·SHEET²·c / (8π²·HALF·WAYS)  the far limit of `met`, in
+ *   G           = BITE·SHEET²·c / (8π²·HALF·DEG)  the far limit of `met`, in
  *                                                  closed form, and IN THE
  *                                                  LATTICE'S OWN UNITS — a
  *                                                  step, a tick, half a step
@@ -85,7 +85,7 @@
  */
 
 
-import { chance, HALF, Live, SHEET, through, WAYS } from "./field";
+import { chance, HALF, Live, SHEET, through, DEG } from "./field";
 import { BITE, LIGHT } from "./physics";
 
 /**
@@ -206,8 +206,8 @@ const EMIT = SHEET / (4 * Math.PI);
  * Which is a counting argument and it fixes everything, with no constant:
  *
  *     weight of the way it went      1 + n
- *     weight of each other way       1,  and there are WAYS of them
- *     net bias                       LIGHT · n / WAYS
+ *     weight of each other way       1,  and there are DEG of them
+ *     net bias                       LIGHT · n / DEG
  *
  * LINEAR in the count, with nothing in it about how fast the thing is already
  * going. So the bias is proportional to the number of annihilations
@@ -216,7 +216,7 @@ const EMIT = SHEET / (4 * Math.PI);
  * speed, and it is the whole of the one-over-time this file could not
  * previously account for. Gravity is an acceleration because space remembers.
  *
- * WAYS AND NOT SHEET, which this had wrong. `SHEET` is how many charges a
+ * DEG AND NOT SHEET, which this had wrong. `SHEET` is how many charges a
  * source lets go of in one pulse — the plane it pulses into, eight in three
  * dimensions. What belongs in the denominator here is how many OTHER
  * directions the biased path could have taken instead, which is every way out
@@ -226,13 +226,13 @@ const EMIT = SHEET / (4 * Math.PI);
  *
  * It moves `GRAVITY` by the same 3.25 and cancels straight back out of every
  * orbit, because `models.ts` divides the masses by `GRAVITY` — exactly as
- * `BITE` does. What it does change is the saturation `n/(WAYS + n)`, which is
+ * `BITE` does. What it does change is the saturation `n/(DEG + n)`, which is
  * a real threshold rather than a scale, and is what any accumulated folding
  * gets read against.
  *
  * This is the only constant in the dynamics, and it is a ratio of two counts.
  */
-export const BIAS = LIGHT / WAYS;
+export const BIAS = LIGHT / DEG;
 
 /**
  * And what a bias comes to as a speed IN THE PICTURE — which is not the same
@@ -353,13 +353,13 @@ export const count = (
  * THE SECOND THING THE COUNT SAYS, which was being computed and thrown away.
  *
  * `BIAS` above reads the count as a RATIO: the way that took an annihilation
- * weighs `1 + n` against the `WAYS` out that weigh one each, so a path leans by
- * `LIGHT·n/WAYS`. That is the first moment of the count — WHICH WAY the extra
+ * weighs `1 + n` against the `DEG` out that weigh one each, so a path leans by
+ * `LIGHT·n/DEG`. That is the first moment of the count — WHICH WAY the extra
  * weight points — and it is the whole of the pull, and it is worth exactly one
  * sixth of Mercury's perihelion advance and nothing at all of light.
  *
  * What is thrown away is the TOTAL. The ways out of that point no longer number
- * `WAYS`; they number `WAYS + n`. The line above this one used to say "while
+ * `DEG`; they number `DEG + n`. The line above this one used to say "while
  * every other way out of the point still weighs exactly what it always did",
  * and that is true and is not the point: every other way weighs one, and there
  * are now more of them. A point with more ways out of it holds more space, so a
@@ -472,13 +472,13 @@ export const count = (
  *
  * `slowing` and `thickness` are general relativity's isotropic functions,
  * borrowed. The counting story says they should not have to be: a place has
- * WAYS + n ways out, the LEAN is a ratio (A) and what a ratio throws away is
+ * DEG + n ways out, the LEAN is a ratio (A) and what a ratio throws away is
  * the TOTAL (B). The only question is how the count composes.
  *
- *     ADDITIVE         weight of the way it went = 1 + n        √A = WAYS/(WAYS+n)
- *     MULTIPLICATIVE   each annihilation multiplies by 1+1/WAYS  √A = (1+1/WAYS)^−n
+ *     ADDITIVE         weight of the way it went = 1 + n        √A = DEG/(DEG+n)
+ *     MULTIPLICATIVE   each annihilation multiplies by 1+1/DEG  √A = (1+1/DEG)^−n
  *
- * and `(1+1/WAYS)^n = exp(n·ln(1+1/WAYS)) → exp(n/WAYS) = exp(u)`, so
+ * and `(1+1/DEG)^n = exp(n·ln(1+1/DEG)) → exp(n/DEG) = exp(u)`, so
  *
  *     A = exp(−2u)      B = exp(+2u)      A·B = 1 exactly
  *
@@ -522,9 +522,9 @@ export const count = (
  * reasoning this file refuses everywhere else. Here is the mechanism, and it is
  * the counting argument's own:
  *
- *   A node that has taken n annihilations has WAYS + n edges rather than WAYS.
+ *   A node that has taken n annihilations has DEG + n edges rather than DEG.
  *   Edges are shared with neighbours, so THE SAME n EXTRA EDGES POINT INTO IT.
- *   A charge wandering nearby is therefore (WAYS + n)/WAYS times more likely to
+ *   A charge wandering nearby is therefore (DEG + n)/DEG times more likely to
  *   arrive there than at an unfolded node.
  *
  *     MORE ARRIVALS → MORE ANNIHILATIONS → MORE FOLDING → MORE ARRIVALS.
@@ -545,8 +545,8 @@ export const count = (
  * `1 + u = e^u₀`, exactly, with nothing chosen. Then the same two readings as
  * before — the lean and the total — give
  *
- *     √A = WAYS/(WAYS+n) = 1/(1+u) = e^−u₀
- *     √B = (WAYS+n)/WAYS = (1+u)   = e^+u₀
+ *     √A = DEG/(DEG+n) = 1/(1+u) = e^−u₀
+ *     √B = (DEG+n)/DEG = (1+u)   = e^+u₀
  *     ⇒  A = e^−2u₀,  B = e^+2u₀,  A·B = 1
  *
  * which is the metric measured above to give general relativity's perihelion
@@ -559,10 +559,10 @@ export const count = (
  * this file's own panels. Nothing measured moves.
  *
  * AND NO HORIZON, IN ONE LINE. A horizon needs √A = 0, so 1 + u = ∞, so n = ∞:
- * a node would have to have INFINITELY MANY WAYS OUT. Each annihilation adds
+ * a node would have to have INFINITELY MANY DEG OUT. Each annihilation adds
  * one and a finite mass sends finitely many charges, so it never gets there.
  * At what general relativity calls the horizon (u₀ = 2) the node has 6.4 extra
- * ways out per WAYS — a lot, and not infinity. Light leaves, redshifted by
+ * ways out per DEG — a lot, and not infinity. Light leaves, redshifted by
  * e² = 7.4. That is the sharpest falsifiable claim in this file, and unlike the
  * rest of it, it is one the astronomers are already testing.
  *
@@ -626,8 +626,8 @@ export const thickness = (fold: number) => Math.exp(2 * Math.max(fold, 0));
  *
  * FIRST, THE EDGE COUNT SLOWS THE CLOCK BY √A. The checkerboard's clock is the
  * REVERSAL rate — the chance of taking the one turning direction rather than
- * carrying on — which at an unfolded node is 1 in WAYS and at a folded one is
- * 1 in WAYS + n. So `m_eff = m·WAYS/(WAYS+n) = m/(1+u)`, and the compounding
+ * carrying on — which at an unfolded node is 1 in DEG and at a folded one is
+ * 1 in DEG + n. So `m_eff = m·DEG/(DEG+n) = m/(1+u)`, and the compounding
  * already says `1 + u = e^{u₀}`:
  *
  *     u₀      m_eff/m = e^−u₀   √A = √(e^−2u₀)    diff
@@ -664,7 +664,7 @@ export const thickness = (fold: number) => Math.exp(2 * Math.max(fold, 0));
  * POSITION-DEPENDENT CHECKERBOARD was built and run.
  *
  * The fold hands the walk ONE number and not two. A node folded by u₀ has
- * WAYS + n edges, and every edge is diluted by the same `e^{−u₀}` — there is
+ * DEG + n edges, and every edge is diluted by the same `e^{−u₀}` — there is
  * no way to thin the turning edge and not the carrying one, since it is the
  * same count in the same denominator. Which is worth pausing on, because it
  * says the whole of gravity is a POSITION-DEPENDENT TICK RATE and nothing
@@ -772,7 +772,7 @@ export const carry = (px: number, py: number, fold: number) => {
  * at all: a 1/r² density integrated radially outward IS 1/r, one integration
  * and nothing free. It gets the shape, it is a fact about a place rather than
  * about a pair, and it PREDICTS G instead of absorbing it — wrongly, by
- * `π·WAYS/(3·SHEET)` exactly. A pure count, so a finite thing to hunt. See the
+ * `π·DEG/(3·SHEET)` exactly. A pure count, so a finite thing to hunt. See the
  * bottom of `SPREAD`.
  *
  * THE ELEVENTH IS THE OTHER INFORMATIVE ONE. It has a
@@ -1363,7 +1363,7 @@ export const annihilation = (
  *     ∫₀^∞ chance(m_a, x) dx = m_a·SHEET/(4π) · 2/HALF     ... the core, twice
  *     two ends, BITE a meeting, half of them opposite
  *
- *     G = BITE·½·4 · (SHEET/4π)² / CORE · BIAS = SHEET²/(4π²·CORE·WAYS)
+ *     G = BITE·½·4 · (SHEET/4π)² / CORE · BIAS = SHEET²/(4π²·CORE·DEG)
  *
  * — 0.124726, and checked against the integral itself at a converged sample
  * count out to a million cells, where it agrees to two parts in a thousand.
@@ -1403,7 +1403,7 @@ export const annihilation = (
  * proportionally more paths to the meeting.
  */
 export const G_LATTICE =
-  BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+  BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 
 /**
  * And the same constant in the units a panel is drawn in, which is the only
@@ -1466,7 +1466,7 @@ export const GRAVITY = G_LATTICE * GRAIN;
  *
  *     δ(r)  = ε·m·SHEET / (4π r c)          what the flux leaves at r
  *     δ     = B^(3/2) − 1 = 3u,  u = GM/rc²
- *     ⇒ ε   = 12π·G/(SHEET·c) = 3·BITE·SHEET/(π·WAYS)
+ *     ⇒ ε   = 12π·G/(SHEET·c) = 3·BITE·SHEET/(π·DEG)
  *
  * — a pure count, no `GRAIN` in it, and about a third of a point per charge
  * per tick. That is the whole of the prediction, and it is the number a lattice
@@ -1501,7 +1501,7 @@ export const GRAVITY = G_LATTICE * GRAIN;
  * vacuum worth the name. A vacuum dense enough to carry anything is dense
  * enough to switch gravity off within about seven steps.
  */
-export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
+export const MADE = 3 * BITE * SHEET / (Math.PI * DEG);
 
 /**
  * HOW FAST THE SURPLUS SPREADS — and the one account still standing.
@@ -1560,7 +1560,7 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  * WHAT D HAS TO BE. Setting `δ = 3u` (a volume excess is three times the u in
  * B = 1 + 2u) and `u = GM/rc²`:
  *
- *     D = SHEET·c² / (12π·G) = π·WAYS·c / (3·BITE·SHEET) = 3.403
+ *     D = SHEET·c² / (12π·G) = π·DEG·c / (3·BITE·SHEET) = 3.403
  *
  * — a pure count, no GRAIN, and order one. For a lattice whose things move a
  * step a tick that is a mean free path of about three steps, which is an
@@ -1582,7 +1582,7 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  * with λ the distance between scatters. So the account is only as good as the
  * λ the lattice can supply, and that is a question with an answer.
  *
- * WHAT D DEMANDS.  λ = 3D/c = π·WAYS/SHEET = 10.21 cells.
+ * WHAT D DEMANDS.  λ = 3D/c = π·DEG/SHEET = 10.21 cells.
  *
  * WHAT THE LATTICE HAS. Diffusion needs a CONSTANT-density scatterer, because
  * a constant D is the only thing that gives 1/r — source it from the body's own
@@ -1657,9 +1657,9 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  * it. Setting `∫δ = 3u` and `u = G·m/(rc²)`:
  *
  *     predicted    G = SHEET·c/(12π)      = 0.21220659
- *     the pull's   G = SHEET²/(4π²·WAYS)  = 0.06235150
+ *     the pull's   G = SHEET²/(4π²·DEG)  = 0.06235150
  *     ratio                                 3.403392
- *     π·WAYS/(3·SHEET)                      3.403392
+ *     π·DEG/(3·SHEET)                      3.403392
  *     SPREAD                                3.403392
  *
  * THE THREE ARE ONE NUMBER, and that says what `SPREAD` actually is. It is NOT
@@ -1670,45 +1670,45 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  *
  * WHICH IS A FAR BETTER PLACE TO BE STUCK. Before: an unfound coefficient and a
  * mechanism needing a length the lattice has not got. Now: two routes, both
- * counted, neither with a free parameter, disagreeing by `π·WAYS/(3·SHEET)`
+ * counted, neither with a free parameter, disagreeing by `π·DEG/(3·SHEET)`
  * exactly — a pure count, so a statement about the lattice's geometry and
  * nothing else. Something in one of the two counts is wrong and it is a
  * COUNTABLE thing. That is a finite search, which "unfound" never was.
  *
- * AND THE FIX IS NOT A COEFFICIENT. The two agree iff `WAYS/SHEET = 3/π`:
+ * AND THE FIX IS NOT A COEFFICIENT. The two agree iff `DEG/SHEET = 3/π`:
  *
- *     d = 2   WAYS 8     SHEET 2    ratio 4.0000
- *     d = 3   WAYS 26    SHEET 8    ratio 3.2500      want 0.9549
- *     d = 4   WAYS 80    SHEET 26   ratio 3.0769
- *     d = 5   WAYS 242   SHEET 80   ratio 3.0250
+ *     d = 2   DEG 8     SHEET 2    ratio 4.0000
+ *     d = 3   DEG 26    SHEET 8    ratio 3.2500      want 0.9549
+ *     d = 4   DEG 80    SHEET 26   ratio 3.0769
+ *     d = 5   DEG 242   SHEET 80   ratio 3.0250
  *
- * `3/π` is irrational and `WAYS/SHEET` is a ratio of integers that tends to 3
+ * `3/π` is irrational and `DEG/SHEET` is a ratio of integers that tends to 3
  * from above, so no dimension closes it and no lattice of this shape can. The
  * two counts cannot both be right AS THEY STAND. Since they are not even the
- * same kind of count — SHEET is what a source EMITS, WAYS is what a path could
+ * same kind of count — SHEET is what a source EMITS, DEG is what a path could
  * have DONE INSTEAD — the honest reading is that one of them is being used for
  * a job it is not the count for, which is the same mistake `gravity.ts` already
- * made once and recorded under `WAYS`.
+ * made once and recorded under `DEG`.
  *
- * THE AUDIT, done. `WAYS` enters the DYNAMICS in exactly one place — `BIAS` —
+ * THE AUDIT, done. `DEG` enters the DYNAMICS in exactly one place — `BIAS` —
  * and `SHEET` in `chance` and `reach`. Everything else (G, MADE, SPREAD) is
  * built from those. So there are three places the error can be, and they can be
  * ranked:
  *
  *   substituting into BIAS      G_pull       ratio to G_metric
- *     WAYS   (current)          0.06235150   3.403392
+ *     DEG   (current)          0.06235150   3.403392
  *     SHEET                     0.20264237   1.047198   ← π/3
- *     WAYS−1                    0.06484556   3.272492
- *     WAYS+1                    0.06004218   3.534292
+ *     DEG−1                    0.06484556   3.272492
+ *     DEG+1                    0.06004218   3.534292
  *
  * `SHEET` in `BIAS` closes it from three and a half TIMES to four and a half
  * PER CENT — and the residual is exactly π/3. That is a striking near miss and
- * it is NOT a fix: the argument for WAYS is good (alternatives a path could
+ * it is NOT a fix: the argument for DEG is good (alternatives a path could
  * have taken, not charges emitted) and 4.7% is not nought. It is recorded
  * because a residual of exactly π/3 is either meaningless or the whole answer,
  * and those can be told apart by finding where a π/3 would live.
  *
- * Keeping WAYS, the metric route's `k` would have to be `π·WAYS/SHEET = 10.21`
+ * Keeping DEG, the metric route's `k` would have to be `π·DEG/SHEET = 10.21`
  * instead of 3 — and 3 was there because a VOLUME excess is three times a
  * linear one, which is DIMS. 10.21 is not a metric factor at all, so the
  * discrepancy cannot be hidden in `k` without throwing away the only reason `k`
@@ -1727,7 +1727,7 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  *
  * Ranked, most likely wrong first:
  *   1. the identification ∫δ = 3u   a choice, unargued
- *   2. BIAS's WAYS                  argued, but sits π/3 from closing it
+ *   2. BIAS's DEG                  argued, but sits π/3 from closing it
  *   3. the pull's own geometry      checked hardest, least likely
  *
  * AND THE AUDIT POINTS AT A ROUTE NOBODY HAS RUN — worked out here, not yet
@@ -1735,26 +1735,26 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  *
  * The pull works because it is a PRODUCT of two fields integrated along a line,
  * `chance_a · chance_b`, and that product is where the extra 1/r comes from and
- * where WAYS enters, one `BIAS` per annihilation. The metric route has one body,
- * so it has no second field, no line integral and no WAYS — which is the exact
+ * where DEG enters, one `BIAS` per annihilation. The metric route has one body,
+ * so it has no second field, no line integral and no DEG — which is the exact
  * shape of the 3.4034.
  *
  * BUT A LONE BODY IS NOT ALONE. Its charges annihilate against the AMBIENT
  * FIELD Φ, the same Φ `reach` is built on, and that restores all three:
  *
  *     annihilation rate at r   ∝  BITE · chance(m,r) · Φ · share
- *     acceleration             =  BIAS · that                    (so a 1/WAYS)
- *     u = ∫a dr                ∝  m·SHEET·Φ / (4π·r·WAYS)        ← 1/r
+ *     acceleration             =  BIAS · that                    (so a 1/DEG)
+ *     u = ∫a dr                ∝  m·SHEET·Φ / (4π·r·DEG)        ← 1/r
  *
  * — the same structure as `shortfall`, with the vacuum standing in for the
  * second body. Matching `u = Gm/rc²` then fixes Φ outright:
  *
- *     Φ = 4π·WAYS·G/SHEET = 2.546479  =  SHEET/π, exactly
+ *     Φ = 4π·DEG·G/SHEET = 2.546479  =  SHEET/π, exactly
  *
  * AND THE COSMOLOGY ATTRACTOR ALREADY SAYS Φ = 2 EXACTLY (closure 2 under
  * `REACHES`), from a completely unrelated argument — the cascade's fixed point.
  * The two agree to 27%, and the residual is a bare 4/π. Pinning Φ at 2 gives
- * `G = SHEET·Φ/(4π·WAYS) = 0.04897` against the pull's 0.06235, ratio 4/π.
+ * `G = SHEET·Φ/(4π·DEG) = 0.04897` against the pull's 0.06235, ratio 4/π.
  *
  * WHICH IS THE FIRST TIME A CHANGE OF MECHANISM HAS MOVED THAT NUMBER AT ALL —
  * from 3.4034, a mixture of counts, to a bare π. And there is an obvious place
@@ -1817,7 +1817,7 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  *
  * Every failure so far took `D` from SCATTERING — how far a charge gets before
  * meeting something — and the vacuum cannot make that short. But a created
- * point that simply sits for a tick and then takes one of the `WAYS` at random
+ * point that simply sits for a tick and then takes one of the `DEG` at random
  * is a random walk with NO SCATTERER IN IT. `D` is then a fact about the
  * lattice, and Φ is not in the problem at all:
  *
@@ -1849,8 +1849,8 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  * a per cent from p = 0 to p = 0.9, so the number is right.
  *
  * AND A CLAIMED COINCIDENCE HERE WAS SPURIOUS, which is worth recording because
- * it was nearly chased. This said the run length was "10.21 cells = π·WAYS/SHEET,
- * a pure count". It is not. 10.21 is `3D/c`, which IS `π·WAYS/SHEET` BY
+ * it was nearly chased. This said the run length was "10.21 cells = π·DEG/SHEET,
+ * a pure count". It is not. 10.21 is `3D/c`, which IS `π·DEG/SHEET` BY
  * CONSTRUCTION — it is `SPREAD` rewritten, not a second fact about anything.
  * The physical run length is 7.67 cells, and the two differ by 33%. The
  * appearance of a pure count sitting in plain sight came from comparing a
@@ -1880,7 +1880,7 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  * So the third is the only survivor and it is not a derivation.
  *
  * ---------------------------------------------------------------------------
- * AND BOTH WAYS OUT OF THAT WERE TESTED, AND BOTH CLOSE — by argument this
+ * AND BOTH DEG OUT OF THAT WERE TESTED, AND BOTH CLOSE — by argument this
  * time, rather than by a measurement coming out wrong.
  *
  * FIRST: IS THE UNIFORMITY A THEOREM? Let the turner have density ∝ r^−n, so
@@ -1932,7 +1932,7 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  *
  * All of it assumed B needs ITS OWN SOURCE — a surplus, made somewhere, carried
  * somehow. But the file's own `METRIC` story says otherwise: a place has
- * WAYS + n ways out, the LEAN is a ratio (that is A) and the TOTAL is what a
+ * DEG + n ways out, the LEAN is a ratio (that is A) and the TOTAL is what a
  * ratio throws away (that is B). Same count, read twice. If that is right, B is
  * not sourced separately at all and the surplus programme was solving a problem
  * that is not there.
@@ -1943,7 +1943,7 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  *
  *     account                                     γ       β     perihelion  deflection
  *     GR, isotropic — what the file uses          1.000   1.000   1.0001     1.0000
- *     √A = WAYS/(WAYS+n), √B = (WAYS+n)/WAYS      1.000   1.500   0.8334     1.0000
+ *     √A = DEG/(DEG+n), √B = (DEG+n)/DEG      1.000   1.500   0.8334     1.0000
  *     A·B = 1 with B = 1 + 2u exactly             1.000   2.000   0.6668     1.0000
  *     Newton, no metric                           0.000   0.000   0.6667     0.5000
  *
@@ -1979,7 +1979,7 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  * whether it is linear all the way up.
  *
  * SO THE GAP IS NOT WHERE THE LAST WEEK PUT IT. It is not a transport rule and
- * not a diffusivity. It is whether `1 + n` should be `(1 + 1/WAYS)^n`, and that
+ * not a diffusivity. It is whether `1 + n` should be `(1 + 1/DEG)^n`, and that
  * question is one line of the counting argument rather than a new mechanism.
  * What follows below stands as the record of the source-and-carry programme,
  * which is now of interest mainly for the two no-gos it established.
@@ -1991,7 +1991,7 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  * CONSISTENT, and that constant has no mechanism behind it in either account.
  *
  * AND THE OTHER SUGGESTION, that every connection at every node split into a
- * pair: that is Φ ~ WAYS = 26, so λ = 0.077 cells and gravity is dead in a
+ * pair: that is Φ ~ DEG = 26, so λ = 0.077 cells and gravity is dead in a
  * tenth of a step — thirteen times worse than the Φ = 2 attractor, which was
  * already fatal. Nor does the aggregate bouncing back rescue it: pairs that
  * recombine are net nothing (`BITE` = 1) and pairs that do not ARE the fog.
@@ -2003,7 +2003,7 @@ export const MADE = 3 * BITE * SHEET / (Math.PI * WAYS);
  * under `carry` are now twelve, and the twelfth is the first that fails by a
  * stated finite amount instead of by a shape or by sixty orders.
  */
-export const SPREAD = Math.PI * WAYS * LIGHT / (3 * BITE * SHEET);
+export const SPREAD = Math.PI * DEG * LIGHT / (3 * BITE * SHEET);
 
 /**
  * And so what a body puts at a distance, as a fold — which is `settle`'s whole
@@ -2179,7 +2179,7 @@ export const REACHES = Math.sqrt(
  *         REVERSE      it goes back the way it came   extinction
  *
  *     Neither is a soft, forward, small-energy scatter — a step is one cell and
- *     a heading is one of WAYS, so a photon either continues EXACTLY or leaves
+ *     a heading is one of DEG, so a photon either continues EXACTLY or leaves
  *     the line of sight entirely. The beam goes as `e^{−D/λ}` and the survivors
  *     arrive at the frequency they left with. THE MODEL CAN DIM LIGHT AND
  *     CANNOT REDDEN IT, and that is a fact about what a lattice step is rather
@@ -2997,7 +2997,7 @@ export const caught = {
  * second is the smallest acceleration a discrete lattice can represent at all.
  *
  * WHAT WOULD HAVE TO BE SHOWN. `spend` gives `accel = BIAS × (annihilation
- * rate)` with `BIAS = c/WAYS`. A rate below one meeting per t₀ is not a small
+ * rate)` with `BIAS = c/DEG`. A rate below one meeting per t₀ is not a small
  * acceleration — it is NO acceleration, because there is no such event. So a
  * floor is expected near
  *
@@ -3135,7 +3135,7 @@ export const caught = {
  * mechanism is one `BIAS` kick per age then `a₀ = BIAS·κ/t₀`, so
  * `κ = a₀t₀/(c·BIAS) = 4.5323`, and the job is to find 4.5323 from the lattice
  * constants. Building every expression of the form a·b/c, a/(b·c) and √(ab)/c
- * out of sixteen constants the file already owns — SHEET, WAYS, HALF, DIMS,
+ * out of sixteen constants the file already owns — SHEET, DEG, HALF, DIMS,
  * FLOOR, G_LATTICE, π, e, √2, √3, 2π, 4π and friends — gives 12816 expressions,
  * of which:
  *
@@ -3145,10 +3145,10 @@ export const caught = {
  *     within  2%     95              12
  *     within  1%     20               4
  *
- * — the closest being `√(WAYS·π)/2 = 4.51889`, at −0.30%. TWENTY EXPRESSIONS
+ * — the closest being `√(DEG·π)/2 = 4.51889`, at −0.30%. TWENTY EXPRESSIONS
  * LAND INSIDE A PERCENT. A search over numbers cannot tell a derivation from an
  * accident here, so a hit is worth nothing even when it is close, and
- * `√(WAYS·π)/2` is recorded as a curiosity and nothing else. This is the one
+ * `√(DEG·π)/2` is recorded as a curiosity and nothing else. This is the one
  * place where the file's habit — count it, do not fit it — has to be enforced
  * by REFUSING TO LOOK rather than by looking carefully.
  *
@@ -3219,7 +3219,7 @@ export const caught = {
  *
  *     constant         a₀ = K·c/t₀    against 1.200e−10
  *     1/SHEET          8.605e−11      −28.3%
- *     1/WAYS = BIAS    2.648e−11      −77.9%
+ *     1/DEG = BIAS    2.648e−11      −77.9%
  *     1/2π             1.096e−10       −8.7%
  *     HALF/DIMS        1.147e−10       −4.4%
  *
@@ -3267,7 +3267,7 @@ export const caught = {
  *
  * and a rate is linear in each emitter because each emitter emits
  * independently. So any change to the GEOMETRY (how flux spreads), the
- * PROPAGATION (ballistic, diffusive, screened) or the COUNTING (SHEET, WAYS,
+ * PROPAGATION (ballistic, diffusive, screened) or the COUNTING (SHEET, DEG,
  * dimension) moves the r-dependence and LEAVES THE MASS LINEAR:
  *
  *     change                        gives         Tully–Fisher
@@ -3524,7 +3524,7 @@ export const caught = {
  *
  * AND THAT IS THE REAL COST, stated plainly: a₀ BECOMES A NEW FUNDAMENTAL
  * CONSTANT — the strength with which layer two's field gravitates in layer one
- * — rather than something counted out of SHEET and WAYS. For a model whose
+ * — rather than something counted out of SHEET and DEG. For a model whose
  * whole method is counting, that is a genuine loss, and it belongs in the
  * ledger rather than hidden inside a κ.
  *
@@ -3845,10 +3845,10 @@ export const caught = {
  * AND THE ONE LIVE CANDIDATE HAS A CANDIDATE MECHANISM — LOCK LAYER TWO TO
  * LAYER ONE'S SHEET.
  *
- * SHEET IS ALREADY THE MODEL'S TWO-DIMENSIONAL OBJECT. `WAYS = 3³ − 1 = 26` is
+ * SHEET IS ALREADY THE MODEL'S TWO-DIMENSIONAL OBJECT. `DEG = 3³ − 1 = 26` is
  * every direction out of a cell; `SHEET = 3² − 1 = 8` is the directions in ONE
  * PLANE through it. And `chance(m,r) = m·SHEET/shell(r)` already uses SHEET
- * rather than WAYS — the pull was always counted through a plane. So this is
+ * rather than DEG — the pull was always counted through a plane. So this is
  * not adding a structure; it is taking one the file already has and making it
  * BIND.
  *
@@ -4619,7 +4619,7 @@ export const caught = {
  *     + feedback, saturated (κ ≥ 10⁹)          19.8%    3.25
  *     wanted                                   < 5%     3.85 ± 0.09
  *
- * THE TWO REQUIREMENTS PULL OPPOSITE WAYS. Weak feedback keeps the shape and
+ * THE TWO REQUIREMENTS PULL OPPOSITE DEG. Weak feedback keeps the shape and
  * leaves the slope at the caught pair's own 2.51; strong enough feedback to
  * move the slope crushes the inner disc, and the curve starts RISING outward —
  * v(30) = 264.9 against v(8) = 229, where Gaia has it falling. The best joint
@@ -5206,7 +5206,7 @@ export const caught = {
  * the comparison that matters. See `tests/genzel2.ts` and `tests/fair.ts`.
  *
  * AND THEN THE DIRECTION, WHICH IS THE PART NOBODY HAD ASKED. A carrier
- * streaming along ĝ occupies the cell in that direction; the point has `WAYS`
+ * streaming along ĝ occupies the cell in that direction; the point has `DEG`
  * exits and only the occupied ones are shut, so the pair goes out with the
  * field direction REMOVED. That is an anisotropic source, and it costs a
  * projection:
@@ -5413,7 +5413,7 @@ export const caught = {
  * WHAT INPUTS EXIST AT ALL — this is the whole list, and a derivation can use
  * nothing else:
  *
- *     counted      SHEET = 8, WAYS = 26, BITE = 1, G_LATTICE = 0.0623515
+ *     counted      SHEET = 8, DEG = 26, BITE = 1, G_LATTICE = 0.0623515
  *     units        cell = ℓ_P, tick = t_P, fixed by the calibration
  *     dynamical    t₀ = 8.078e+60 ticks — an AGE, not a constant
  *
@@ -5487,7 +5487,7 @@ export const caught = {
  *                which is the same average that corrected the screening
  *                geometry at the head of `shows`.
  *
- * They pull OPPOSITE WAYS — fewer meetings means the threshold sits at a higher
+ * They pull OPPOSITE DEG — fewer meetings means the threshold sits at a higher
  * density and a₀ goes up; a larger relative speed means more meetings and a₀
  * goes down:
  *
@@ -6055,9 +6055,9 @@ export const sharing = (mass: number, R: number) =>
  * AND WHAT IF MATTER IN A FOLDED PLACE CAN EMIT MORE — a second feedback, and
  * the one that would restore horizons.
  *
- * A node that has taken n annihilations has WAYS + n edges. `SHEET` is how many
+ * A node that has taken n annihilations has DEG + n edges. `SHEET` is how many
  * of them a pulse goes into, so a source SITTING THERE lets go of
- * `SHEET·(WAYS+n)/WAYS = SHEET·(1+u)` charges a pulse. Emission is mass, so
+ * `SHEET·(DEG+n)/DEG = SHEET·(1+u)` charges a pulse. Emission is mass, so
  *
  *     M_eff = M·(1 + κu)          κ = 1 if the sheet scales with the edges
  *
@@ -6093,7 +6093,7 @@ export const sharing = (mass: number, R: number) =>
  * IT SURVIVES ONLY AS A DEEP-FIELD EFFECT. β is a statement about the u² term,
  * so a boost beginning at u³, or above a threshold, leaves the weak field alone
  * and still diverges eventually. And the threshold is not invented: `BIAS`
- * saturates as `n/(WAYS+n)`, which turns over when n ~ WAYS, i.e. u ~ 1 — which
+ * saturates as `n/(DEG+n)`, which turns over when n ~ DEG, i.e. u ~ 1 — which
  * is where the counting argument already changes character, and is exactly
  * where the divergence would sit.
  *
@@ -6121,7 +6121,7 @@ export const sharing = (mass: number, R: number) =>
  */
 
 /**
- * TWO WAYS TO MAKE A DARK OBJECT, AND THE MODEL KEEPS BOTH.
+ * TWO DEG TO MAKE A DARK OBJECT, AND THE MODEL KEEPS BOTH.
  *
  * They are not rivals to be settled by argument — they predict different
  * things, so they are settled by looking. `regimes.ts` carries `boost` for the
@@ -6143,7 +6143,7 @@ export const sharing = (mass: number, R: number) =>
  * ─────────────────────────────────────────────────────────────────────────────
  * ROUTE TWO — DARK BY HORIZON. A genuine one.
  *
- * A node with WAYS + n edges has more ways for a source SITTING THERE to pulse
+ * A node with DEG + n edges has more ways for a source SITTING THERE to pulse
  * into, so `SHEET → SHEET(1+u)` and emission — which is mass — is boosted:
  *
  *     M_eff = M(1 + κu)   ⇒   u = u₀/(1 − κu₀)
@@ -6161,8 +6161,8 @@ export const sharing = (mass: number, R: number) =>
  *                        perihelion advance is EIGHT sixths where the panels
  *                        measure six — 33% high, excluded by three thousand.
  *                        So the boost must begin above u², at a threshold
- *                        nobody has derived. `BIAS` saturating as n/(WAYS+n)
- *                        turns over at n ~ WAYS, i.e. u ~ 1, which is at least
+ *                        nobody has derived. `BIAS` saturating as n/(DEG+n)
+ *                        turns over at n ~ DEG, i.e. u ~ 1, which is at least
  *                        where such a threshold would naturally sit.
  *
  * ─────────────────────────────────────────────────────────────────────────────
@@ -6254,13 +6254,13 @@ export const sharing = (mass: number, R: number) =>
  * decides both.
  *
  * (A) AND BEING CONSISTENT MAKES IT WORSE. If SHEET scales with the edges then
- * so does WAYS — both are edge counts — and `G = BITE·SHEET²·LIGHT/(8π²·CORE·WAYS)`
+ * so does DEG — both are edge counts — and `G = BITE·SHEET²·LIGHT/(8π²·CORE·DEG)`
  * then scales as (1+u) too. With M_eff also boosted, `u = u₀(1+u)²`:
  *
  *     what scales                        k     β      perihelion
  *     nothing (the model as it stands)   0     1.0    1.0000    allowed
  *     SHEET only                         1     0.0    1.3333    EXCLUDED
- *     SHEET and WAYS together            2    −1.0    1.6667    EXCLUDED
+ *     SHEET and DEG together            2    −1.0    1.6667    EXCLUDED
  *
  * TEN SIXTHS where the panels measure six. Keeping the counts consistent
  * doubles the damage rather than cancelling it, and β is known to 3·10⁻⁴, so
@@ -6274,7 +6274,7 @@ export const sharing = (mass: number, R: number) =>
  *
  * which DIVERGES at
  *
- *     R_c = √(3/4πG) = √(3π·WAYS)/SHEET = 1.9567 cells
+ *     R_c = √(3/4πG) = √(3π·DEG)/SHEET = 1.9567 cells
  *
  * — a pure count. So R_c is approached from below and never passed:
  *
@@ -6314,7 +6314,7 @@ export const sharing = (mass: number, R: number) =>
  *
  *     r_areal = r·√B = r·e^{u}          B = e^{2u},  u = GM/rc²
  *
- * — which is the same statement as "a node with WAYS + n edges touches far more
+ * — which is the same statement as "a node with DEG + n edges touches far more
  * than a cell's worth of neighbours", measured rather than counted.
  *
  * AND IT DOES NOT SHRINK TO NOTHING. `d/dr (r e^{GM/r}) = e^{GM/r}(1 − GM/r)`,
@@ -6333,7 +6333,7 @@ export const sharing = (mass: number, R: number) =>
  *
  * SO THE OBJECT IS TWO CELLS ACROSS AND ENORMOUS AT ONCE. A solar mass at R_c
  * has u = 4.7·10³⁷, so an areal radius of 10^(2.0·10³⁷) cells — a number with
- * ten-to-the-thirty-seven digits — and its node carries WAYS(1+u) = 1.2·10³⁹
+ * ten-to-the-thirty-seven digits — and its node carries DEG(1+u) = 1.2·10³⁹
  * edges. Those two are the same fact. (That figure uses the EXTERIOR u = GM/r
  * where the interior solution actually applies; for a uniform ball u_centre is
  * 1.5× the surface value, so the conclusion is unchanged in kind and the exact
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 1a359e9..6d72b28 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -1,4 +1,4 @@
-import { Fragment, ReactNode, useEffect, useRef, useState } from "react";
+import { Children, Fragment, isValidElement, ReactNode, useEffect, useRef, useState } from "react";
 
 import { GRAIN } from "./gravity";
 import { Echoes } from "./echoes";
@@ -125,12 +125,177 @@ export const Hat = ({ children }: { children: ReactNode }) => (
   </span>
 );
 
+/**
+ * A bar over the whole of what it covers — the mark that means DISCRETE.
+ *
+ * Not U+0305. A combining overline is one mark per letter, so a five letter
+ * word comes out as five short strokes with the gaps between the letters
+ * showing through, each landing wherever that glyph's own metrics put it, and
+ * a font without the combining mark drops them on the floor or draws them as
+ * dotted boxes. This is one rule, the width of what it covers, at one height —
+ * drawn the way the fraction's rule is drawn, since that is all a bar is.
+ *
+ * IT TAKES NO SPACE. A barred letter in the middle of a paragraph must not
+ * push that line of prose any taller than the lines around it, so the rule is
+ * positioned out of flow. Which means it needs a height to be positioned AT,
+ * and that is measured from the bottom of a box exactly one em tall — the
+ * `lineHeight: 1` — rather than from the paragraph's line box, which is
+ * whatever the surrounding text asked for and would slide the bar around from
+ * one context to the next. A box that tall has its baseline a fixed sliver
+ * above its bottom edge in every font here, so `bottom` is effectively a
+ * distance above the baseline — and it is set to sit clear of the letters
+ * rather than on top of them. A capital reaches about 0.7em and an ascender a
+ * little past that, so 1.06em leaves an unmistakable gap under the rule at
+ * every size, which is what makes it read as a bar OVER the letters and not as
+ * part of them. Any lower and it crowds the caps of `STEP` and `SHEET`.
+ */
+export const Bar = ({ children }: { children: ReactNode }) => (
+  <span style={{ position: 'relative', display: 'inline-block', lineHeight: 1 }}>
+    <span aria-hidden style={{
+      position: 'absolute', left: 0, right: 0, bottom: '1.06em',
+      borderTop: '1px solid currentColor',
+    }} />
+    {children}
+  </span>
+);
+
 export const Note = ({ children }: { children: ReactNode }) => (
   <div style={{ color: DIM, fontSize: '0.88em', lineHeight: 1.6, paddingTop: '0.5em' }}>
     {children}
   </div>
 );
 
+/**
+ * Where a set line is allowed to break, since a phone is narrower than most of
+ * the equations here and a sideways scrollbar is not reading.
+ *
+ * A line of maths cannot simply be handed to the normal wrapping rules. The
+ * spaces in it are wherever the JSX happened to be indented, so `4π r̅²` would
+ * come apart between the 4π and the r̅², and a fraction would be left stranded
+ * from the thing it divides. So the line stays unbreakable as before, EXCEPT
+ * at the two places where a break means something:
+ *
+ * AFTER A RELATION. `A = B` becomes `A =` over `B`, the sign staying on the
+ * line it closes, which is how a two line equation has always been set — never
+ * `A` over `= B`.
+ *
+ * AT A GAP. The empty padded span is what stands two independent statements
+ * side by side, so it is exactly the seam between them, and it goes at the end
+ * of the line it finishes where its padding costs nothing. A padded span with
+ * something IN it — a `⇒`, a `vs`, an aside in FAINT — becomes a piece of its
+ * own, free to fall either way.
+ *
+ * Joined by zero width spaces, so a line that fits is set exactly as it was
+ * before; and a single piece too wide for the screen still has the horizontal
+ * scroll underneath it as the last resort.
+ */
+const RELATION = /([=≈][ \u00a0]*)/;
+
+/** A padded top-level span: 'after' for a bare gap, 'both' for one with a mark in it. */
+const gap = (child: ReactNode): 'after' | 'both' | null => {
+  if (!isValidElement(child) || child.type !== 'span') return null;
+
+  const props = child.props as { style?: { padding?: string }, children?: ReactNode };
+  const pad = props.style?.padding;
+
+  if (typeof pad !== 'string' || !pad.startsWith('0 ')) return null;
+
+  return props.children == null ? 'after' : 'both';
+};
+
+/**
+ * The line's own parts, through any fragment wrapped around them.
+ *
+ * `<Eq>` is handed its children as a list, but `Step`'s line arrives as
+ * `eq={<>…</>}` — ONE fragment, whose contents are the equation. Walked into,
+ * or a step's line has exactly one piece, cannot break, and scrolls sideways in
+ * a panel that is 94vw on a phone. Which is what it did.
+ */
+const parts = (children: ReactNode): ReactNode[] => {
+  const kids = Children.toArray(children);
+
+  return kids.length === 1 && isValidElement(kids[0]) && kids[0].type === Fragment
+    ? parts((kids[0].props as { children?: ReactNode }).children)
+    : kids;
+};
+
+const breakable = (children: ReactNode, hanging = false) => {
+  const pieces: ReactNode[][] = [[]];
+  const put = (n: ReactNode) => pieces[pieces.length - 1].push(n);
+  const cut = () => { if (pieces[pieces.length - 1].length) pieces.push([]); };
+
+  /**
+   * Whether we are at the head of a statement that a gap has just started —
+   * and if we are, its own relation is not a place to break.
+   *
+   * THE GAP WINS, which is the whole of this. A line reading `A = 1 [gap]
+   * B = 2` has three places it could come apart, and filling greedily takes
+   * the last one that fits: `A = 1 [gap] B =` on the first line and a lonely
+   * `2` on the second, which splits a statement down the middle while the seam
+   * between the two statements sits unused a few characters to its left. Taking
+   * the second statement's own relation out of the running leaves the gap as
+   * the last opportunity, so a new equation goes to a new line and stays whole
+   * — and a statement long enough to need it can still break at its NEXT
+   * relation, which is the one place a break was going to be necessary anyway.
+   */
+  let heading = false;
+
+  parts(children).forEach((child) => {
+    if (typeof child === 'string') {
+      // Odd indices are the relations themselves, with whatever space followed
+      // them — which travels with the sign, so a wrapped line never starts
+      // indented by it.
+      child.split(RELATION).forEach((bit, i) => {
+        if (!bit) return;
+
+        put(bit);
+        if (!(i % 2)) return;
+
+        if (heading) heading = false;
+        else cut();
+      });
+      return;
+    }
+
+    const at = gap(child);
+
+    if (!at) return put(child);
+    if (at === 'both') cut();
+
+    put(child);
+    cut();
+
+    heading = true;
+  });
+
+  return (
+    <div style={{
+      display: 'inline-block',
+      // Room between the halves of a line that has come apart — set wide,
+      // because what sits above and below in an equation is fractions and
+      // superscripts rather than words, and at reading leading the two lines
+      // touch. `Frac` and `Bar` both fix their own leading, so this reaches
+      // the gap between the lines and nothing inside them. A line that fits
+      // pays for it as a slightly taller box, which is a thing with 1.5em of
+      // margin either side of it and nowhere to collide.
+      lineHeight: 1.95,
+      // What is carried onto the next line is set in from the line it continues
+      // by about the width of a space, which is enough to say `still the same
+      // line` and not enough to look like an indent. Hung, so only the carried
+      // lines take it and the first still starts where it always did. Left off
+      // where the line is centred, since centring already says it.
+      ...(hanging ? { textIndent: '-0.3em', paddingLeft: '0.3em' } : null),
+    }}>
+      {pieces.filter(piece => piece.length).map((piece, i) => (
+        <Fragment key={i}>
+          {i ? '\u200b' : null}
+          <span style={{ whiteSpace: 'nowrap' }}>{piece}</span>
+        </Fragment>
+      ))}
+    </div>
+  );
+};
+
 // —— the derivations, and the panel they open in —————————————————————————
 
 export type Derivation = { title: ReactNode; label: string; body: ReactNode };
@@ -141,7 +306,7 @@ export const Step = ({ eq, children }: { eq?: ReactNode, children: ReactNode })
     {eq ? <div style={{
       fontFamily: SERIF, fontSize: '1.05em', color: INK,
       overflowX: 'auto', padding: '0.3em 0 0.6em',
-    }}><div style={{ display: 'inline-block', whiteSpace: 'nowrap' }}>{eq}</div></div> : null}
+    }}>{breakable(eq, true)}</div> : null}
     <div style={{ color: DIM, fontSize: '0.87em', lineHeight: 1.62 }}>{children}</div>
   </div>
 );
@@ -263,7 +428,7 @@ export const Eq = (
       overflowX: 'auto', textAlign: 'center', color: INK,
       fontFamily: SERIF, fontSize: '1.18em', padding: '0.2em 0',
     }}>
-      <div style={{ display: 'inline-block', whiteSpace: 'nowrap' }}>{children}</div>
+      {breakable(children)}
     </div>
     {note ? <div style={{
       textAlign: 'center', color: FAINT, fontSize: '0.72em',
@@ -314,7 +479,7 @@ export const Eq = (
   </>);
 };
 
-const Head = ({ children }: { children: ReactNode }) => (
+export const Head = ({ children }: { children: ReactNode }) => (
   <div style={{
     color: FAINT, fontSize: '0.7em', letterSpacing: '0.09em',
     textTransform: 'uppercase', padding: '2.2em 0 0.1em',
@@ -323,7 +488,7 @@ const Head = ({ children }: { children: ReactNode }) => (
 );
 
 /** symbol → what it is, laid out so the symbols line up down the page. */
-const Rows = ({ of }: { of: [ReactNode, ReactNode][] }) => (
+export const Rows = ({ of }: { of: [ReactNode, ReactNode][] }) => (
   <div style={{
     display: 'grid', gridTemplateColumns: 'minmax(6.5em, max-content) 1fr',
     gap: '0.75em 1.4em', alignItems: 'baseline', padding: '1em 0 0.2em',
@@ -339,7 +504,7 @@ const Rows = ({ of }: { of: [ReactNode, ReactNode][] }) => (
 
 // —— what is behind each line ————————————————————————————————————————————
 
-const LAW: Derivation = {
+export const LAW: Derivation = {
   label: 'the law',
   title: 'the law',
   body: <>
@@ -352,17 +517,17 @@ const LAW: Derivation = {
 
     <Because>what that does to a path through it</Because>
     <Step eq={<>
-      <Frac over={<>1 + <V>n</V></>} under={<>1, and there are <K>WAYS</K> of them</>} />
+      <Frac over={<>1 + <V>n</V></>} under={<>1, and there are <K>DEG</K> of them</>} />
     </>}>
       A path arriving there has more ways of going the way the annihilation
       went than of going any other. One makes it two to one, a second three to
       one, a third four — the direction accumulates weight one annihilation at
       a time, while every other way out of the point still weighs exactly what
-      it always did. There are <K>WAYS</K> = 26 of those.
+      it always did. There are <K>DEG</K> = 26 of those.
     </Step>
 
-    <Step eq={<><K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>WAYS</K>} /></>}>
-      So the net lean is <K>LIGHT</K>·<V>n</V>/<K>WAYS</K> — linear in the
+    <Step eq={<><K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>DEG</K>} /></>}>
+      So the net lean is <K>LIGHT</K>·<V>n</V>/<K>DEG</K> — linear in the
       count, with no ceiling in it — and one annihilation is worth <K>BIAS</K>.
       This is the only constant in the dynamics, and it is a ratio of two
       counts.
@@ -370,13 +535,13 @@ const LAW: Derivation = {
 
     <Because>that is a ratio, and a ratio is not all of it</Because>
     <Step eq={<>
-      <Frac over={<>1 + <V>n</V></>} under={<K>WAYS</K>} />
+      <Frac over={<>1 + <V>n</V></>} under={<K>DEG</K>} />
       &nbsp;the lean&nbsp;&nbsp;·&nbsp;&nbsp;
-      <K>WAYS</K> + <V>n</V>&nbsp; the total
+      <K>DEG</K> + <V>n</V>&nbsp; the total
     </>}>
       The line above compares one direction against the others and throws away
       how many there are. But the ways out of that point no longer{' '}
-      number <K>WAYS</K> — they number <K>WAYS</K> + <V>n</V>, and{' '}
+      number <K>DEG</K> — they number <K>DEG</K> + <V>n</V>, and{' '}
       <b style={{ color: INK }}>a point with more ways out of it holds more
         space</b>. The lean is the first moment of the count; the total is the
       zeroth. Both are the same annihilations, read twice.
@@ -406,7 +571,7 @@ const LAW: Derivation = {
         under={<><V>B</V> √(<V>A</V>(1 + |<B>u</B>|<Sup>2</Sup>/<V>B</V><K>LIGHT</K><Sup>2</Sup>))</>} />
     </>}>
       The counting happens on the body’s own worldline, so{' '}
-      <K>LIGHT</K>·<V>n</V>/<K>WAYS</K> is cells per tick of <i>its</i> clock —
+      <K>LIGHT</K>·<V>n</V>/<K>DEG</K> is cells per tick of <i>its</i> clock —
       a proper velocity, not a coordinate one. Turning that into what the
       picture shows is one line of arithmetic the model does not get to choose,
       and how many cells it is worth depends on how thick the place is. Flat, it
@@ -442,13 +607,13 @@ const LAW: Derivation = {
   </>,
 };
 
-const METRIC: Derivation = {
+export const METRIC: Derivation = {
   label: 'A and B',
   title: <>the count, read a second time</>,
   body: <>
     <Because>what the lean threw away</Because>
     <Step eq={<>
-      <Frac over={<>1 + <V>n</V></>} under={<>1 each, <K>WAYS</K> of them</>} />
+      <Frac over={<>1 + <V>n</V></>} under={<>1 each, <K>DEG</K> of them</>} />
     </>}>
       <K>BIAS</K> compares the direction that took an annihilation against the
       others. Every other way out still weighs one — which is true, and is a{' '}
@@ -459,7 +624,7 @@ const METRIC: Derivation = {
     </Step>
 
     <Because>the total, which is the other reading</Because>
-    <Step eq={<><K>WAYS</K> + <V>n</V>&nbsp;&nbsp;ways out, not <K>WAYS</K></>}>
+    <Step eq={<><K>DEG</K> + <V>n</V>&nbsp;&nbsp;ways out, not <K>DEG</K></>}>
       A point that has taken <V>n</V> annihilations has more ways out of it
       than its neighbours do, so it{' '}
       <b style={{ color: INK }}>holds more space</b> — and a neighbourhood of
@@ -520,7 +685,7 @@ const METRIC: Derivation = {
   </>,
 };
 
-const SPACE: Derivation = {
+export const SPACE: Derivation = {
   label: 'where space comes from',
   title: <>the three rewrites, and what they buy</>,
   body: <>
@@ -574,7 +739,7 @@ const SPACE: Derivation = {
     <Step eq={<>
       <V>D</V> = <Frac over={<><K>SHEET</K> <V>c</V><Sup>2</Sup></>}
         under={<>12<V>π</V> <V>G</V></>} /> =
-      <Frac over={<><V>π</V> <K>WAYS</K> <V>c</V></>}
+      <Frac over={<><V>π</V> <K>DEG</K> <V>c</V></>}
         under={<>3 <K>BITE</K> <K>SHEET</K></>} /> = 3.403
     </>}>
       From <V>δ</V> = 3<V>u</V> and <V>u</V> = <V>GM</V>/<V>rc</V><Sup>2</Sup>.
@@ -598,7 +763,7 @@ const SPACE: Derivation = {
   </>,
 };
 
-const MADE_FROM: Derivation = {
+export const MADE_FROM: Derivation = {
   label: 'ε',
   title: <>what a charge would have to make</>,
   body: <>
@@ -633,7 +798,7 @@ const MADE_FROM: Derivation = {
     <Step eq={<>
       <V>ε</V> =
       <Frac over={<>3 <K>BITE</K> <K>SHEET</K></>}
-        under={<><V>π</V> <K>WAYS</K></>} /> = 0.2938
+        under={<><V>π</V> <K>DEG</K></>} /> = 0.2938
     </>}>
       About a third of a point per charge per lattice tick. Every symbol a
       count, no <K>GRAIN</K> in it, and order one — which is what a fundamental
@@ -712,8 +877,8 @@ const MADE_FROM: Derivation = {
     <Because>so it predicts G rather than absorbing it — and gets it wrong, precisely</Because>
     <Step eq={<>
       <Frac over={<><K>SHEET</K>·<V>c</V>/12π</>}
-        under={<><K>SHEET</K><Sup>2</Sup>/4π<Sup>2</Sup><K>WAYS</K></>} /> =
-      <Frac over={<>π<K>WAYS</K></>} under={<>3<K>SHEET</K></>} /> = 3.4034
+        under={<><K>SHEET</K><Sup>2</Sup>/4π<Sup>2</Sup><K>DEG</K></>} /> =
+      <Frac over={<>π<K>DEG</K></>} under={<>3<K>SHEET</K></>} /> = 3.4034
     </>}>
       Predicted <V>G</V> = 0.21221, the pull’s <V>G</V> = 0.06235, ratio
       3.403392 — and <b style={{ color: INK }}>that is <V>ε</V>’s own number,
@@ -729,10 +894,10 @@ const MADE_FROM: Derivation = {
       <span style={{ padding: '0 1.2em', color: FAINT }}>pinned</span>
     </>}>
       The pull works because it is a <i>product</i> of two fields along a line —
-      which is where <K>WAYS</K> enters. A lone body has no second field, and
+      which is where <K>DEG</K> enters. A lone body has no second field, and
       that is the shape of the 3.4034. But a lone body is not alone: its charges
       annihilate against the ambient <V>Φ</V>, restoring product, bias and{' '}
-      <K>WAYS</K> at once. It gives 1/<V>r</V>, and matching{' '}
+      <K>DEG</K> at once. It gives 1/<V>r</V>, and matching{' '}
       <V>u</V> = <V>Gm</V>/<V>rc</V><Sup>2</Sup> fixes{' '}
       <V>Φ</V> = <K>SHEET</K>/π = 2.546 —{' '}
       <b style={{ color: INK }}>against the cosmology attractor’s independent{' '}
@@ -773,19 +938,19 @@ const MADE_FROM: Derivation = {
       Two routes, both counted, neither with a free parameter, disagreeing by a{' '}
       <i>pure count</i> — so it is a statement about the lattice’s geometry and
       nothing else, and the search is finite. The fix is not a coefficient and
-      not a dimension: they agree iff <K>WAYS</K>/<K>SHEET</K> = 3/π, which is
-      irrational, while <K>WAYS</K>/<K>SHEET</K> is a ratio of integers tending
+      not a dimension: they agree iff <K>DEG</K>/<K>SHEET</K> = 3/π, which is
+      irrational, while <K>DEG</K>/<K>SHEET</K> is a ratio of integers tending
       to 3 from above.{' '}
       <b style={{ color: INK }}>So one of the two counts is being used for a job
         it is not the count for</b> — and they are not even the same kind of
-      thing, <K>SHEET</K> being what a source emits and <K>WAYS</K> what a path
+      thing, <K>SHEET</K> being what a source emits and <K>DEG</K> what a path
       could have done instead. That is the same mistake this file already made
       once, and recorded.
     </Step>
   </>,
 };
 
-const REACH: Derivation = {
+export const REACH: Derivation = {
   label: 'how far gravity reaches',
   title: <>the ambient field, and the end of the pull</>,
   body: <>
@@ -849,7 +1014,7 @@ const REACH: Derivation = {
   </>,
 };
 
-const IDENTICAL: Derivation = {
+export const IDENTICAL: Derivation = {
   label: 'gravity between identical things',
   title: <>two of the same, closer than a wavelength</>,
   body: <>
@@ -907,7 +1072,7 @@ half out   1.98   1.88   1.76   1.41   1.00   1.00`}
   </>,
 };
 
-const CLOCK: Derivation = {
+export const CLOCK: Derivation = {
   label: 'mass as a period',
   title: <>once a tick is the ceiling</>,
   body: <>
@@ -943,7 +1108,7 @@ const CLOCK: Derivation = {
   </>,
 };
 
-const IGNORANCE: Derivation = {
+export const IGNORANCE: Derivation = {
   label: 'the matter wave',
   title: <>λ = <V>h</V>/<V>p</V>, twice — by ignorance, and then by zigzag</>,
   body: <>
@@ -1131,7 +1296,7 @@ const IGNORANCE: Derivation = {
       k_eff = 0.016&nbsp;&nbsp;against&nbsp;&nbsp;k = 0.30
     </span>}>
       <b style={{ color: INK }}>Every path gets the same modulus.</b> Feynman
-      postulates it, and <K>WAYS</K> looked like the answer: every way out of a
+      postulates it, and <K>DEG</K> looked like the answer: every way out of a
       point equally available, one step a tick so path length ∝ time, hence all
       equal-time paths equally likely. Summed over every 8-neighbour path of 130
       steps, the phase does <i>not</i> track <V>k·x</V> — fitted
@@ -1146,7 +1311,7 @@ const IGNORANCE: Derivation = {
       massive particle’s phase is −<V>mc</V><Sup>2</Sup>∫d<V>τ</V>/ħ, which
       along a lightlike path is nought too.{' '}
       <b style={{ color: INK }}>A charge’s path is not a particle’s path</b>,
-      and <K>WAYS</K> counts a charge’s options; the path integral needs the
+      and <K>DEG</K> counts a charge’s options; the path integral needs the
       worldlines of the <i>emitter</i>, which moves at <V>v</V> &lt; <V>c</V>.
       Two independent things now point at one structural gap — the lattice has
       one kind of mover, and both quantum mechanics and the metric want
@@ -1225,7 +1390,7 @@ const IGNORANCE: Derivation = {
 
     <Because>and fractional dimensions do not survive it</Because>
     <Step eq={<>2<Sup>⌊(<V>d</V>+1)/2⌋</Sup> components</>}>
-      <K>SHEET</K> and <K>WAYS</K> are 3<Sup><V>d</V>−1</Sup> − 1 and
+      <K>SHEET</K> and <K>DEG</K> are 3<Sup><V>d</V>−1</Sup> − 1 and
       3<Sup><V>d</V></Sup> − 1, perfectly happy at <V>d</V> = 2.5 (4.196 and
       14.588), and every counting argument would still run. But a Clifford
       algebra has no fractional representation — you cannot have 2.83
@@ -1235,13 +1400,13 @@ const IGNORANCE: Derivation = {
       fermions. Either the spinor is fundamental and <V>d</V> is an integer, or
       the counts are and four components at <V>d</V> = 3 has to be derived.
       Nothing here decides it. It does settle one thing negatively:{' '}
-      <K>WAYS</K>/<K>SHEET</K> is bounded below by 3 at <i>every</i> <V>d</V>,
+      <K>DEG</K>/<K>SHEET</K> is bounded below by 3 at <i>every</i> <V>d</V>,
       so no dimension — fractional or not — closes the 3.4034.
     </Step>
   </>,
 };
 
-const MEETINGS: Derivation = {
+export const MEETINGS: Derivation = {
   label: 'the meeting rate',
   title: <>the meeting rate <V>S</V><Sub>ab</Sub></>,
   body: <>
@@ -1297,7 +1462,7 @@ const MEETINGS: Derivation = {
   </>,
 };
 
-const MET: Derivation = {
+export const MET: Derivation = {
   label: 'met(R)',
   title: <>met(<V>R</V>)</>,
   body: <>
@@ -1400,16 +1565,16 @@ const MET: Derivation = {
   </>,
 };
 
-const CONSTANTS: Derivation = {
+export const CONSTANTS: Derivation = {
   label: 'BIAS and c',
   title: <><K>BIAS</K> and <V>c</V></>,
   body: <>
     <Because>BIAS</Because>
     <Step eq={<>
-      <K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>WAYS</K>} /> =
+      <K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>DEG</K>} /> =
       <Frac over={<>1</>} under={<>26</>} />
     </>}>
-      What one annihilation buys a path. <K>WAYS</K> = 3<Sup>3</Sup> − 1 is how
+      What one annihilation buys a path. <K>DEG</K> = 3<Sup>3</Sup> − 1 is how
       many ways out of a point there are — the alternatives the biased path did
       not take. Note this is <i>not</i> <K>SHEET</K>, which is how many charges
       a source emits in one pulse: a different question, and the same constant
@@ -1439,7 +1604,7 @@ const CONSTANTS: Derivation = {
   </>,
 };
 
-const FULL: Derivation = {
+export const FULL: Derivation = {
   label: 'the law in full',
   title: 'the law in full',
   body: <>
@@ -1457,7 +1622,7 @@ const FULL: Derivation = {
     <Step eq={<>
       <Frac over={<>d<V>p</V></>} under={<>d<V>t</V></>} /> =
       <Frac over={<><K>SHEET</K><Sup>2</Sup></>}
-        under={<>4<V>π</V><Sup>2</Sup><V>c</V> <K>WAYS</K></>} /> ·
+        under={<>4<V>π</V><Sup>2</Sup><V>c</V> <K>DEG</K></>} /> ·
       <Frac over={<><V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub></>}
         under={<><V>R</V><Sup>2</Sup></>} />
       <Paren>1 + <Frac over={<V>c</V>} under={<V>R</V>} /> ln
@@ -1471,7 +1636,7 @@ const FULL: Derivation = {
     <Because>which is a gravitational constant</Because>
     <Step eq={<>
       <V>G</V> = <Frac over={<><K>SHEET</K><Sup>2</Sup></>}
-        under={<>4<V>π</V><Sup>2</Sup><V>c</V> <K>WAYS</K></>} />
+        under={<>4<V>π</V><Sup>2</Sup><V>c</V> <K>DEG</K></>} />
     </>}>
       Not measured off a run and not fitted — the far limit of met, in closed
       form, out of charges per pulse, ways out of a point, and the size of a
@@ -1492,8 +1657,8 @@ const FULL: Derivation = {
       Not from that bracket, and not from anything short-range. It comes from
       the two places the count is read. Read as a <i>direction</i>, on the
       body’s own worldline, it gives special relativity’s response and one
-      sixth of Mercury. Read as a <i>size</i> — <K>WAYS</K> + <V>n</V> ways out
-      of a point rather than <K>WAYS</K> — it gives the spatial part of a
+      sixth of Mercury. Read as a <i>size</i> — <K>DEG</K> + <V>n</V> ways out
+      of a point rather than <K>DEG</K> — it gives the spatial part of a
       metric, and with it the other five sixths and the whole of light’s
       deflection. Same annihilations, same constant, counted twice.
     </Step>
@@ -1570,7 +1735,7 @@ export const Law = () => {
     </Eq>
 
     <Eq derive={CONSTANTS} open={show}>
-      <K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>WAYS</K>} /> =
+      <K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>DEG</K>} /> =
       <Frac over={<>1</>} under={<>26</>} />
       <span style={{ padding: '0 1.6em' }} />
       <V>c</V> = <Frac over={<K>HALF</K>} under={<K>GRAIN</K>} />
@@ -1580,7 +1745,7 @@ export const Law = () => {
     <Note>Six countable facts about the lattice, and nothing else is assumed.</Note>
 
     <Rows of={[
-      [<><K>WAYS</K> = 3<Sup>3</Sup> − 1 = 26</>,
+      [<><K>DEG</K> = 3<Sup>3</Sup> − 1 = 26</>,
         <>ways out of a point — the 3×3×3 block around it, minus itself</>],
       [<><K>SHEET</K> = 3<Sup>2</Sup> − 1 = 8</>,
         <>charges in one pulse: the plane a source emits into, which turns with it</>],
@@ -1643,7 +1808,7 @@ export const Law = () => {
         exponential with nothing chosen. β = γ = 1 both fall out.</>],
       [<span style={{ color: DERIVED }}><i>carry</i></span>,
         <><b style={{ color: INK }}>The geodesic equation.</b> The reversal rate
-          thins as 1/(<K>WAYS</K>+<V>n</V>), which is √<V>A</V> exactly — so the
+          thins as 1/(<K>DEG</K>+<V>n</V>), which is √<V>A</V> exactly — so the
           clock is the edge count — and stationary phase on ω<V>τ</V> then gives
           this function to 10<Sup>−7</Sup>.</>],
       [<span style={{ color: DERIVED }}>
@@ -1665,8 +1830,8 @@ export const Law = () => {
     <Rows of={[
       [<span style={{ color: DERIVED }}><i>carry</i></span>,
         <><b style={{ color: INK }}>No longer borrowed.</b> The checkerboard’s
-          clock is the <i>reversal</i> rate, 1 in <K>WAYS</K> unfolded and 1 in{' '}
-          <K>WAYS</K>+<V>n</V> folded — so{' '}
+          clock is the <i>reversal</i> rate, 1 in <K>DEG</K> unfolded and 1 in{' '}
+          <K>DEG</K>+<V>n</V> folded — so{' '}
           <V>m</V><Sub>eff</Sub> = <V>m</V>/(1+<V>u</V>) = <V>m e</V><Sup>−<V>u</V><Sub>0</Sub></Sup>{' '}
           = <V>m</V>√<V>A</V>, identical to machine precision.{' '}
           <b style={{ color: INK }}>Gravitational time dilation is the edge
@@ -1774,7 +1939,7 @@ export const Law = () => {
       <span style={{ padding: '0 1.4em' }} />
       <V>G</V> =
       <Frac over={<><K>SHEET</K><Sup>2</Sup></>}
-        under={<>4<V>π</V><Sup>2</Sup> <V>c</V> <K>WAYS</K></>} />
+        under={<>4<V>π</V><Sup>2</Sup> <V>c</V> <K>DEG</K></>} />
     </Eq>
 
     <Note>
@@ -1869,7 +2034,7 @@ export const Law = () => {
           either.</>],
       [<span style={{ color: DERIVED }}>by hopping</span>,
         <><b style={{ color: INK }}>Alive.</b> A created point that sits a tick
-          and then takes one of the <K>WAYS</K> at random is a random walk with{' '}
+          and then takes one of the <K>DEG</K> at random is a random walk with{' '}
           <i>no scatterer in it</i>, so <V>D</V> = ⟨ℓ<Sup>2</Sup>⟩/6 = 0.3462 is
           a fact about the lattice and <V>Φ</V> never enters. Measured on the
           lattice: the Green’s function to 0.1%, and <i>static</i> — an
@@ -1937,12 +2102,12 @@ export const Law = () => {
     </Note>
 
     <Note>
-      The audit that followed found <K>WAYS</K> enters the dynamics in exactly
+      The audit that followed found <K>DEG</K> enters the dynamics in exactly
       one place — <K>BIAS</K>. Putting <K>SHEET</K> there instead closes the gap
       from three and a half <i>times</i> to{' '}
       <b style={{ color: INK }}>π/3, four and a half per cent</b> — a striking
-      near miss, and not a fix, since the argument for <K>WAYS</K> is good and
-      4.7% is not nought. Keeping <K>WAYS</K>, the metric route’s 3 would have
+      near miss, and not a fix, since the argument for <K>DEG</K> is good and
+      4.7% is not nought. Keeping <K>DEG</K>, the metric route’s 3 would have
       to be 10.21, and the 3 was there because a volume excess is three times a
       linear one. So the likeliest error is neither count but{' '}
       <b style={{ color: INK }}>the identification ∫<V>δ</V> = 3<V>u</V>{' '}
@@ -2098,7 +2263,7 @@ export const Law = () => {
           energy on the way. <i>through</i> gives a charge arriving at an
           occupied cell exactly two outcomes and no third —{' '}
           <i>annihilate</i>, or <i>reverse</i> — and both are extinction. A
-          step is one cell and a heading is one of <K>WAYS</K>, so there is no
+          step is one cell and a heading is one of <K>DEG</K>, so there is no
           soft forward channel anywhere in the rules:{' '}
           <b style={{ color: INK }}>the lattice can dim light and cannot redden
             it</b>. A structural no-go rather than a number coming out
@@ -2933,13 +3098,13 @@ export const Law = () => {
       [<span style={{ color: FAINT }}>within 2%</span>, <>95, 12</>],
       [<span style={{ color: BORROWED }}>within 1%</span>,
         <><b style={{ color: INK }}>20 expressions, 4 distinct values</b> — the
-          closest √(<K>WAYS</K>·π)/2 = 4.51889, at −0.30%</>],
+          closest √(<K>DEG</K>·π)/2 = 4.51889, at −0.30%</>],
     ]} />
 
     <Note>
       <b style={{ color: INK }}>Twenty expressions land inside a percent.</b> A
       search over numbers cannot tell a derivation from an accident here, so a
-      hit is worth nothing even when it is close, and √(<K>WAYS</K>·π)/2 goes
+      hit is worth nothing even when it is close, and √(<K>DEG</K>·π)/2 goes
       down as a curiosity and nothing else. This is the one place where{' '}
       <i>count it, do not fit it</i> has to be enforced by refusing to look
       rather than by looking carefully.
@@ -3221,7 +3386,7 @@ export const Law = () => {
       <b style={{ color: INK }}>And that is the real cost, stated plainly:</b>{' '}
       <V>a</V><Sub>0</Sub> becomes a new fundamental constant — the strength
       with which layer two’s field gravitates in layer one — rather than
-      something counted out of <K>SHEET</K> and <K>WAYS</K>. For a model whose
+      something counted out of <K>SHEET</K> and <K>DEG</K>. For a model whose
       whole method is counting, that is a genuine loss, and it belongs in the
       ledger rather than hidden inside a κ.
     </Note>
@@ -3510,10 +3675,10 @@ export const Law = () => {
     <Note>
       <b style={{ color: INK }}>And the live candidate has a candidate
         mechanism: lock layer two to layer one’s <K>SHEET</K>.</b>{' '}
-      <K>WAYS</K> = 3<Sup>3</Sup>−1 = 26 is every direction out of a cell;{' '}
+      <K>DEG</K> = 3<Sup>3</Sup>−1 = 26 is every direction out of a cell;{' '}
       <K>SHEET</K> = 3<Sup>2</Sup>−1 = 8 is the directions in <i>one plane</i>{' '}
       through it. And <i>chance</i> = <V>m</V><K>SHEET</K>/<i>shell</i> already
-      uses <K>SHEET</K> rather than <K>WAYS</K> — the pull was always counted
+      uses <K>SHEET</K> rather than <K>DEG</K> — the pull was always counted
       through a plane. This is not adding a structure; it is taking one the file
       already has and making it <i>bind</i>.
     </Note>
@@ -4209,7 +4374,7 @@ export const Law = () => {
       <Frac over={<><V>c</V><V>H</V><Sub>0</Sub>/2π</>}
         under={<>4π<V>G</V>/(<K>SHEET</K><V>t</V><Sub>0</Sub>)</>} />
       <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
-      <Frac over={<><K>WAYS</K></>} under={<>2 <K>SHEET</K></>} />
+      <Frac over={<><K>DEG</K></>} under={<>2 <K>SHEET</K></>} />
       <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
       <Frac over={<>13</>} under={<>8</>} />
       <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
@@ -4218,7 +4383,7 @@ export const Law = () => {
 
     <Note>
       Because <K>CORE</K> = ½ makes 8π²<V>G</V>/<K>SHEET</K> come to exactly
-      2·<K>SHEET</K>/<K>WAYS</K>, to eight digits. So one of the two is
+      2·<K>SHEET</K>/<K>DEG</K>, to eight digits. So one of the two is
       miscounting by 13/8 — a factor built from the number of exits from a cell
       and the size of a sheet, and nothing else.{' '}
       <b style={{ color: INK }}>That is a much better position than two rival
@@ -4613,7 +4778,7 @@ export const Law = () => {
           bulk one it was derived under.</>],
       [<span style={{ color: BORROWED }}>the factor of 13/8</span>,
         <>Two derivations of <V>a</V><Sub>0</Sub> differing by exactly{' '}
-          <K>WAYS</K>/2<K>SHEET</K>. One of them miscounts, and finding which
+          <K>DEG</K>/2<K>SHEET</K>. One of them miscounts, and finding which
           would turn a 9% agreement into a derivation or kill it outright. This
           is arithmetic, not physics.</>],
       [<span style={{ color: DERIVED }}>and then a real prediction</span>,
@@ -4835,7 +5000,7 @@ export const Law = () => {
         point to keep its heading about 85% of the time?</b> That was, at the
       time, the whole of the remaining gap. A pure count did briefly seem to be
       sitting in
-      plain sight — 10.21 = π<K>WAYS</K>/<K>SHEET</K> — but that is{' '}
+      plain sight — 10.21 = π<K>DEG</K>/<K>SHEET</K> — but that is{' '}
       3<V>D</V>/<V>c</V>, which is <V>D</V> rewritten rather than a second fact,
       and the physical run is 7.67 cells. No coincidence to chase.
     </Note>
@@ -4878,7 +5043,7 @@ export const Law = () => {
     <Note>
       <b style={{ color: INK }}>And then the target moved.</b> All of that
       assumed <V>B</V> needs its own source. But a place has{' '}
-      <K>WAYS</K> + <V>n</V> ways out, the <i>lean</i> is a ratio and the{' '}
+      <K>DEG</K> + <V>n</V> ways out, the <i>lean</i> is a ratio and the{' '}
       <i>total</i> is what a ratio throws away — <V>A</V> and <V>B</V> from the
       same count, with no surplus, no transport and no <V>D</V>. That is a claim
       with numbers, because <V>A</V> and <V>B</V> carry exactly two things the
@@ -4912,7 +5077,7 @@ export const Law = () => {
       next annihilation there buys, the composition is multiplicative and β = 1
       follows. So the gap is not a transport rule and not a diffusivity:{' '}
       <b style={{ color: INK }}>it is whether 1 + <V>n</V> should be
-        (1 + 1/<K>WAYS</K>)<Sup><V>n</V></Sup></b> — one line of the counting
+        (1 + 1/<K>DEG</K>)<Sup><V>n</V></Sup></b> — one line of the counting
       argument, in the one rule that has never been asked whether it stays
       linear all the way up.
     </Note>
@@ -4921,9 +5086,9 @@ export const Law = () => {
 
     <Note>
       A node that has taken <V>n</V> annihilations has{' '}
-      <K>WAYS</K> + <V>n</V> edges. Edges are shared with neighbours, so{' '}
+      <K>DEG</K> + <V>n</V> edges. Edges are shared with neighbours, so{' '}
       <b style={{ color: INK }}>the same <V>n</V> extra edges point <i>into</i>{' '}
-        it</b> — a charge nearby is (<K>WAYS</K>+<V>n</V>)/<K>WAYS</K> times
+        it</b> — a charge nearby is (<K>DEG</K>+<V>n</V>)/<K>DEG</K> times
       more likely to arrive there. More arrivals, more annihilations, more
       folding, more arrivals. The increment is proportional to what is already
       there, which is what <i>multiplicative</i> means, and it is the counting
@@ -4959,7 +5124,7 @@ export const Law = () => {
       <i>infinitely many ways out</i>, and each annihilation adds one, and a
       finite mass sends finitely many charges. At what general relativity calls
       the horizon (<V>u</V><Sub>0</Sub> = 2) the node has 6.4 extra ways out
-      per <K>WAYS</K>: a lot, and not infinity. Light leaves, redshifted by{' '}
+      per <K>DEG</K>: a lot, and not infinity. Light leaves, redshifted by{' '}
       <V>e</V><Sup>2</Sup> = 7.4. Nothing is ever cut off — things get
       arbitrarily red and arbitrarily slow and never quite vanish.
     </Note>
@@ -5126,7 +5291,7 @@ export const Law = () => {
     <Head>and a second way, kept alongside</Head>
 
     <Note>
-      A node with <K>WAYS</K> + <V>n</V> edges gives a source <i>sitting there</i>{' '}
+      A node with <K>DEG</K> + <V>n</V> edges gives a source <i>sitting there</i>{' '}
       more ways to pulse into, so <K>SHEET</K> → <K>SHEET</K>(1+<V>u</V>) and
       emission — which <i>is</i> mass — is boosted. A feedback on the{' '}
       <b style={{ color: INK }}>source</b>, where the compounding was a feedback
@@ -5157,7 +5322,7 @@ export const Law = () => {
           <b style={{ color: INK }}>eight sixths where the panels measure
             six</b> — 33% high, excluded by three thousand. It survives only if
           the boost begins above <V>u</V><Sup>2</Sup>, at a depth nothing has
-          fixed. <K>BIAS</K> saturating as <V>n</V>/(<K>WAYS</K>+<V>n</V>) turns
+          fixed. <K>BIAS</K> saturating as <V>n</V>/(<K>DEG</K>+<V>n</V>) turns
           over at <V>u</V> ~ 1, which is at least where such a threshold would
           sit.</>],
     ]} />
@@ -5181,7 +5346,7 @@ export const Law = () => {
       <V>r</V> has proper area 4π<V>r</V><Sup>2</Sup><V>B</V>, so{' '}
       <V>r</V><Sub>areal</Sub> = <V>r</V>·<V>e</V><Sup><V>u</V></Sup>. Which is
       the same statement as{' '}
-      <b style={{ color: INK }}>“a node with <K>WAYS</K> + <V>n</V> edges
+      <b style={{ color: INK }}>“a node with <K>DEG</K> + <V>n</V> edges
         touches far more than a cell’s worth of neighbours”</b>, measured rather
       than counted.
     </Note>
@@ -5797,7 +5962,7 @@ export const WithoutPolarity = () => (
     <Eq note="G doubles — and that is the whole of it">
       <K>G</K> = <Frac
         over={<><K>BITE</K>·<i>share</i>·<K>SHEET</K><Sup>2</Sup></>}
-        under={<>4<V>π</V><Sup>2</Sup>·<K>CORE</K>·<K>WAYS</K></>} />
+        under={<>4<V>π</V><Sup>2</Sup>·<K>CORE</K>·<K>DEG</K></>} />
       <span style={{ padding: '0 1.4em' }} />
       0.062351 → 0.124703
     </Eq>
@@ -5815,7 +5980,7 @@ export const WithoutPolarity = () => (
 
     <Rows of={[
       [<span style={{ color: DERIVED }}>what does not move</span>,
-        <><K>SHEET</K>, <K>WAYS</K>, <K>BITE</K>, <K>BIAS</K>, <K>MADE</K>,{' '}
+        <><K>SHEET</K>, <K>DEG</K>, <K>BITE</K>, <K>BIAS</K>, <K>MADE</K>,{' '}
           <K>SPREAD</K>, <K>REACHES</K>, and the tick — which is still exactly
           the Planck time. <K>REACHES</K> is the pretty one: it carries <K>G</K>{' '}
           on top and the share underneath, and the two cancel to the digit.</>],
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnet.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnet.ts
index a2c16f6..1f0d92c 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnet.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnet.ts
@@ -13,12 +13,12 @@
  *
  *   MAGNETON       = CYCLE·G_LATTICE/2π              in units of µ_B — 0.0794
  *   G_FACTOR       = 1                               and measurement says 2
- *   biased(axis)   = |{exits with d·axis > 0}| / WAYS   9/26 or 10/26
+ *   biased(axis)   = |{exits with d·axis > 0}| / DEG   9/26 or 10/26
  *
  */
 
 import { CYCLE } from "./lattice";
-import { SHEET, WAYS } from "./field";
+import { SHEET, DEG } from "./field";
 import { BITE, LIGHT, Spin, rate, sided } from "./physics";
 import { G_LATTICE } from "./gravity";
 
@@ -327,7 +327,7 @@ export const G_FACTOR = 1;
  * AND ONE THING THE LATTICE PREDICTS THAT NOTHING ELSE DOES.
  *
  * A held emitter puts + into every exit whose projection on its axis is
- * positive and − into every negative one. There are only `WAYS` = 26 exits, so
+ * positive and − into every negative one. There are only `DEG` = 26 exits, so
  * that split is a COUNT, and the count depends on which way the axis points:
  *
  *     ⟨100⟩ face      9 +    8 equator    9 −     0.3462 biased
@@ -360,7 +360,7 @@ export const biased = (axis: number[]): number => {
         if (x * axis[0] + y * (axis[1] ?? 0) + z * (axis[2] ?? 0) > 1e-9) positive++;
       }
 
-  return positive / WAYS;
+  return positive / DEG;
 };
 
 /**
@@ -435,4 +435,4 @@ export const biased = (axis: number[]): number => {
 
 // Kept so a reader can check the two constants this file leans on are the ones
 // the rest of the article means by those names, rather than a copy that drifted.
-export const CHECK = { SHEET, WAYS, BITE, LIGHT, CYCLE, G_LATTICE };
+export const CHECK = { SHEET, DEG, BITE, LIGHT, CYCLE, G_LATTICE };
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnetism.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnetism.tsx
index 9b783df..1316c15 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnetism.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/magnetism.tsx
@@ -23,7 +23,7 @@ const RELAT = "#9aa0b4";                 // the reading that was tried and faile
 const GOOD = "#8bd48b", BAD = "#e0685f";
 const BACK = "#08090d";
 
-const CYCLE = 8, WAYS = 26, SHEET = 8;
+const CYCLE = 8, DEG = 26, SHEET = 8;
 
 // ---------------------------------------------------------------------------
 // the same drawing helpers the rotation panels use, kept local so this file
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
index 140b4f2..13903dc 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/metric.tsx
@@ -28,18 +28,18 @@
  *   An annihilation leaves the space where it happened denser: the next path
  *   out of that point is twice as likely to go the way it went, a second one
  *   makes it three to one, a third four. So a direction carrying n of them
- *   weighs 1 + n against the WAYS out that weigh one each, and what that leans
- *   a path by is LIGHT·n/WAYS — linear, with no ceiling in it.
+ *   weighs 1 + n against the DEG out that weigh one each, and what that leans
+ *   a path by is LIGHT·n/DEG — linear, with no ceiling in it.
  *
  *   THAT IS A RATIO, and a ratio is not all a count says. The ways out of that
- *   point no longer number WAYS; they number WAYS + n. The lean is the first
+ *   point no longer number DEG; they number DEG + n. The lean is the first
  *   moment of the count and is the whole of the pull; the total is the zeroth,
  *   and is how much space the point holds. One scalar, read twice — the pull
  *   for A and the thickness for B. See `slowing` and `thickness`.
  *
  *   Everything else here falls out of that, and none of it is stated:
  *
- *     BIAS        one annihilation buys LIGHT/WAYS, whatever else is going on
+ *     BIAS        one annihilation buys LIGHT/DEG, whatever else is going on
  *                 — so at rest, NEWTON, with no free constant
  *     u̇ ∝ ṅ      a shortage of space is an ACCELERATION and not a speed,
  *                 because what accumulates is the count and what drifts is a
@@ -56,7 +56,7 @@
  *                 heavier things have proportionally more paths to bias, so
  *                 the same fraction of them bends. Inertia IS path count.
  *
- *   G           = BITE·SHEET²·c/(8π²·HALF·WAYS)  closed form, nothing fitted,
+ *   G           = BITE·SHEET²·c/(8π²·HALF·DEG)  closed form, nothing fitted,
  *                                                 and in the lattice's own units
  *                                                 `S·R²` runs above it by
  *                                                 CORE·ln(R/CORE)/R — which
@@ -191,7 +191,7 @@ export type Space = {
    * annihilation has more ways of going the way it went "while every other way
    * out of the point still weighs exactly what it always did" — and that is
    * true, and it is a RATIO, and a ratio throws away the total. There are now
-   * WAYS + n ways out of that point rather than WAYS, and a point with more
+   * DEG + n ways out of that point rather than DEG, and a point with more
    * ways out of it holds more space. The lean is A. The total is B. See
    * `slowing` and `thickness` in `gravity.ts`, and `settle` below, which is
    * the whole of the fix and is four lines.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
index 3e62865..4c2d1fd 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/model.ts
@@ -161,6 +161,17 @@ export type Lattice = {
 
   mode?: RenderMode;
 
+  /**
+   * Whether the charges are drawn as charges — see `GraphCanvas`.
+   *
+   * The gravity arc has no polarity in it. The same runs are shown twice in
+   * this article, once as gravity and once as gravity-and-magnetism, and it is
+   * the SECOND showing that adds the two kinds. Drawn amber and cyan in the
+   * first, the picture has already answered a question the argument has not
+   * asked yet.
+   */
+  polarities?: boolean;
+
   /**
    * The gravity-flow glow. Worth it for a large universe; for a two-point one
    * it washes out the handful of boundaries the picture is about.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
index 3ffd34b..79cdfea 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -1142,7 +1142,7 @@ const known: Model[] = KNOWN.map(({ name, note, sources }) => ({
  * was actually missing was the other five sixths, and they were never a
  * velocity effect or a short-range one. They are the same count read as a size
  * rather than as a direction — a point that has taken n annihilations has
- * WAYS + n ways out of it and not WAYS, so it holds more space — which is the
+ * DEG + n ways out of it and not DEG, so it holds more space — which is the
  * spatial part of a metric. See `slowing` and `thickness` in `gravity.ts` and
  * `settle` in `metric.tsx`.
  *
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
index 5296a74..3e68e37 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/regimes.ts
@@ -81,10 +81,10 @@ export type Regime = {
    * is derived or borrowed.
    *
    *   0  ADDITIVE. `weight of the way it went = 1 + n`, which is what `BIAS`
-   *      says. Gives √A = WAYS/(WAYS+n), hence β = 3/2, hence a perihelion
+   *      says. Gives √A = DEG/(DEG+n), hence β = 3/2, hence a perihelion
    *      advance 17% low at every depth. Wrong, and measured to be wrong.
-   *   1  MULTIPLICATIVE. Each annihilation multiplies by 1 + 1/WAYS, so
-   *      √A = (1+1/WAYS)^−n → exp(−u), and A = e^−2u, B = e^+2u. Gives
+   *   1  MULTIPLICATIVE. Each annihilation multiplies by 1 + 1/DEG, so
+   *      √A = (1+1/DEG)^−n → exp(−u), and A = e^−2u, B = e^+2u. Gives
    *      β = γ = 1 and general relativity's perihelion advance.
    *
    * At 1 the metric is DERIVED — no A and B taken from outside — at the price
@@ -103,7 +103,7 @@ export type Regime = {
    *      REDSHIFT: collapse past λ_C, the matter self-coheres, the screening cap
    *      lifts, u grows unbounded. No horizon, a surface, no free parameter.
    *
-   *   1  yes. A node with WAYS + n edges gives a source there more ways to pulse
+   *   1  yes. A node with DEG + n edges gives a source there more ways to pulse
    *      into, so `M_eff = M(1 + κu)` and `u = u₀/(1 − κu₀)` DIVERGES at u₀ = 1.
    *      Dark objects are DARK BY HORIZON, the ordinary kind.
    *
@@ -135,7 +135,7 @@ export type Regime = {
    * edge count rather than fixed at one emitter a cell.
    *
    *   0  ρ_max = 1. One emitter to a cell, everywhere.
-   *   1  ρ_max = 1 + u. A node with WAYS + n edges fits more distinct emitters,
+   *   1  ρ_max = 1 + u. A node with DEG + n edges fits more distinct emitters,
    *      each still the same m ≤ 1 thing.
    *
    * DISTINCT FROM `boost`, and the distinction is the whole point. `boost` makes
@@ -144,7 +144,7 @@ export type Regime = {
    * place, so a fixed mass emits exactly what it always did and β is untouched.
    *
    * What it buys: `M = (4/3)πR³/(1 − (4/3)πGR²)` diverges at
-   * `R_c = √(3π·WAYS)/SHEET = 1.9567 cells`, so every collapsed object is the
+   * `R_c = √(3π·DEG)/SHEET = 1.9567 cells`, so every collapsed object is the
    * same size — a hair under two Planck lengths — with u ∝ M. Darkness becomes
    * automatic, needing neither the coherence argument nor a horizon.
    *
@@ -346,7 +346,7 @@ export const stepping = (m: number, k: number, r: Regime = FULL) => {
  * is worth more than either.
  *
  * AND FRACTIONAL DIMENSIONS DO NOT WORK HERE, which is worth knowing before
- * building on them. `SHEET` and `WAYS` are `3^(d−1) − 1` and `3^d − 1` and are
+ * building on them. `SHEET` and `DEG` are `3^(d−1) − 1` and `3^d − 1` and are
  * perfectly happy off the integers — d = 2.5 gives 4.196 and 14.588, and every
  * counting argument in `gravity.ts` would still run. But a Clifford algebra has
  * no fractional representation: you cannot have 2.83 anticommuting matrices.
@@ -365,7 +365,7 @@ export const stepping = (m: number, k: number, r: Regime = FULL) => {
  * Nothing here decides it, and recording that it is a decision is the point.
  *
  * ONE THING FRACTIONAL d DOES SETTLE, though, and it settles it negatively:
- * `WAYS/SHEET` is bounded BELOW by 3 at every d — 5.73 at 1.5, 4.00 at 2, 3.25
+ * `DEG/SHEET` is bounded BELOW by 3 at every d — 5.73 at 1.5, 4.00 at 2, 3.25
  * at 3, tending to 3 from above — and closing `SPREAD` needs it to be 3/π =
  * 0.955. So no dimension rescues that factor of 3.4034, fractional or not. It
  * was already known that no integer d does; this closes the continuous case too.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
index ddc6942..075d19b 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
@@ -14,7 +14,7 @@ Each file is standalone TypeScript with **no imports** — it carries its own
 constants and its own copy of whatever geometry it needs. That duplication is
 deliberate: a test should be readable and runnable on its own, and should not
 break because the article was edited. Where a test needs the lattice constants
-it recomputes them from `SHEET`, `WAYS`, `BITE`, `CORE` rather than importing
+it recomputes them from `SHEET`, `DEG`, `BITE`, `CORE` rather than importing
 `G_LATTICE`, so a change to the definitions shows up as a test failure rather
 than as silent agreement.
 
@@ -86,7 +86,7 @@ than as silent agreement.
 
 | | |
 |---|---|
-| `recon`, `which138` | the two a₀ derivations differ by exactly `WAYS/2·SHEET` = 13/8, and which one the surviving mechanism selects |
+| `recon`, `which138` | the two a₀ derivations differ by exactly `DEG/2·SHEET` = 13/8, and which one the surviving mechanism selects |
 | `accum`, `accumulate` | whether the fold really accumulates — it reaches a **steady state** in λ/c, which retires the defect |
 | `asym` | the fixed-point exponents, converged to five figures |
 
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accumulate.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accumulate.ts
index 2022a1c..f129aac 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accumulate.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/accumulate.ts
@@ -18,8 +18,8 @@
  * soon as those balance. Solve it and see whether the profile settles or runs.
  */
 
-const SHEET = 8, BITE = 1, WAYS = 26, CORE = 0.5, LIGHT = 1;
-const G_LAT = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const SHEET = 8, BITE = 1, DEG = 26, CORE = 0.5, LIGHT = 1;
+const G_LAT = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 
 console.log("=".repeat(76));
 console.log("1. THE NAIVE COUNT, WHICH IS WHAT THE DEFECT SAYS");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/blocking.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/blocking.ts
index f310629..c3123c2 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/blocking.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/blocking.ts
@@ -15,7 +15,7 @@
  */
 
 const G = 6.67430e-11, MSUN = 1.98847e30, KPC = 3.0857e19, C = 2.99792458e8;
-const WAYS = 26;                                   // directions out of a cell
+const DEG = 26;                                   // directions out of a cell
 const H0 = 70.9e3 / 3.0856775814913673e22;
 const A0 = C * H0 / (2 * Math.PI);
 
@@ -52,7 +52,7 @@ console.log("=".repeat(78));
 console.log("2. WHICH WAY THE PAIR GOES — the part that has not been asked");
 console.log("=".repeat(78));
 console.log("  A carrier streaming along ĝ occupies the cell in THAT direction.");
-console.log("  The split cannot go that way, but the point has WAYS = 26 exits");
+console.log("  The split cannot go that way, but the point has DEG = 26 exits");
 console.log("  and only the occupied ones are shut. So the pair is emitted with");
 console.log("  the field direction removed — an ANISOTROPIC source.");
 console.log();
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/budget.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/budget.ts
index a95620a..f3107e4 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/budget.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/budget.ts
@@ -24,9 +24,9 @@ const MU0 = 4e-7 * Math.PI, ME = 9.1093837015e-31, MU_B = 9.2740100783e-24;
 const M_PLANCK = Math.sqrt(HBAR * C / G_N);
 
 const DIMS = 3;
-const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
 const BITE = 1, CORE = 0.5, LIGHT = 1, CYCLE = 8;
-const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 const MU = G_LATTICE * M_PLANCK;
 
 /** pulses a second, for a mass in kg — `beat = 1/m` read in SI */
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/combined.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/combined.ts
index 2ae1802..6ed79ad 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/combined.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/combined.ts
@@ -25,8 +25,8 @@ const LP = 1.616255e-35, TP = 5.391247e-44, MP = 2.176434e-8;
 const H0 = 70.9e3 / MPC, T0 = 1 / H0;
 
 // the lattice's own constants
-const SHEET = 8, WAYS = 26, BITE = 1, CORE = 0.5, LIGHT = 1;
-const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const SHEET = 8, DEG = 26, BITE = 1, CORE = 0.5, LIGHT = 1;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 const MU = G_LATTICE * MP;
 
 const A0 = C * H0 / (2 * Math.PI);              // the prediction, cH₀/2π
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/coulomb.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/coulomb.ts
index aae97c5..eaa05cb 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/coulomb.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/coulomb.ts
@@ -51,9 +51,9 @@ const ALPHA = 7.2973525693e-3;
 const M_PLANCK = Math.sqrt(HBAR * C / G_N);
 
 const DIMS = 3;
-const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
 const BITE = 1, CORE = 0.5, LIGHT = 1, CYCLE = 8;
-const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 
 /** the fraction of meetings that annihilate, given the two biases */
 const annihilating = (Pa: number, Pb: number) => (1 - Pa * Pb) / 2;
@@ -188,11 +188,11 @@ console.log("6. AND A FIT TO α WOULD MEAN NOTHING — measured, so it stays mea
 console.log("=".repeat(78));
 console.log("   It is tempting to look for 137.036 in the lattice counts. Here is");
 console.log("   why that is not evidence: search every monomial");
-console.log("      2^a · 3^b · π^c · SHEET^d · WAYS^e · CORE^f,  exponents in −3..3");
+console.log("      2^a · 3^b · π^c · SHEET^d · DEG^e · CORE^f,  exponents in −3..3");
 console.log("   and count how many land within half a percent of it.\n");
 {
-  const base = [2, 3, Math.PI, SHEET, WAYS, CORE];
-  const names = ["2", "3", "π", "SHEET", "WAYS", "CORE"];
+  const base = [2, 3, Math.PI, SHEET, DEG, CORE];
+  const names = ["2", "3", "π", "SHEET", "DEG", "CORE"];
   const target = 1 / ALPHA;
   let hits = 0, total = 0;
   const found: string[] = [];
@@ -219,12 +219,12 @@ console.log("=".repeat(78));
 console.log("7. WHAT THE MISSING CHANNEL WOULD HAVE TO BE");
 console.log("=".repeat(78));
 console.log("   The fold is the only force channel this model has: an annihilation");
-console.log("   removes a cell and leans a path by BIAS = LIGHT/WAYS = 1/26. The");
+console.log("   removes a cell and leans a path by BIAS = LIGHT/DEG = 1/26. The");
 console.log("   OTHER outcome — alike charges turning around — transfers momentum");
 console.log("   too, and `gravity.ts` does not count it as a force at all.");
 console.log("   That is the gap, and it has a size:\n");
 {
-  const BIAS = LIGHT / WAYS;
+  const BIAS = LIGHT / DEG;
   const need = (E_Q * E_Q / (4 * Math.PI * EPS0)) / (G_N * ME * ME);
   console.log(`      BIAS, per annihilation                ${BIAS.toFixed(6)} cells/tick`);
   console.log(`      momentum a returned charge carries    2 (out at c, back at c)`);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/dipole.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/dipole.ts
index 24c7022..c12e81e 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/dipole.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/dipole.ts
@@ -41,7 +41,7 @@
  */
 
 const DIMS = 3;
-const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
 const CYCLE = 8, CORE = 0.5;
 
 type V = [number, number, number];
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/frontcheck.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/frontcheck.ts
index e4906ec..deca890 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/frontcheck.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/frontcheck.ts
@@ -6,7 +6,7 @@
 const C = 2.99792458e8, G = 6.67430e-11;
 const MPC = 3.0856775814913673e22, GYR = 3.1557e16;
 const LP = 1.616255e-35, TP = 5.391247e-44, MP = 2.176434e-8;
-const SHEET = 8, WAYS = 26, BITE = 1, SHARE = 0.5;
+const SHEET = 8, DEG = 26, BITE = 1, SHARE = 0.5;
 const G_LATTICE = 0.06235150;
 const MU = G_LATTICE * MP;
 
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel2.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel2.ts
index efbe61e..ef1b232 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel2.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/genzel2.ts
@@ -46,7 +46,7 @@ const boosted = (gN: number, a0: number) => gN / 2 + Math.sqrt(gN * gN / 4 + gN
 const CEIL = 1 / Math.sqrt(0.8);                 // f_DM < 0.2  ⇒  v/v_bar < 1.118
 
 console.log("=".repeat(78));
-console.log("THE TWO WAYS OF GETTING g_N AT Re, AND THEY DISAGREE");
+console.log("THE TWO DEG OF GETTING g_N AT Re, AND THEY DISAGREE");
 console.log("=".repeat(78));
 console.log(`   ceiling from f_DM < 0.2 : ${CEIL.toFixed(4)}\n`);
 console.log("   galaxy         g_N point   g_N disc    ratio   boost pt   boost disc");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/magnets.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/magnets.ts
index 335b946..33d8909 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/magnets.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/magnets.ts
@@ -38,9 +38,9 @@ const MU_B = 9.2740100783e-24;
 const M_PLANCK = Math.sqrt(HBAR * C / G_N);
 
 const DIMS = 3;
-const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
 const BITE = 1, CORE = 0.5, LIGHT = 1;
-const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 const MU = G_LATTICE * M_PLANCK;
 
 /** pulses a second, for a mass in kg — `beat = 1/m` read in SI */
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts
index a3169de..83609ca 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts
@@ -23,9 +23,9 @@ const ALPHA = 7.2973525693e-3;
 const M_PLANCK = Math.sqrt(HBAR * C / G_N);
 
 const DIMS = 3;
-const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
 const BITE = 1, CORE = 0.5, LIGHT = 1, CYCLE = 8;
-const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 
 console.log("=".repeat(78));
 console.log("1. GAUSS'S LAW IS THE EMISSION RULE — checked");
@@ -48,7 +48,7 @@ console.log("=".repeat(78));
 console.log("2. AND ∇·B = 0 IS FORCED BY WHAT AN AXIS IS — checked");
 console.log("=".repeat(78));
 console.log("   A sided source puts + into every exit on one side of its axis and");
-console.log("   − into every exit on the other. There are only WAYS = 26 of them,");
+console.log("   − into every exit on the other. There are only DEG = 26 of them,");
 console.log("   so the net is a COUNT, and it is nought for every axis there is:\n");
 const EXITS: number[][] = [];
 for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/moment.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/moment.ts
index 0c920c6..615f7dc 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/moment.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/moment.ts
@@ -28,9 +28,9 @@ const ALPHA = 7.2973525693e-3;
 const G_MEASURED = 2.00231930436256;
 
 const DIMS = 3;
-const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
 const BITE = 1, CORE = 0.5, LIGHT = 1, CYCLE = 8;
-const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 
 console.log("=".repeat(78));
 console.log("1. THE MAGNETON THE MODEL ACTUALLY GIVES");
@@ -53,7 +53,7 @@ console.log("=".repeat(78));
   console.log("   and having a place is not having a derivation. If it were the");
   console.log("   right factor the count would read:\n");
   const alt = 2 * SHEET * G_LATTICE;
-  console.log(`      2·SHEET·G = 2·SHEET³/(8π²·CORE·WAYS) = 1024/(104π²) = ${alt.toFixed(6)} µ_B`);
+  console.log(`      2·SHEET·G = 2·SHEET³/(8π²·CORE·DEG) = 1024/(104π²) = ${alt.toFixed(6)} µ_B`);
   console.log(`      measured µ_e/µ_B                                    = ${(G_MEASURED / 2).toFixed(6)} µ_B`);
   console.log(`      off by                                              ${(100 * (alt / (G_MEASURED / 2) - 1)).toFixed(3)}%`);
   console.log("\n   A near miss, in the wrong direction: the measured anomaly is");
@@ -102,7 +102,7 @@ console.log("3. AND THE LATTICE QUANTISES WHICH WAY A MAGNET CAN POINT");
 console.log("=".repeat(78));
 console.log("   A held emitter puts + into every exit whose projection on its axis");
 console.log("   is positive, − into every negative one, and nothing into the ones");
-console.log("   exactly across. There are only WAYS = 26 exits, so the split is a");
+console.log("   exactly across. There are only DEG = 26 exits, so the split is a");
 console.log("   COUNT and it depends on which way the axis points:\n");
 
 const EXITS: number[][] = [];
@@ -129,9 +129,9 @@ const AXES: [string, number[]][] = [
 const frac: Record<string, number> = {};
 for (const [n, a] of AXES) {
   const s = split(a);
-  frac[n] = s.p / WAYS;
+  frac[n] = s.p / DEG;
   console.log(`   ${n.padEnd(14)} ${String(s.p).padStart(6)}     ${String(s.e).padStart(6)}     ` +
-    `${String(s.n).padStart(6)}     ${(s.p / WAYS).toFixed(4)}`);
+    `${String(s.n).padStart(6)}     ${(s.p / DEG).toFixed(4)}`);
 }
 console.log(`\n   Note the equator of a face axis is exactly SHEET = ${SHEET}, which is`);
 console.log("   what one pulse is. So a face-aligned magnet wastes a whole pulse's");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts
index 4e16fb5..45a1271 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/nopolarity.ts
@@ -16,13 +16,13 @@
  *   share      half of them are opposite, so ½    all of them, so 1
  *
  * Those two changes pull opposite ways and the file measures which wins where.
- * Everything else — `chance`, `SHEET`, `WAYS`, `BITE`, `MADE`, `SPREAD`,
+ * Everything else — `chance`, `SHEET`, `DEG`, `BITE`, `MADE`, `SPREAD`,
  * `BIAS`, the accumulation, the ceiling — never mentions a sign and is
  * untouched by construction.
  */
 
 const DIMS = 3;
-const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
 const BITE = 1, CORE = 0.5, LIGHT = 1;
 const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
 const M_PLANCK = Math.sqrt(HBAR * C / G_N);
@@ -32,7 +32,7 @@ const MPC = 3.0856775814913673e22, KPC = 3.0857e19, MSUN = 1.98847e30;
 const SHARE = { xor: 0.5, plain: 1.0 };
 
 const G_OF = (share: number) =>
-  BITE * SHEET * SHEET * LIGHT * share / (4 * Math.PI * Math.PI * CORE * WAYS);
+  BITE * SHEET * SHEET * LIGHT * share / (4 * Math.PI * Math.PI * CORE * DEG);
 
 console.log("=".repeat(78));
 console.log("1. THE CONSTANTS — which move and which do not");
@@ -41,11 +41,11 @@ const Gx = G_OF(SHARE.xor), Gp = G_OF(SHARE.plain);
 console.log("      quantity                  with polarity     without         moves?");
 const rows: [string, number, number][] = [
   ["SHEET", SHEET, SHEET],
-  ["WAYS", WAYS, WAYS],
+  ["DEG", DEG, DEG],
   ["BITE", BITE, BITE],
-  ["BIAS = LIGHT/WAYS", LIGHT / WAYS, LIGHT / WAYS],
-  ["MADE = 3·BITE·SHEET/πWAYS", 3 * BITE * SHEET / (Math.PI * WAYS), 3 * BITE * SHEET / (Math.PI * WAYS)],
-  ["SPREAD", Math.PI * WAYS * LIGHT / (3 * BITE * SHEET), Math.PI * WAYS * LIGHT / (3 * BITE * SHEET)],
+  ["BIAS = LIGHT/DEG", LIGHT / DEG, LIGHT / DEG],
+  ["MADE = 3·BITE·SHEET/πWAYS", 3 * BITE * SHEET / (Math.PI * DEG), 3 * BITE * SHEET / (Math.PI * DEG)],
+  ["SPREAD", Math.PI * DEG * LIGHT / (3 * BITE * SHEET), Math.PI * DEG * LIGHT / (3 * BITE * SHEET)],
   ["G_LATTICE", Gx, Gp],
   ["MU = G·m_Planck (kg)", Gx * M_PLANCK, Gp * M_PLANCK],
   ["REACHES", Math.sqrt(8 * Math.PI * Gx / (3 * BITE * SHARE.xor * SHEET)),
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/poles.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/poles.ts
index 1b1f9cf..ab9d07c 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/poles.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/poles.ts
@@ -27,7 +27,7 @@
  */
 
 const DIMS = 3;
-const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
 const CORE = 0.5;
 
 type V = [number, number, number];
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pulses.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pulses.ts
index cd0c833..3f432a8 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pulses.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pulses.ts
@@ -23,9 +23,9 @@ const T_PLANCK = Math.sqrt(HBAR * G_N / (C * C * C * C * C));
 // the lattice's own constants, recomputed rather than imported
 const DIMS = 3;
 const SHEET = Math.pow(3, DIMS - 1) - 1;      // 8  — charges in one pulse
-const WAYS = Math.pow(3, DIMS) - 1;           // 26 — ways out of a point
+const DEG = Math.pow(3, DIMS) - 1;           // 26 — ways out of a point
 const BITE = 1, CORE = 0.5, LIGHT = 1;
-const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 
 // the largest thing that can pulse on its own: once a tick is the ceiling
 const MU = G_LATTICE * M_PLANCK;
@@ -40,8 +40,8 @@ const pulses = (m: number) => 1 / period(m);
 console.log("=".repeat(78));
 console.log("1. THE CONSTANTS");
 console.log("=".repeat(78));
-console.log(`   SHEET ${SHEET}   WAYS ${WAYS}   BITE ${BITE}   CORE ${CORE}`);
-console.log(`   G_LATTICE = SHEET²/(8π²·CORE·WAYS) = ${G_LATTICE.toFixed(8)}`);
+console.log(`   SHEET ${SHEET}   DEG ${DEG}   BITE ${BITE}   CORE ${CORE}`);
+console.log(`   G_LATTICE = SHEET²/(8π²·CORE·DEG) = ${G_LATTICE.toFixed(8)}`);
 console.log(`   1/G_LATTICE = ${(1 / G_LATTICE).toFixed(4)}   (2·SHEET = ${2 * SHEET}, off by ` +
   `${(100 * (1 / G_LATTICE / (2 * SHEET) - 1)).toFixed(2)}% — noted, not derived)`);
 console.log(`   MU = G·m_Planck = ${(MU * 1e9).toFixed(3)} µg   — the largest elementary mass`);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/scale.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/scale.ts
index 10bdb66..7d0587c 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/scale.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/scale.ts
@@ -32,9 +32,9 @@ const MU0 = 4e-7 * Math.PI, MU_B = 9.2740100783e-24, MU_N = 5.0507837461e-27;
 const M_PLANCK = Math.sqrt(HBAR * C / G_N);
 
 const DIMS = 3;
-const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
 const BITE = 1, CORE = 0.5, LIGHT = 1, CYCLE = 8;
-const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 const MU = G_LATTICE * M_PLANCK;
 
 /** the model's own magneton, from `moment`: CYCLE·G/2π, in units of µ_B */
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/tradeoff.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/tradeoff.ts
index 4e9138c..234a6a5 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/tradeoff.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/tradeoff.ts
@@ -25,9 +25,9 @@ const MU0 = 4e-7 * Math.PI;
 const M_PLANCK = Math.sqrt(HBAR * C / G_N);
 
 const DIMS = 3;
-const SHEET = Math.pow(3, DIMS - 1) - 1, WAYS = Math.pow(3, DIMS) - 1;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
 const BITE = 1, CORE = 0.5, LIGHT = 1;
-const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 const MU = G_LATTICE * M_PLANCK;
 
 const pulses = (m: number) => m * C * C / (G_LATTICE * HBAR);
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/which138.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/which138.ts
index 78b3405..39ec3c8 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/which138.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/which138.ts
@@ -7,12 +7,12 @@
  *   A   a₀ = 4πG/(SHEET·t₀)      "a carrier meets about one other in a lifetime"
  *   B   a₀ = c·H₀/2π             "the field falls to the expansion's own scale"
  *
- *   A/B = 8π²G_LATTICE/SHEET = 2·SHEET/WAYS = 8/13, exactly.
+ *   A/B = 8π²G_LATTICE/SHEET = 2·SHEET/DEG = 8/13, exactly.
  */
 
 const C = 2.99792458e8, MPC = 3.0856775814913673e22, TP = 5.391247e-44;
-const SHEET = 8, WAYS = 26, BITE = 1, CORE = 0.5, LIGHT = 1;
-const G_LAT = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * WAYS);
+const SHEET = 8, DEG = 26, BITE = 1, CORE = 0.5, LIGHT = 1;
+const G_LAT = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
 const H0 = 70.9e3 / MPC, T0 = 1 / H0, T0_TICKS = T0 / TP;
 const LP = 1.616255e-35;
 const toSI = LP / (TP * TP);
@@ -29,8 +29,8 @@ console.log(`   B  expansion  c·H₀/2π         = ${B.toExponential(4)}   shor
 console.log(`   measured                      = ${MEASURED.toExponential(4)}`);
 console.log();
 console.log(`   B/A = ${(B / A).toFixed(6)}`);
-console.log(`   WAYS/(2·SHEET) = ${(WAYS / (2 * SHEET)).toFixed(6)}   ( = 13/8 )`);
-console.log(`   difference = ${Math.abs(B / A - WAYS / (2 * SHEET)).toExponential(2)}`);
+console.log(`   DEG/(2·SHEET) = ${(DEG / (2 * SHEET)).toFixed(6)}   ( = 13/8 )`);
+console.log(`   difference = ${Math.abs(B / A - DEG / (2 * SHEET)).toExponential(2)}`);
 console.log();
 console.log("   So the gap is a pure count and NOT a numerical accident. But that");
 console.log("   does not say which is right, because they are not the same count.");
@@ -83,12 +83,12 @@ console.log(`   needed: ${need.toFixed(4)}`);
 const cands: [string, number][] = [
   ["√π", Math.sqrt(Math.PI)],
   ["π/2 ", Math.PI / 2],
-  ["WAYS/(2·SHEET)", WAYS / (2 * SHEET)],
-  ["√(WAYS/SHEET)", Math.sqrt(WAYS / SHEET)],
-  ["2·SHEET/WAYS·π/2", 2 * SHEET / WAYS * Math.PI / 2],
+  ["DEG/(2·SHEET)", DEG / (2 * SHEET)],
+  ["√(DEG/SHEET)", Math.sqrt(DEG / SHEET)],
+  ["2·SHEET/DEG·π/2", 2 * SHEET / DEG * Math.PI / 2],
   ["16/9", 16 / 9],
   ["e/√e·…  (√e)", Math.sqrt(Math.E)],
-  ["WAYS/SHEET/√π", WAYS / SHEET / Math.sqrt(Math.PI)],
+  ["DEG/SHEET/√π", DEG / SHEET / Math.sqrt(Math.PI)],
 ];
 console.log("      candidate            value     off by");
 for (const [n, v] of cands)
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
index 4b4acab..642b093 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/views.tsx
@@ -37,6 +37,7 @@ const LatticePlayer = ({
   height = 150,
   density = true,
   mode = 'lattice',
+  polarities = true,
   interval = 0.45,
 }: Lattice) => {
   const [running, setRunning] = useState(autoplay);
@@ -126,6 +127,7 @@ const LatticePlayer = ({
         animate
         density={density}
         mode={mode}
+        polarities={polarities}
         onFrame={onFrame}
         onVisible={onVisible}
       />
@@ -188,6 +190,7 @@ const LatticeFilmstrip = ({
   height = 150,
   density = true,
   mode = 'lattice',
+  polarities = true,
   backwards = false,
 }: Lattice) => {
   const frames = useMemo(() => {
@@ -219,7 +222,9 @@ const LatticeFilmstrip = ({
           </div>
           : null}
         <div style={{ flex: '1 1 120px', height }}>
-          <GraphCanvas graph={() => graph} density={density} mode={mode} />
+          <GraphCanvas
+            graph={() => graph} density={density} mode={mode} polarities={polarities}
+          />
         </div>
       </Fragment>
     ))}
diff --git a/orbitmines.com/src/routes/profiles/fadi-shawki/bibliography.ts b/orbitmines.com/src/routes/profiles/fadi-shawki/bibliography.ts
new file mode 100644
index 0000000..ffc2dbe
--- /dev/null
+++ b/orbitmines.com/src/routes/profiles/fadi-shawki/bibliography.ts
@@ -0,0 +1,4789 @@
+/**
+ * Everything read, watched, worked at and attended — the bibliography the
+ * articles cite from.
+ *
+ * It was in `fadi_shawki.ts` next to the profile, and that turned out to be
+ * expensive in a way that had nothing to do with either of them. The profile is
+ * what `references.tsx` names in order to put an author on a paper, so every
+ * paper on the site imported this module; the profile's `content` pointed at a
+ * dozen entries in here, which kept the whole four thousand line literal alive;
+ * and so every article shipped the complete bibliography in order to print one
+ * name under its title.
+ *
+ * Split, the profile is a few lines and this is imported by the three places
+ * that actually cite from it. Nothing in here changed in the move.
+ */
+import ORGANIZATIONS, {Content, ExternalProfile, TProfile, Viewed} from '../../../lib/organizations/ORGANIZATIONS';
+
+// TODO: Just a crude initi\al setup while the interface is not yet workable
+
+const string = `
+- [An Infinity of Worlds: Cosmic Inflation and the Beginning of the Universe (2022)](https://books.google.nl/books/about/An_Infinity_of_Worlds.html?id=G3aMEAAAQBAJ&source=kp_book_description&redir_esc=y) ; *Will Kinney*
+
+- :youtube: :lex_fridman_podcast: [State of AI in 2026: LLMs, Coding, Scaling Laws, China, Agents, GPUs, AGI | #490 (2026)](https://www.youtube.com/watch?v=EV7WhVT270Q&t=2s) ;  *Nathan Lambert, Sebastian Raschka, Lex Fridman*
+- :youtube: :lex_fridman_podcast: [OpenClaw: The Viral AI Agent that Broke the Internet - Peter Steinberger | #491 (2026)](https://www.youtube.com/watch?v=YFjfBk8HI5o&t=2s) ;  *Peter Steinberger, Lex Fridman*
+- :youtube: :lex_fridman_podcast: [Jeff Kaplan: World of Warcraft, Overwatch, Blizzard, and Future of Gaming | #493 (2026)](https://www.youtube.com/watch?v=H9rF1CSSh-w&t=8566s&pp=0gcJCd4KAYcqIYzv) ;  *Jeff Kaplan, Lex Fridman*
+- :youtube: :lex_fridman_podcast: [Jensen Huang: NVIDIA - The $4 Trillion Company & the AI Revolution | #494 (2026)](https://www.youtube.com/watch?v=vif8NQcjVf0&t=1s) ;  *Jensen Huang, Lex Fridman*
+- :youtube: :lex_fridman_podcast: [Vikings, Ragnar, Berserkers, Valhalla & the Warriors of the Viking Age | #495 (2026)](https://www.youtube.com/watch?v=iKx3gAODybU) ;  *Lars Brownworth, Lex Fridman*
+- :youtube: :cool_worlds_podcast: [#31 Joshua Winn - Exoplanet New Discoveries, History and Future (2026)](https://www.youtube.com/watch?v=ISZHVwY5YjE) ;  *Joshua Winn, David Kipping*
+- :youtube: :cool_worlds_podcast: [#32 Chris Lintott - Technosignatures, Citizen Science, Scicomm (2026)](https://www.youtube.com/watch?v=qI3DAXM0-do) ;  *Chris Lintott, David Kipping*
+- :youtube: :topos_institute: [Dan Ghica: Designing and developing an industrial-strength programming language (2026)](https://www.youtube.com/watch?v=oFGc4hGJRJQ) ;  *Dan Ghica*
+- :youtube: [Where We’re Going, We Don’t Need Rows: Columnar Data Connectivity with Apache Arrow ADBC (2025)](https://www.youtube.com/watch?v=TjlmNGNx77E) ;  *Ian Cook*
+- :youtube: [Vortex: LLVM for File Formats (2025)](https://www.youtube.com/watch?v=zyn_T5uragA) ;  *Will Manning*
+- :youtube: [DuckLake: Learning from Cloud Data Warehouses to Build a Robust “Lakehouse” (2025)](https://www.youtube.com/watch?v=z2GhznqtIz0) ;  *Jordan Tigani*
+- :youtube: [An Extremely Technical Overview of How Apache Iceberg Planning Actually Works (2025)](https://www.youtube.com/watch?v=kJaD0WuQ1Bg) ;  *Russell Spitzer*
+`
+
+export const REFERENCES = {
+  THE_METAVERSE_BUILDING_THE_SPATIAL_INTERNET: <Content>{  
+    reference: {                 title: 'The Metaverse: Building the Spatial Internet',      
+          authors: [{name: 'Matthew Ball'}],      
+          organizations: [],  
+          year: '(2024)',      
+          link: "https://books.google.nl/books/about/The_Metaverse.html?id=BirjEAAAQBAJ"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'     
+  },
+  THE_DECOMPILATION_WIKI: <Content>{  
+    reference: {                 title: 'The Decompilation Wiki',      
+          authors: [{name: 'Zion Leonahenahe Basque'}],      
+          organizations: [],  
+          year: '',      
+          link: "https://decompilation.wiki/"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  DECOMPILING_2024_A_YEAR_OF_RESURGENCE_IN_DECOMPILATION_RESEARCH: <Content>{  
+    reference: {                 title: 'Decompiling 2024: A Year of Resurgence in Decompilation Research',      
+          authors: [{name: 'Zion Leonahenahe Basque'}],      
+          organizations: [],  
+          year: '(2025)',      
+          link: "https://mahaloz.re/dec-progress-2024"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  _30_YEARS_OF_DECOMPILATION_AND_THE_UNSOLVED_STRUCTURING_PROBLEM_PART_1: <Content>{  
+    reference: {                 title: '30 Years of Decompilation and the Unsolved Structuring Problem: Part 1',      
+          authors: [{name: 'Zion Leonahenahe Basque'}],      
+          organizations: [],  
+          year: '(2024)',      
+          link: "https://mahaloz.re/dec-history-pt1"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  _30_YEARS_OF_DECOMPILATION_AND_THE_UNSOLVED_STRUCTURING_PROBLEM_PART_2: <Content>{  
+    reference: {                 title: '30 Years of Decompilation and the Unsolved Structuring Problem: Part 2',      
+          authors: [{name: 'Zion Leonahenahe Basque'}],      
+          organizations: [],  
+          year: '(2024)',      
+          link: "https://mahaloz.re/dec-history-pt2"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  FFMPEG_THE_INCREDIBLE_TECHNOLOGY_BEHIND_VIDEO_ON_THE_INTERNET_496: <Content>{  
+    reference: {                 title: 'FFmpeg: The Incredible Technology Behind Video on the Internet | #496',      
+          authors: [{name: 'Jean-Baptiste Kempf'},{name: 'Kieran Kunhya'},{name: 'Lex Fridman'}],      
+          organizations: [ORGANIZATIONS.youtube,ORGANIZATIONS.lex_fridman_podcast],  
+          year: '(2026)',      
+          link: "https://www.youtube.com/watch?v=nepKKz-MzFM"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  CREATOR_OF_CPP_BELL_LABS_NEGATIVE_OVERHEAD_ABSTRACTION_MISTAKES_BJARNE_STROUSTRUP: <Content>{  
+    reference: {                 title: 'Creator of C++: Bell Labs, Negative Overhead Abstraction, Mistakes | Bjarne Stroustrup',      
+          authors: [{name: 'Bjarne Stroustrup'},{name: 'Ryan Peterman'}],      
+          organizations: [ORGANIZATIONS.youtube],  
+          year: '(2026)',      
+          link: "https://www.youtube.com/watch?v=U46fJ2bJ-co"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  THE_MAGIC_OF_ARM_W_CASEY_MURATORI: <Content>{  
+    reference: {                 title: 'The Magic Of ARM w/ Casey Muratori',      
+          authors: [{name: 'Casey Muratori'},{name: 'ThePrimeagen'}],      
+          organizations: [ORGANIZATIONS.youtube],  
+          year: '(2024)',      
+          link: "https://www.youtube.com/watch?v=Zr09I5OlOjs"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  X86_NEEDS_TO_DIE: <Content>{  
+    reference: {                 title: 'X86 Needs To Die',      
+          authors: [{name: 'Casey Muratori'},{name: 'ThePrimeagen'}],      
+          organizations: [ORGANIZATIONS.youtube],  
+          year: '(2024)',      
+          link: "https://www.youtube.com/watch?v=xCBrtopAG80"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  THE_REAL_PROBLEMS_W_GIT: <Content>{  
+    reference: {                 title: 'The Real Problems w/ Git',      
+          authors: [{name: 'ThePrimeagen'},{name: 'Casey Muratori'},{name: 'TJ DeVries'},{name: 'David Begin'}],      
+          organizations: [ORGANIZATIONS.youtube],  
+          year: '(2025)',      
+          link: "https://www.youtube.com/watch?v=t6qL_FbLArk"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  THE_ONLY_UNBREAKABLE_LAW: <Content>{  
+    reference: {                 title: 'The Only Unbreakable Law',      
+          authors: [{name: 'Casey Muratori'}],      
+          organizations: [ORGANIZATIONS.youtube],  
+          year: '(2022)',      
+          link: "https://www.youtube.com/watch?v=5IUj1EZwpJY"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+
+  AN_INFINITY_OF_WORLDS_COSMIC_INFLATION_AND_THE_BEGINNING_OF_THE_UNIVERSE: <Content>{  
+    reference: {                 title: 'An Infinity of Worlds: Cosmic Inflation and the Beginning of the Universe',      
+          authors: [{name: 'Will Kinney'}],      
+          organizations: [],  
+          year: '(2022)',      
+          link: "https://books.google.nl/books/about/An_Infinity_of_Worlds.html?id=G3aMEAAAQBAJ&source=kp_book_description&redir_esc=y"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  STATE_OF_AI_IN_2026_LLMS_CODING_SCALING_LAWS_CHINA_AGENTS_GPUS_AGI_490: <Content>{  
+    reference: {                 title: 'State of AI in 2026: LLMs, Coding, Scaling Laws, China, Agents, GPUs, AGI | #490',      
+          authors: [{name: 'Nathan Lambert'},{name: 'Sebastian Raschka'},{name: 'Lex Fridman'}],      
+          organizations: [ORGANIZATIONS.youtube,ORGANIZATIONS.lex_fridman_podcast],  
+          year: '(2026)',      
+          link: "https://www.youtube.com/watch?v=EV7WhVT270Q"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  OPENCLAW_THE_VIRAL_AI_AGENT_THAT_BROKE_THE_INTERNET___PETER_STEINBERGER_491: <Content>{  
+    reference: {                 title: 'OpenClaw: The Viral AI Agent that Broke the Internet - Peter Steinberger | #491',      
+          authors: [{name: 'Peter Steinberger'},{name: 'Lex Fridman'}],      
+          organizations: [ORGANIZATIONS.youtube,ORGANIZATIONS.lex_fridman_podcast],  
+          year: '(2026)',      
+          link: "https://www.youtube.com/watch?v=YFjfBk8HI5o"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  JEFF_KAPLAN_WORLD_OF_WARCRAFT_OVERWATCH_BLIZZARD_AND_FUTURE_OF_GAMING_493: <Content>{  
+    reference: {                 title: 'Jeff Kaplan: World of Warcraft, Overwatch, Blizzard, and Future of Gaming | #493',      
+          authors: [{name: 'Jeff Kaplan'},{name: 'Lex Fridman'}],      
+          organizations: [ORGANIZATIONS.youtube,ORGANIZATIONS.lex_fridman_podcast],  
+          year: '(2026)',      
+          link: "https://www.youtube.com/watch?v=H9rF1CSSh-w"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  JENSEN_HUANG_NVIDIA___THE_4_TRILLION_COMPANY_THE_AI_REVOLUTION_494: <Content>{  
+    reference: {                 title: 'Jensen Huang: NVIDIA - The $4 Trillion Company & the AI Revolution | #494',      
+          authors: [{name: 'Jensen Huang'},{name: 'Lex Fridman'}],      
+          organizations: [ORGANIZATIONS.youtube,ORGANIZATIONS.lex_fridman_podcast],  
+          year: '(2026)',      
+          link: "https://www.youtube.com/watch?v=vif8NQcjVf0"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  VIKINGS_RAGNAR_BERSERKERS_VALHALLA_THE_WARRIORS_OF_THE_VIKING_AGE_495: <Content>{  
+    reference: {                 title: 'Vikings, Ragnar, Berserkers, Valhalla & the Warriors of the Viking Age | #495',      
+          authors: [{name: 'Lars Brownworth'},{name: 'Lex Fridman'}],      
+          organizations: [ORGANIZATIONS.youtube,ORGANIZATIONS.lex_fridman_podcast],  
+          year: '(2026)',      
+          link: "https://www.youtube.com/watch?v=iKx3gAODybU"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  _31_JOSHUA_WINN___EXOPLANET_NEW_DISCOVERIES_HISTORY_AND_FUTURE: <Content>{  
+    reference: {                 title: '#31 Joshua Winn - Exoplanet New Discoveries, History and Future',      
+          authors: [{name: 'Joshua Winn'},{name: 'David Kipping'}],      
+          organizations: [ORGANIZATIONS.youtube,ORGANIZATIONS.cool_worlds_podcast],  
+          year: '(2026)',      
+          link: "https://www.youtube.com/watch?v=ISZHVwY5YjE"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  _32_CHRIS_LINTOTT___TECHNOSIGNATURES_CITIZEN_SCIENCE_SCICOMM: <Content>{  
+    reference: {                 title: '#32 Chris Lintott - Technosignatures, Citizen Science, Scicomm',      
+          authors: [{name: 'Chris Lintott'},{name: 'David Kipping'}],      
+          organizations: [ORGANIZATIONS.youtube,ORGANIZATIONS.cool_worlds_podcast],  
+          year: '(2026)',      
+          link: "https://www.youtube.com/watch?v=qI3DAXM0-do"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  DAN_GHICA_DESIGNING_AND_DEVELOPING_AN_INDUSTRIAL_STRENGTH_PROGRAMMING_LANGUAGE: <Content>{  
+    reference: {                 title: 'Dan Ghica: Designing and developing an industrial-strength programming language',      
+          authors: [{name: 'Dan Ghica'}],      
+          organizations: [ORGANIZATIONS.youtube,ORGANIZATIONS.topos_institute],  
+          year: '(2026)',      
+          link: "https://www.youtube.com/watch?v=oFGc4hGJRJQ"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  WHERE_WE_RE_GOING_WE_DON_T_NEED_ROWS_COLUMNAR_DATA_CONNECTIVITY_WITH_APACHE_ARROW_ADBC: <Content>{  
+    reference: {                 title: 'Where We\'re Going, We Don\'t Need Rows: Columnar Data Connectivity with Apache Arrow ADBC',      
+          authors: [{name: 'Ian Cook'}],      
+          organizations: [ORGANIZATIONS.youtube],  
+          year: '(2025)',      
+          link: "https://www.youtube.com/watch?v=TjlmNGNx77E"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  VORTEX_LLVM_FOR_FILE_FORMATS: <Content>{  
+    reference: {                 title: 'Vortex: LLVM for File Formats',      
+          authors: [{name: 'Will Manning'}],      
+          organizations: [ORGANIZATIONS.youtube],  
+          year: '(2025)',      
+          link: "https://www.youtube.com/watch?v=zyn_T5uragA"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  DUCKLAKE_LEARNING_FROM_CLOUD_DATA_WAREHOUSES_TO_BUILD_A_ROBUST_LAKEHOUSE: <Content>{  
+    reference: {                 title: 'DuckLake: Learning from Cloud Data Warehouses to Build a Robust “Lakehouse”',      
+          authors: [{name: 'Jordan Tigani'}],      
+          organizations: [ORGANIZATIONS.youtube],  
+          year: '(2025)',      
+          link: "https://www.youtube.com/watch?v=z2GhznqtIz0"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+  AN_EXTREMELY_TECHNICAL_OVERVIEW_OF_HOW_APACHE_ICEBERG_PLANNING_ACTUALLY_WORKS: <Content>{  
+    reference: {                 title: 'An Extremely Technical Overview of How Apache Iceberg Planning Actually Works',      
+          authors: [{name: 'Russell Spitzer'}],      
+          organizations: [ORGANIZATIONS.youtube],  
+          year: '(2025)',      
+          link: "https://www.youtube.com/watch?v=kJaD0WuQ1Bg"      
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"     
+  },
+
+  THE_STRANGEST_MAN: <Content>{
+    reference: {
+      title: 'The Strangest Man',
+      authors: [{name: 'Graham Farmelo'}],
+      organizations: [],
+      year: '(2009)',
+      link: "https://en.wikipedia.org/wiki/The_Strangest_Man"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  ECCE_HOMO: <Content>{
+    reference: {
+      title: 'Ecce Homo',
+      authors: [{name: 'Friedrich Nietzsche'}],
+      organizations: [],
+      year: '(1908)',
+      link: "https://en.wikipedia.org/wiki/Ecce_Homo_(book)"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  THE_THREE_BODY_PROBLEM: <Content>{
+    reference: {
+      title: 'The Three-Body Problem',
+      authors: [{name: 'Liu Cixin'}],
+      organizations: [],
+      year: '(2008)',
+      link: "https://en.wikipedia.org/wiki/The_Three-Body_Problem_(novel)"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  WOOL: <Content>{
+    reference: {
+      title: 'Wool',
+      authors: [{name: 'Hugh Howey'}],
+      organizations: [],
+      year: '(2011)',
+      link: "https://en.wikipedia.org/wiki/Silo_(series)"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  SHIFT: <Content>{
+    reference: {
+      title: 'Shift',
+      authors: [{name: 'Hugh Howey'}],
+      organizations: [],
+      year: '(2013)',
+      link: "https://en.wikipedia.org/wiki/Silo_(series)"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  HARRY_POTTER_1_7: <Content>{
+    reference: {
+      title: 'Harry Potter 1-7',
+      authors: [{name: 'J. K. Rowling'}],
+      organizations: [],
+      year: '(1997-2007)',
+      link: "https://en.wikipedia.org/wiki/Harry_Potter"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  PROPOSITIONS_AS_TYPES: <Content>{
+    reference: {
+      title: '"Propositions as Types"',
+      authors: [{name: 'Philip Wadler'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '(2015)',
+      link: "https://www.youtube.com/watch?v=IOiZatlZtGU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PROGRAMMING_DISTRIBUTED_SYSTEMS: <Content>{
+    reference: {
+      title: '"Programming Distributed Systems"',
+      authors: [{name: 'Mae Milano'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '(2023)',
+      link: "https://www.youtube.com/watch?v=Mc3tTRkjCvE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  DAN_HOUSER_GTA_RED_DEAD_REDEMPTION_ROCKSTAR_ABSURD_FUTURE_OF_GAMING_484: <Content>{
+    reference: {
+      title: 'Dan Houser: GTA, Red Dead Redemption, Rockstar, Absurd & Future of Gaming | #484',
+      authors: [{name: 'Dan Houser'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=o3gbXDjNWyI"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  DECIPHERING_SECRETS_OF_ANCIENT_CIVILIZATIONS_NOAHS_ARK_AND_FLOOD_MYTHS_487: <Content>{
+    reference: {
+      title: 'Deciphering Secrets of Ancient Civilizations, Noah\'s Ark, and Flood Myths | #487',
+      authors: [{name: 'Irving Finkel'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=_bBRVNkAfkQ&pp=0gcJCYcKAYcqIYzv"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PAVEL_DUROV_TELEGRAM_FREEDOM_CENSORSHIP_MONEY_POWER_HUMAN_NATURE_482: <Content>{
+    reference: {
+      title: 'Pavel Durov: Telegram, Freedom, Censorship, Money, Power & Human Nature | #482',
+      authors: [{name: 'Pavel Durov'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=qjPH9njnaVU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  DAVID_KIRTLEY_NUCLEAR_FUSION_PLASMA_PHYSICS_AND_THE_FUTURE_OF_ENERGY_485: <Content>{
+    reference: {
+      title: 'David Kirtley: Nuclear Fusion, Plasma Physics, and the Future of Energy | #485',
+      authors: [{name: 'David Kirtley'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=m_CFCyc2Shs"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  INFINITY_PARADOXES_GÖDEL_INCOMPLETENESS_THE_MATHEMATICAL_MULTIVERSE_488: <Content>{
+    reference: {
+      title: 'Infinity, Paradoxes, Gödel Incompleteness & the Mathematical Multiverse | #488',
+      authors: [{name: 'Joel David Hamkins'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=14OPT6CcsH4"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PAUL_ROSOLIE_UNCONTACTED_TRIBES_IN_THE_AMAZON_JUNGLE_489: <Content>{
+    reference: {
+      title: 'Paul Rosolie: Uncontacted Tribes in the Amazon Jungle | #489',
+      authors: [{name: 'Paul Rosolie'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2026)',
+      link: "https://www.youtube.com/watch?v=Z-FRe5AKmCU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _26_WILL_KINNEY___BEFORE_THE_BIG_BANG_INFLATION_INFINITY_OF_WORLDS: <Content>{
+    reference: {
+      title: '#26 Will Kinney - Before the Big Bang, Inflation, Infinity of Worlds',
+      authors: [{name: 'Will Kinney'}, {name: 'David Kipping'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.cool_worlds_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=HSZtn0yKPBI"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _27_JASON_STEFFEN___KEPLER_MISSION_LEGACY_PARTICLE_PHYSICS_OPTIMAL_PLANE_BOARDING: <Content>{
+    reference: {
+      title: '#27 Jason Steffen - Kepler Mission Legacy, Particle Physics, Optimal Plane Boarding',
+      authors: [{name: 'Jason Steffen'}, {name: 'David Kipping'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.cool_worlds_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=vaqgPzT8PXA"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _28_NÉSTOR_ESPINOZA___JWST_EXOPLANET_ATMOSPHERES_MOLECULE_DETECTION: <Content>{
+    reference: {
+      title: '#28 Néstor Espinoza - JWST, Exoplanet Atmospheres, Molecule Detection',
+      authors: [{name: 'Néstor Espinoza'}, {name: 'David Kipping'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.cool_worlds_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=bZ7Hge0OUTE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CRAFTING_INTERPRETERS: <Content>{
+    reference: {
+      title: 'Crafting Interpreters',
+      authors: [{name: 'Robert Nystrom'}],
+      organizations: [],
+      year: '(2021)',
+      link: "https://www.craftinginterpreters.com/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  FUNCTIONAL_PROGRAMMING_IN_LEAN: <Content>{
+    reference: {
+      title: 'Functional Programming in Lean',
+      authors: [{name: 'David Thrane Christiansen'}],
+      organizations: [],
+      year: '(2023)',
+      link: "https://lean-lang.org/functional_programming_in_lean/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  REFLECTIONS_ON_EQUALITY: <Content>{
+    reference: {
+      title: 'Reflections on Equality',
+      authors: [{name: 'Amélia Liao'}],
+      organizations: [],
+      year: '(2020)',
+      link: "https://amelia.how/posts/reflections-on-equality.html"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CUBICAL_TYPE_THEORY: <Content>{
+    reference: {
+      title: 'Cubical Type Theory',
+      authors: [{name: 'Amélia Liao'}],
+      organizations: [],
+      year: '(2021)',
+      link: "https://amelia.how/posts/cubical-type-theory.html"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ABSTRACT_INTERPRETATION_IN_A_NUTSHELL: <Content>{
+    reference: {
+      title: 'Abstract Interpretation in a Nutshell',
+      authors: [{name: 'Patrick Cousot'}],
+      organizations: [],
+      year: '(2005)',
+      link: "https://www.di.ens.fr/~cousot/AI/IntroAbsInt.html"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ABSTRACT_INTERPRETATION_A_UNIFIED_LATTICE_MODEL_FOR_STATIC_ANALYSIS_OF_PROGRAMS_BY_CONSTRUCTION_OR_APPROXIMATION_OF_FIXPOINTS: <Content>{
+    reference: {
+      title: 'Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints',
+      authors: [{name: 'Patrick Cousot'}, {name: 'Radhia Cousot'}],
+      organizations: [],
+      year: '(1977)',
+      link: "https://dl.acm.org/doi/pdf/10.1145/512950.512973"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  LEVIATHAN_WAKES: <Content>{
+    reference: {
+      title: 'Leviathan Wakes',
+      authors: [{name: 'James S. A. Corey'}],
+      organizations: [],
+      year: '(2011)',
+      link: "https://en.wikipedia.org/wiki/Leviathan_Wakes"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  CUBICAL_TYPES_FOR_THE_WORKING_FORMALIZER: <Content>{
+    reference: {
+      title: '"Cubical types for the working formalizer"',
+      authors: [{name: 'Amélia Liao'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.topos_institute],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=rhZAkHDo-r4&t=1s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  EASY_ABSTRACT_INTERPRETATION_WITH_SPARTA: <Content>{
+    reference: {
+      title: '"Easy Abstract Interpretation with SPARTA"',
+      authors: [{name: 'Arnaud Venet'}, {name: 'Jez Ng'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '(2019)',
+      link: "https://www.youtube.com/watch?v=_fA7vkVJhF8&t=2s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  A_LITTLE_TASTE_OF_DEPENDENT_TYPES: <Content>{
+    reference: {
+      title: 'A Little Taste of Dependent Types',
+      authors: [{name: 'David Thrane Christiansen'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '(2018)',
+      link: "https://www.youtube.com/watch?v=VxINoKFm-S4&ab_channel=StrangeLoopConference"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _24___MODERN_COSMOLOGY_HUBBLE_TENSION_EXOTIC_PHYSICS: <Content>{
+    reference: {
+      title: '#24 - Modern Cosmology, Hubble Tension, Exotic Physics',
+      authors: [{name: 'Colin Hill'}, {name: 'David Kipping'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.cool_worlds_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=FkC-kVC2IRA"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _25___PBS_SPACETIME_SCIENCE_ON_YOUTUBE_QUASARS: <Content>{
+    reference: {
+      title: '#25 - PBS Spacetime, Science on YouTube, Quasars',
+      authors: [{name: 'Matt O\'Dowd'}, {name: 'David Kipping'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.cool_worlds_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=V7QjrsadlKQ&t=5327s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  DAVE_PLUMMER_PROGRAMMING_AUTISM_AND_OLD_SCHOOL_MICROSOFT_STORIES_479: <Content>{
+    reference: {
+      title: 'Dave Plummer: Programming, Autism, and Old-School Microsoft Stories | #479',
+      authors: [{name: 'Dave Plummer'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=HsLgZzgpz9Y"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  DAVE_HONE_T_REX_DINOSAURS_EXTINCTION_EVOLUTION_AND_JURASSIC_PARK_480: <Content>{
+    reference: {
+      title: 'Dave Hone: T-Rex, Dinosaurs, Extinction, Evolution, and Jurassic Park | #480',
+      authors: [{name: 'Dave Hone'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=-Qm1_On71Oo"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  TIM_SWEENEY_FORTNITE_UNREAL_ENGINE_AND_THE_FUTURE_OF_GAMING_467: <Content>{
+    reference: {
+      title: 'Tim Sweeney: Fortnite, Unreal Engine, and the Future of Gaming | #467',
+      authors: [{name: 'Tim Sweeney'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=477qF6QNSvc&t=14990s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  QUANTUM_THEORY_AS_A_NEW_KIND_OF_STOCHASTIC_PROCESS: <Content>{
+    reference: {
+      title: 'Quantum Theory as a New Kind of Stochastic Process',
+      authors: [{name: 'Jacob Barandes'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=JsmX3YxiUj0&t=4288s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  KEYNOTE_HIGHER_INDUCTIVE_TYPES_IN_HOMOTOPY_TYPE_THEORY: <Content>{
+    reference: {
+      title: 'Keynote: Higher Inductive Types in Homotopy Type Theory',
+      authors: [{name: 'Kristina Sojakova'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2019)',
+      link: "https://www.youtube.com/watch?v=AMJIsEBS-zk"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_VERSE_PROGRAMMING_LANGUAGE_GDC_2023: <Content>{
+    reference: {
+      title: 'The Verse Programming Language | GDC 2023',
+      authors: [{name: 'Tim Sweeney'}, {name: 'Phil Pizlo'}, {name: 'Tim TIllotson'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2023)',
+      link: "https://www.youtube.com/watch?v=5prkKOIilJg&t=1517s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+
+  READY_PLAYER_ONE: <Content>{
+    reference: {
+      title: 'Ready Player One',
+      authors: [{name: 'Ernest Cline'}],
+      organizations: [],
+      year: '(2011)',
+      link: "https://en.wikipedia.org/wiki/Ready_Player_One"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  READY_PLAYER_TWO: <Content>{
+    reference: {
+      title: 'Ready Player Two',
+      authors: [{name: 'Ernest Cline'}],
+      organizations: [],
+      year: '(2020)',
+      link: "https://en.wikipedia.org/wiki/Ready_Player_Two"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  MSP_101_GENERALISATION_IN_LLMS_PETAR_VELIČKOVIĆ: <Content>{
+    reference: {
+      title: 'MSP 101: Generalisation in LLMs (Petar Veličković)',
+      authors: [{name: 'Petar Veličković'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=7Z144Ymohd0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  SUNDAR_PICHAI_CEO_OF_GOOGLE_AND_ALPHABET_471: <Content>{
+    reference: {
+      title: 'Sundar Pichai: CEO of Google and Alphabet | #471',
+      authors: [{name: 'Sundar Pichai'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=9V6tWC4CdFQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  TERENCE_TAO_HARDEST_PROBLEMS_IN_MATHEMATICS_PHYSICS_THE_FUTURE_OF_AI_472: <Content>{
+    reference: {
+      title: 'Terence Tao: Hardest Problems in Mathematics, Physics & the Future of AI | #472',
+      authors: [{name: 'Terence Tao'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=HUkBz-cdB-k"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  DHH_FUTURE_OF_PROGRAMMING_AI_RUBY_ON_RAILS_PRODUCTIVITY_PARENTING_474: <Content>{
+    reference: {
+      title: 'DHH: Future of Programming, AI, Ruby on Rails, Productivity & Parenting | #474',
+      authors: [{name: 'David Heinemeier Hansson'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=vagyIcmIGOQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  DEMIS_HASSABIS_FUTURE_OF_AI_SIMULATING_REALITY_PHYSICS_AND_VIDEO_GAMES_475: <Content>{
+    reference: {
+      title: 'Demis Hassabis: Future of AI, Simulating Reality, Physics and Video Games | #475',
+      authors: [{name: 'Demis Hassabis'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=-HzgcbRXUK8&t=8677s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_323_JACOB_BARANDES_ON_INDIVISIBLE_STOCHASTIC_QUANTUM_MECHANICS: <Content>{
+    reference: {
+      title: 'Mindscape 323 | Jacob Barandes on Indivisible Stochastic Quantum Mechanics',
+      authors: [{name: 'Jacob Barandes'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=gINYis8BgSY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _23___FINE_TUNING_MULTIVERSE_COSMOLOGICAL_TENSIONS: <Content>{
+    reference: {
+      title: '#23 - Fine-Tuning, Multiverse, Cosmological Tensions',
+      authors: [{name: 'Geraint Lewis'}, {name: 'David Kipping'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.cool_worlds_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=OejwZqh-F9U&t=29s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  STRING_DIAGRAM_REWRITE_THEORY_III_CONFLUENCE_WITH_AND_WITHOUT_FROBENIUS: <Content>{
+    reference: {
+      title: 'String diagram rewrite theory III: Confluence with and without Frobenius',
+      authors: [{name: 'Filippo Bonchi'}, {name: 'Fabio Gadducci'}, {name: 'Aleks Kissinger'}, {name: 'Pawel Sobocinski'}, {name: 'Fabio Zanasi'}],
+      organizations: [],
+      year: '(2022)',
+      link: "https://arxiv.org/abs/2109.06049"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  INFLUENCE_OF_TEMPORAL_INFORMATION_GAPS_ON_DECISION_MAKING_DESCRIBING_THE_DYNAMICS_OF_WORKING_MEMORY: <Content>{
+    reference: {
+      title: 'Influence of temporal information gaps on decision making: describing the dynamics of working memory',
+      authors: [{name: 'Alejandro Sospedra'}, {name: 'Santiago Canals'}, {name: 'Encarni Marcos'}],
+      organizations: [],
+      year: '(2024)',
+      link: "https://www.biorxiv.org/content/10.1101/2024.07.17.603868v1"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  BLACK_HOLES_WORMHOLES_ALIENS_PARADOXES_EXTRA_DIMENSIONS_468: <Content>{
+    reference: {
+      title: 'Black Holes, Wormholes, Aliens, Paradoxes & Extra Dimensions | #468',
+      authors: [{name: 'Janna Levin'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=A6m4iJIw_84"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _19___INFLATION_B_MODES_AND_LOSING_THE_NOBEL_PRIZE: <Content>{
+    reference: {
+      title: '#19 - Inflation, B Modes and Losing the Nobel Prize',
+      authors: [{name: 'Brian Keating'}, {name: 'David Kipping'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.cool_worlds_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=L5MDDTFbpfU&t=3s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _20___KEPLER_MISSION_EXOPLANETS_WITH_JWST_FUTURE_IMAGERS: <Content>{
+    reference: {
+      title: '#20 - Kepler Mission, Exoplanets with JWST, Future Imagers',
+      authors: [{name: 'Natalie Batalha'}, {name: 'David Kipping'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.cool_worlds_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=BCWd7NuTIcY&t=4s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _21___EARLY_MARS_TERRAFORMINGSETTLING_MARS: <Content>{
+    reference: {
+      title: '#21 - Early Mars, Terraforming/Settling Mars',
+      authors: [{name: 'Edwin Kite'}, {name: 'David Kipping'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.cool_worlds_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=-DaeWdIaMZE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _22___ORIGIN_OF_LIFE_ASSEMBLY_THEORY_BIOSIGNATURES: <Content>{
+    reference: {
+      title: '#22 - Origin of Life, Assembly Theory, Biosignatures',
+      authors: [{name: 'Sara Walker'}, {name: 'David Kipping'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.cool_worlds_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=W2duMnWYhDY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  RULES_THAT_REALITY_PLAYS_BY___343: <Content>{
+    reference: {
+      title: 'Rules that Reality Plays By - #343',
+      authors: [{name: 'Stephen Wolfram'}, {name: 'Anastasia Bendebury'}, {name: 'Michael Shilo DeLay'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.demystifysci],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=aQCT_kboi8A"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MISTAKING_THE_MAP_FOR_THE_TERRITORY_IN_PHYSICS___344: <Content>{
+    reference: {
+      title: 'Mistaking the Map for the Territory in Physics - #344',
+      authors: [{name: 'Jacob Barandes'}, {name: 'Anastasia Bendebury'}, {name: 'Michael Shilo DeLay'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.demystifysci],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=9068pS75Uds&t=2s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+
+  THE_EQUIVALENCE_BETWEEN_GEOMETRICAL_STRUCTURES_AND_ENTROPY: <Content>{
+    reference: {
+      title: 'The equivalence between geometrical structures and entropy',
+      authors: [{name: 'Gabriele Carcassi'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=lp0RgZ6kQF8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  DEEPSEEK_CHINA_OPENAI_NVIDIA_XAI_TSMC_STARGATE_AND_AI_MEGACLUSTERS_459: <Content>{
+    reference: {
+      title: 'DeepSeek, China, OpenAI, NVIDIA, xAI, TSMC, Stargate, and AI Megaclusters | #459',
+      authors: [{name: 'Dylan Patel'}, {name: 'Nathan Lambert'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=_1f-o0nqpEI"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WHY_PHYSICS_WITHOUT_PHILOSOPHY_IS_DEEPLY_BROKEN_PART_2: <Content>{
+    reference: {
+      title: 'Why Physics Without Philosophy Is Deeply Broken... [Part 2]',
+      authors: [{name: 'Jacob Barandes'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=YaS1usLeXQM"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  HARVARD_SCIENTIST_THERE_IS_NO_QUANTUM_MULTIVERSE_PART_3: <Content>{
+    reference: {
+      title: 'Harvard Scientist: "There is No Quantum Multiverse" [Part 3]',
+      authors: [{name: 'Jacob Barandes'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=wrUvtqr4wOs"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  HARVARD_PHYSICIST_DEBUNKS_PARTICLE_SUPERPOSITION: <Content>{
+    reference: {
+      title: 'Harvard Physicist Debunks Particle Superposition',
+      authors: [{name: 'Jacob Barandes'}, {name: 'Manolis Kellis'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=MTD8xkbiGis&t=11s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  TOP_AI_SCIENTIST_UNIFIES_WOLFRAM_LEIBNIZ_CONSCIOUSNESS: <Content>{
+    reference: {
+      title: 'Top AI Scientist Unifies Wolfram, Leibniz, & Consciousness',
+      authors: [{name: 'William Hahn'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=3fkg0uTA3qU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_THEORY_THAT_EXPLAINS_YOU_FREE_ENERGY_PRINCIPLE: <Content>{
+    reference: {
+      title: 'The Theory That Explains YOU... (Free Energy Principle)',
+      authors: [{name: 'Michael Levin'}, {name: 'Karl Friston'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=0yOV9Pzk2zw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  EINSTEIN_HIS_LIFE_AND_UNIVERSE: <Content>{
+    reference: {
+      title: 'Einstein: His Life and Universe',
+      authors: [{name: 'Walter Isaacson'}],
+      organizations: [],
+      year: '(2007)',
+      link: "https://en.wikipedia.org/wiki/Einstein:_His_Life_and_Universe"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  THE_FUTURE_OF_BRAIN_EMULATION_IS_LOOKING_SPIKY: <Content>{
+    reference: {
+      title: 'The future of brain emulation is looking spiky',
+      authors: [{name: 'Andy McKenzie'}],
+      organizations: [],
+      year: '(2025)',
+      link: "https://neurobiology.substack.com/p/the-future-of-brain-emulation-is"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WHY_THE_GODFATHER_OF_AI_NOW_FEARS_HIS_OWN_CREATION: <Content>{
+    reference: {
+      title: 'Why The "Godfather of AI" Now Fears His Own Creation',
+      authors: [{name: 'Geoffrey Hinton'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=b_DUft-BdIE&ab_channel=CurtJaimungal"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_MAJOR_FLAWS_IN_FUNDAMENTAL_PHYSICS: <Content>{
+    reference: {
+      title: 'The Major Flaws in Fundamental Physics',
+      authors: [{name: 'Sabine Hossenfelder'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=E3y-Z0pgupg&ab_channel=CurtJaimungal"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_CRISIS_IN_STRING_THEORY_IS_WORSE_THAN_YOU_THINK: <Content>{
+    reference: {
+      title: 'The Crisis in String Theory is Worse Than You Think',
+      authors: [{name: 'Leonard Susskind'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=2p_Hlm6aCok&ab_channel=CurtJaimungal"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MATH_HAS_CHANGED_FOREVER: <Content>{
+    reference: {
+      title: 'Math Has Changed Forever…',
+      authors: [{name: 'Yang-Hui He'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2025)',
+      link: "https://www.youtube.com/watch?v=wbP0KjWm0pw&ab_channel=CurtJaimungal"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+
+  APPLIED_CATEGORY_THEORY_IN_CHEMISTRY_COMPUTING_AND_SOCIAL_NETWORKS: <Content>{
+    reference: {
+      title: 'Applied Category Theory in Chemistry, Computing, and Social Networks',
+      authors: [{name: 'John Baez'}, {name: 'Simon Cho'}, {name: 'Daniel Cicala'}, {name: 'Nina Otter'}, {name: 'Valeria de Paiva'}],
+      organizations: [],
+      year: '(2022)',
+      link: "https://math.ucr.edu/home/baez/mrc_2022.pdf"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  UNIQUENESS_TREES_A_POSSIBLE_POLYNOMIAL_APPROACH_TO_THE_GRAPH_ISOMORPHISM_PROBLEM: <Content>{
+    reference: {
+      title: 'Uniqueness Trees: A Possible Polynomial Approach to the Graph Isomorphism Problem',
+      authors: [{name: 'Jonathan Gorard'}],
+      organizations: [],
+      year: '(2016)',
+      link: "https://arxiv.org/pdf/1606.06399"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALIEN_CIVILIZATIONS_AND_THE_SEARCH_FOR_EXTRATERRESTRIAL_LIFE_LEX_FRIDMAN_PODCAST_455: <Content>{
+    reference: {
+      title: 'Alien Civilizations and the Search for Extraterrestrial Life | Lex Fridman Podcast #455',
+      authors: [{name: 'Adam Frank'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=yhZAXXI83-4&ab_channel=LexFridman"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THERES_NO_WAVE_FUNCTION: <Content>{
+    reference: {
+      title: 'There’s No Wave Function?',
+      authors: [{name: 'Jacob Barandes'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=7oWip00iXbo&ab_channel=CurtJaimungal"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_POTENTIAL_OF_THE_HUMAN_BRAIN: <Content>{
+    reference: {
+      title: 'The Potential of the Human Brain',
+      authors: [{name: 'Iain McGilchrist'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=Q9sBKCd2HD0&ab_channel=CurtJaimungal"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_UNIVERSE_WRITES_ITSELF_INTO_EXISTENCE_MOMENT_BY_MOMENT: <Content>{
+    reference: {
+      title: 'The Universe Writes Itself Into Existence Moment by Moment',
+      authors: [{name: 'Avshalom Elitzur'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=pWRAaimQT1E&ab_channel=CurtJaimungal"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+
+  HUNTERS_OF_DUNE: <Content>{
+    reference: {
+      title: 'Hunters of Dune',
+      authors: [{name: 'Brian Herbert'}, {name: 'Kevin J. Anderson'}],
+      organizations: [],
+      year: '(2006)',
+      link: "https://en.wikipedia.org/wiki/Hunters_of_Dune"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  THE_LITTLE_BOOK_OF_DEEP_LEARNING: <Content>{
+    reference: {
+      title: 'The Little Book of Deep Learning',
+      authors: [{name: 'François Fleuret'}],
+      organizations: [],
+      year: '(2023)',
+      link: "https://fleuret.org/public/lbdl.pdf"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PREFACE_WHAT_IS_OPENGL: <Content>{
+    reference: {
+      title: 'Preface: What is OpenGL?',
+      authors: [{name: 'Eddy Luten'}],
+      organizations: [],
+      year: '(2014)',
+      link: "https://openglbook.com/chapter-0-preface-what-is-opengl.html#:~:text=On%20the%20most%20fundamental%20level,the%20finer%20details%20of%20OpenGL."
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  FOUNDATIONS_OF_BIDIRECTIONAL_PROGRAMMING_I_WELL_TYPED_SUBSTRUCTURAL_LANGUAGES: <Content>{
+    reference: {
+      title: 'Foundations of Bidirectional Programming I: Well-Typed Substructural Languages',
+      authors: [{name: 'Jules Hedges'}],
+      organizations: [],
+      year: '(2024)',
+      link: "https://cybercat.institute/2024/08/26/bidirectional-programming-i/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  FOUNDATIONS_OF_BIDIRECTIONAL_PROGRAMMING_II_NEGATIVE_TYPES: <Content>{
+    reference: {
+      title: 'Foundations of Bidirectional Programming II: Negative Types',
+      authors: [{name: 'Jules Hedges'}],
+      organizations: [],
+      year: '(2024)',
+      link: "https://cybercat.institute/2024/09/05/bidirectional-programming-ii/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_YOGA_OF_CONTEXTS_I: <Content>{
+    reference: {
+      title: 'The Yoga of Contexts I',
+      authors: [{name: 'Jules Hedges'}],
+      organizations: [],
+      year: '(2024)',
+      link: "https://cybercat.institute/2024/06/28/yoga-contexts/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WHY_DOES_BIOLOGICAL_EVOLUTION_WORK_A_MINIMAL_MODEL_FOR_BIOLOGICAL_EVOLUTION_AND_OTHER_ADAPTIVE_PROCESSES: <Content>{
+    reference: {
+      title: 'Why Does Biological Evolution Work? A Minimal Model for Biological Evolution and Other Adaptive Processes',
+      authors: [{name: 'Stephen Wolfram'}],
+      organizations: [ORGANIZATIONS.wolfram],
+      year: '(2024)',
+      link: "https://writings.stephenwolfram.com/2024/05/why-does-biological-evolution-work-a-minimal-model-for-biological-evolution-and-other-adaptive-processes/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  _20TH_CENTURY_S_GREATEST_LIVING_SCIENTIST_SIR_ROGER_PENROSE: <Content>{
+    reference: {
+      title: '20th Century’s Greatest Living Scientist | Sir Roger Penrose',
+      authors: [{name: 'Roger Penrose'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=sGm505TFMbU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_QUANTUM_HERETIC_A_NEW_THEORY_OF_EVERYTHING: <Content>{
+    reference: {
+      title: 'The Quantum Heretic: A New Theory of Everything?',
+      authors: [{name: 'Jonathan Oppenheim'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=6Z_p3viqW1g"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MAYA_AZTEC_INCA_AND_LOST_CIVILIZATIONS_OF_SOUTH_AMERICA_LEX_FRIDMAN_PODCAST_446: <Content>{
+    reference: {
+      title: 'Maya, Aztec, Inca, and Lost Civilizations of South America | Lex Fridman Podcast #446',
+      authors: [{name: 'Ed Barnhart'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=AzzE7GOvYz8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_ROMAN_EMPIRE___RISE_AND_FALL_OF_ANCIENT_ROME_LEX_FRIDMAN_PODCAST_443: <Content>{
+    reference: {
+      title: 'The Roman Empire - Rise and Fall of Ancient Rome | Lex Fridman Podcast #443',
+      authors: [{name: 'Gregory Aldrete'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=DyoVVSggPjY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_289_THE_NEXT_GENERATION_OF_PARTICLE_EXPERIMENTS: <Content>{
+    reference: {
+      title: 'Mindscape 289 | The Next Generation of Particle Experiments',
+      authors: [{name: 'Cari Cesarotti'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=ELe3fvuTsdE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_291_THE_BIOLOGY_OF_DEATH_AND_AGING: <Content>{
+    reference: {
+      title: 'Mindscape 291 | The Biology of Death and Aging',
+      authors: [{name: 'Venki Ramakrishnan'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=aNqwamgxNiU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MATHS_OF_QUANTUM_MECHANICS: <Content>{
+    reference: {
+      title: 'Maths of Quantum Mechanics',
+      authors: [{name: 'Brandon Sandoval'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2023)',
+      link: "https://www.youtube.com/watch?v=3nvbBEzfmE8&list=PL8ER5-vAoiHAWm1UcZsiauUGPlJChgNXC"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+
+  COMPUTING_MACHINERY_AND_INTELLIGENCE: <Content>{
+    reference: {
+      title: 'Computing Machinery and Intelligence',
+      authors: [{name: 'Alan M. Turing'}],
+      organizations: [],
+      year: '(1950)',
+      link: "https://academic.oup.com/mind/article/LIX/236/433/986238?url=http://szyxflb.com&login=false"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  VON_NEUMANN_AND_LATTICE_THEORY: <Content>{
+    reference: {
+      title: 'Von Neumann and Lattice Theory',
+      authors: [{name: 'Garrett Birkhoff'}],
+      organizations: [],
+      year: '(1958)',
+      link: "https://projecteuclid.org/journals/bulletin-of-the-american-mathematical-society/volume-64/issue-3.P2/Von-Neumann-and-lattice-theory/bams/1183522370.pdf"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WHEN_EXACTLY_WILL_THE_ECLIPSE_HAPPEN_A_MULTIMILLENNIUM_TALE_OF_COMPUTATION: <Content>{
+    reference: {
+      title: 'When Exactly Will the Eclipse Happen? A Multimillennium Tale of Computation',
+      authors: [{name: 'Stephen Wolfram'}],
+      organizations: [ORGANIZATIONS.wolfram],
+      year: '(2024)',
+      link: "https://writings.stephenwolfram.com/2024/03/when-exactly-will-the-eclipse-happen-a-multimillennium-tale-of-computation/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ARE_ALL_FISH_THE_SAME_SHAPE_IF_YOU_STRETCH_THEM_THE_VICTORIAN_TALE_OF_ON_GROWTH_AND_FORM: <Content>{
+    reference: {
+      title: 'Are All Fish the Same Shape if You Stretch Them? The Victorian Tale of On Growth and Form',
+      authors: [{name: 'Stephen Wolfram'}],
+      organizations: [ORGANIZATIONS.wolfram],
+      year: '(2017)',
+      link: "https://writings.stephenwolfram.com/2017/10/are-all-fish-the-same-shape-if-you-stretch-them-the-victorian-tale-of-on-growth-and-form/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WHATS_REALLY_GOING_ON_IN_MACHINE_LEARNING_SOME_MINIMAL_MODELS: <Content>{
+    reference: {
+      title: 'What’s Really Going On in Machine Learning? Some Minimal Models',
+      authors: [{name: 'Stephen Wolfram'}],
+      organizations: [ORGANIZATIONS.wolfram],
+      year: '(2024)',
+      link: "https://writings.stephenwolfram.com/2024/08/whats-really-going-on-in-machine-learning-some-minimal-models/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_HYDROGEN_ATOM_INTRO_TO_QUANTUM: <Content>{
+    reference: {
+      title: 'The Hydrogen Atom: Intro to Quantum Physics',
+      authors: [{name: 'Richard Behiel'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=-Y0XL-K0jy0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_287_INSTITUTIONS_AND_THE_LEGACY_OF: <Content>{
+    reference: {
+      title: 'Mindscape 287 | Institutions and the Legacy of History',
+      authors: [{name: 'Jean-Paul Faguet'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=FKVmYeU11y0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  LIVE_SCIENCE_SPINAL_GRAPHS_HYPERGRAPH_CONFLUENCE_SYMMETRY_AND: <Content>{
+    reference: {
+      title: 'Live Science | Spinal Graphs | Hypergraph Confluence, Symmetry and Efficiency',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=uZkqNDIOQLs"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  LIVE_SCIENCE_INFRAGEOMETRY_CORRESPONDENCES_DIFFERENTIAL_GEOMETRY_HYPERGRAPH: <Content>{
+    reference: {
+      title: 'Live Science | Infrageometry: Correspondences | Differential Geometry, Hypergraph Rewriting',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=Mr1zfZtoFX0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  LIVE_SCIENCE_QUANTUM_PARADOXES_DELAYED_CHOICE_QUANTUM_ERASER_CHSH_GAME: <Content>{
+    reference: {
+      title: 'Live Science | Quantum Paradoxes | Delayed Choice Quantum Eraser, CHSH Game, Quasiprobabilities',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=rTKSWObWtNE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CONSCIOUSNESS_BIOLOGY_UNIVERSAL_MIND_EMERGENCE_CANCER: <Content>{
+    reference: {
+      title: 'Consciousness, Biology, Universal Mind, Emergence, Cancer Research',
+      authors: [{name: 'Michael Levin'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=c8iFtaltX-s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_CRISIS_IN_FUNDAMENTAL_PHYSICS_IS_WORSE_THAN_YOU: <Content>{
+    reference: {
+      title: 'The Crisis in (Fundamental) Physics is Worse Than You Think...',
+      authors: [{name: 'Sean Carroll'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=9AoRxtYZrZo"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  NEURALINK_AND_THE_FUTURE_OF_HUMANITY_LEX_FRIDMAN_PODCAST: <Content>{
+    reference: {
+      title: 'Neuralink and the Future of Humanity | Lex Fridman Podcast #438',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=Kbk9BiPhm7o"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PHYSICS_OF_LIFE_TIME_COMPLEXITY_AND_ALIENS_LEX_FRIDMAN_PODCAST: <Content>{
+    reference: {
+      title: 'Physics of Life, Time, Complexity, and Aliens | Lex Fridman Podcast #433',
+      authors: [{name: 'Sara Walker'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=wwhTfyX9J34"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PLURALISTIC_THE_DISENSHITTIFIED_INTERNET_STARTS_WITH_LOYAL_USER_AGENTS: <Content>{
+    reference: {
+      title: 'Pluralistic: The disenshittified internet starts with loyal "user agents"',
+      authors: [{name: 'Cory Doctorow'}],
+      organizations: [],
+      year: '(2024)',
+      link: "https://pluralistic.net/2024/05/07/treacherous-computing/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ELON_MUSK: <Content>{
+    reference: {
+      title: 'Elon Musk',
+      authors: [{name: 'Walter Isaacson'}],
+      organizations: [],
+      year: '(2023)',
+      link: "https://en.wikipedia.org/wiki/Elon_Musk_(Isaacson_book)"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  FUN_RAISING_FUNDING_SCHOOL_QA_SEMF: <Content>{
+    reference: {
+      title: 'Fun Raising | Funding & School Q&A + SEMF Social',
+      authors: [{name: 'Fadi Shawki'}, {name: 'Álvaro Moreno Vallori'}, {name: 'Alejandro Sospedra Orellano'}, {name: 'Elena Isasi Theus'}, {name: 'Anmol Agrawal'}, {name: 'Carlos Zapata Carratalá'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.semf],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=FL8zNDbrAR0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  HUMAN_MEMORY_IMAGINATION_DEJA_VU_AND_FALSE_MEMORIES_LEX_FRIDMAN_PODCAST: <Content>{
+    reference: {
+      title: 'Human Memory, Imagination, Deja Vu, and False Memories | Lex Fridman Podcast #430',
+      authors: [{name: 'Charan Ranganath'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=4iuepdI3wCU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  JUNGLE_APEX_PREDATORS_ALIENS_UNCONTACTED_TRIBES_AND_GOD_LEX_FRIDMAN_PODCAST: <Content>{
+    reference: {
+      title: 'Jungle, Apex Predators, Aliens, Uncontacted Tribes, and God | Lex Fridman Podcast #429',
+      authors: [{name: 'Paul Rosolie'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=pwN8u6HFH8U"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  LONGEVITY_MEDITATION_PHILOSOPHIES_CONSCIOUSNESS_NATURE_OF: <Content>{
+    reference: {
+      title: 'Longevity, Meditation, Philosophies, Consciousness, Nature of Reality',
+      authors: [{name: 'Bryan Johnson'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=PXkhhHPUud4"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+
+  REVERSE_ENGINEERING_SAME_THING_WE_DO_EVERY_WEEKEND_DOCUMENTING_THE_AMD_7900XTX_PART2: <Content>{
+    reference: {
+      title: 'Reverse engineering | same thing we do every weekend documenting the AMD 7900XTX Part2',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=Z04xTlLdZnc"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  RESEARCHING_DOCUMENTING_THE_AMD_7900XTX_SO_WE_CAN_UNDERSTAND_WHY_IT_CRASHES_RDNA_3: <Content>{
+    reference: {
+      title: 'Researching | documenting the AMD 7900XTX so we can understand why it crashes | RDNA 3',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=Y-0yZ1AHb0s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WHAT_MAKES_HIGH_DIMENSIONAL_NETWORKS_PRODUCE_LOW_DIM_ACTIVITY: <Content>{
+    reference: {
+      title: 'What makes high-dimensional networks produce low-dim. activity?',
+      authors: [{name: 'Eric Shea-Brown'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2019)',
+      link: "https://www.youtube.com/watch?v=toeX2mGWDbI"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  LISA_RANDALL_DARK_MATTER_THEORETICAL_PHYSICS_AND_EXTINCTION_EVENTS_LEX_FRIDMAN_PODCAST_403: <Content>{
+    reference: {
+      title: 'Lisa Randall: Dark Matter, Theoretical Physics, and Extinction Events | Lex Fridman Podcast #403',
+      authors: [{name: 'Lisa Randall'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2023)',
+      link: "https://www.youtube.com/watch?v=VPaOy3G1-2A"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  REALITY_IS_A_PARADOX___MATHEMATICS_PHYSICS_TRUTH_LOVE_LEX_FRIDMAN_PODCAST_370: <Content>{
+    reference: {
+      title: 'Reality is a Paradox - Mathematics, Physics, Truth & Love | Lex Fridman Podcast #370',
+      authors: [{name: 'Edward Frenkel'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '(2023)',
+      link: "https://www.youtube.com/watch?v=Osh0-J3T2nY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_LANGLANDS_PROGRAM___NUMBERPHILE: <Content>{
+    reference: {
+      title: 'The Langlands Program - Numberphile',
+      authors: [{name: 'Edward Frenkel'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2023)',
+      link: "https://www.youtube.com/watch?v=4dyytPboqvE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  TIME_AND_QUANTUM_MECHANICS_SOLVED_LEE_SMOLIN: <Content>{
+    reference: {
+      title: 'Time and Quantum Mechanics SOLVED? | Lee Smolin',
+      authors: [{name: 'Lee Smolin'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=uOKOodQXjhc"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  EDWARD_FRENKEL_INFINITY_AI_STRING_THEORY_DEATH_THE_SELF: <Content>{
+    reference: {
+      title: 'Edward Frenkel: Infinity, Ai, String Theory, Death, The Self',
+      authors: [{name: 'Edward Frenkel'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2023)',
+      link: "https://www.youtube.com/watch?v=n_oPMcvHbAc"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  LIVE_SCIENCE_INFRAGEOMETRY_CORE_DEFINITIONS_DIFFERENTIAL_GEOMETRY_TANGENT_BUNDLES_FUNCTIONS: <Content>{
+    reference: {
+      title: 'Live Science | Infrageometry: Core Definitions | Differential Geometry, Tangent Bundles, Functions',
+      authors: [{name: 'Nikolay Murzin'}, {name: 'Carlos Zapata-Carratalá'}, {name: 'James Wiles'}, {name: 'Utkarsh Bajaj'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=QxtG4tr6VY0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  LIVE_SCIENCE_INFRAGEOMETRY_WORKING_SESSION_FUNCTIONS_EDGES_PLACES_BIPARTITE_GRAPHS: <Content>{
+    reference: {
+      title: 'Live Science | Infrageometry: Working Session | Functions, Edges-Places, Bipartite Graphs',
+      authors: [{name: 'Nikolay Murzin'}, {name: 'Carlos Zapata-Carratalá'}, {name: 'James Wiles'}, {name: 'Utkarsh Bajaj'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=pdPBzPyJqcE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  FELLOW_FOCUS_RICHARD_ASSAR_METAMETAVERSE_ALIEN_MINDS_MACHINE_LEARNING_CELLULAR_AUTOMATA: <Content>{
+    reference: {
+      title: 'Fellow Focus | Richard Assar | MetaMetaverse, Alien Minds, Machine Learning Cellular Automata',
+      authors: [{name: 'Nikolay Murzin'}, {name: 'Carlos Zapata-Carratalá'}, {name: 'James Wiles'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=xg9pAx4bupk"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  FELLOW_FOCUS_NIK_MURZIN_QUANTUM_FRAMEWORK: <Content>{
+    reference: {
+      title: 'Fellow Focus | Nik Murzin | Quantum Framework',
+      authors: [{name: 'Nikolay Murzin'}, {name: 'Carlos Zapata-Carratalá'}, {name: 'James Wiles'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=eG6d8_2GuCw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  EXPLORE_LEARN_THE_MAP_OF_INSTITUTE_RESEARCH_QUANTUM_PROBABILITIES_MULTICOMPUTATION_CAUSALITY: <Content>{
+    reference: {
+      title: 'Explore & Learn | The Map of Institute Research | Quantum Probabilities, Multicomputation, Causality',
+      authors: [{name: 'Nikolay Murzin'}, {name: 'James Wiles'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=OKHrPZ6tT6M"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  EXPLORE_LEARN_THE_MAP_OF_INSTITUTE_RESEARCH_MULTICOMPUTATION_INFRAGEOMETRY_RULIAD: <Content>{
+    reference: {
+      title: 'Explore & Learn | The Map of Institute Research | Multicomputation, Infrageometry, Ruliad',
+      authors: [{name: 'Carlos Zapata-Carratalá'}, {name: 'James Wiles'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=8F9YL887Bck"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  EXPLORE_LEARN_FUNDAMENTALS_WHATS_HYPE_ABOUT_HYPERGRAPHS_GRAPH_THEORY_HYPERMATRIX_ARITY: <Content>{
+    reference: {
+      title: 'Explore & Learn | Fundamentals: What\'s hype about Hypergraphs? | Graph Theory, Hypermatrix, Arity',
+      authors: [{name: 'Carlos Zapata-Carratalá'}, {name: 'Richard Assar'}, {name: 'James Wiles'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=N3vGEp1uLvk"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_274_GIZEM_GUMUSKAYA_ON_BUILDING_ROBOTS_FROM_HUMAN_CELLS: <Content>{
+    reference: {
+      title: 'Mindscape 274 | Gizem Gumuskaya on Building Robots from Human Cells',
+      authors: [{name: 'Gizem Gumuskaya'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=jwaOzmW3xfs"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  COMMUNITY_LIVESTREAM_DATA_DIMENSIONALITY: <Content>{
+    reference: {
+      title: 'Community Livestream | Data & Dimensionality',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.semf],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=zBV1nLw2WuM"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALL_IN_PODCAST_E173: <Content>{
+    reference: {
+      title: 'All-In Podcast E173',
+      authors: [{name: 'Chamath Palihapitiya'}, {name: 'Jason Calacanis'}, {name: 'David Friedberg'}, {name: 'David O. Sacks'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.all_in],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=z3Zzlgo-xZM"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALL_IN_PODCAST_E174: <Content>{
+    reference: {
+      title: 'All-In Podcast E174',
+      authors: [{name: 'Chamath Palihapitiya'}, {name: 'Jason Calacanis'}, {name: 'David Friedberg'}, {name: 'David O. Sacks'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.all_in],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=hZp80SYIRlY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALL_IN_PODCAST_E175: <Content>{
+    reference: {
+      title: 'All-In Podcast E175',
+      authors: [{name: 'Chamath Palihapitiya'}, {name: 'Jason Calacanis'}, {name: 'David Friedberg'}, {name: 'David O. Sacks'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.all_in],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=HKtlezdPNAI"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALL_IN_PODCAST_E176: <Content>{
+    reference: {
+      title: 'All-In Podcast E176',
+      authors: [{name: 'Chamath Palihapitiya'}, {name: 'Jason Calacanis'}, {name: 'David Friedberg'}, {name: 'David O. Sacks'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.all_in],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=1ZQ33OnGFWE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CALCULUS_RATIOCINATOR_VS_CHARACTERISTICA_UNIVERSALIS_THE_TWO_TRADITIONS_IN_LOGIC_REVISITED: <Content>{
+    reference: {
+      title: 'Calculus Ratiocinator vs. Characteristica Universalis? The Two Traditions in Logic, Revisited',
+      authors: [{name: 'Volker Peckhaus'}],
+      organizations: [],
+      year: '(2004)',
+      link: "https://www.researchgate.net/publication/22838cus`6287_Calculus_Ratiocinator_vs_Characteristica_Universalis_The_two_traditions_in_logic_revisited"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CARGO_CULT_SCIENCE: <Content>{
+    reference: {
+      title: 'Cargo Cult Science',
+      authors: [{name: 'Richard P. Feynman'}],
+      organizations: [],
+      year: '(1974)',
+      link: "https://calteches.library.caltech.edu/51/2/CargoCult.htm"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MILLIONS_OF_CHILDREN_LEARN_ONLY_VERY_LITTLE_HOW_CAN_THE_WORLD_PROVIDE_A_BETTER_EDUCATION_TO_THE_NEXT_GENERATION: <Content>{
+    reference: {
+      title: 'Millions of children learn only very little. How can the world provide a better education to the next generation?',
+      authors: [{name: 'Max Roser'}],
+      organizations: [],
+      year: '(2022)',
+      link: "https://ourworldindata.org/better-learning"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  STRIPES_2023_ANNUAL_LETTER: <Content>{
+    reference: {
+      title: 'Stripe\'s 2023 annual letter',
+      authors: [{name: 'Patrick Collison'}, {name: 'John Collison'}],
+      organizations: [],
+      year: '(2024)',
+      link: "https://stripe.com/en-nl/annual-updates/2023"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PLAYING_VALUING_AND_LIVING_EXAMINING_NIETZSCHES_PLAYFUL_RESPONSE_TO_NIHILISM: <Content>{
+    reference: {
+      title: 'Playing, Valuing, and Living: Examining Nietzsche’s Playful Response to Nihilism',
+      authors: [{name: 'Aaron Harper'}],
+      organizations: [],
+      year: '(2015)',
+      link: "https://philpapers.org/rec/HARPVA-2"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_BUILD_YOUR_OWN_OPEN_GAMES_ENGINE_BOOTCAMP_PART_I_LENSES: <Content>{
+    reference: {
+      title: 'The Build Your Own Open Games Engine Bootcamp — Part I: Lenses',
+      authors: [{name: 'Daniele Palombi'}],
+      organizations: [],
+      year: '(2024)',
+      link: "https://blog.20squares.xyz/open-games-bootcamp-i/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CAN_AI_SOLVE_SCIENCE: <Content>{
+    reference: {
+      title: 'Can AI Solve Science?',
+      authors: [{name: 'Stephen Wolfram'}, {name: 'Richard Assar'}, {name: 'Nik Murzin'}],
+      organizations: [ORGANIZATIONS.wolfram],
+      year: '(2024)',
+      link: "https://writings.stephenwolfram.com/2024/03/can-ai-solve-science/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  COMMUNITY_LIVESTREAM_BIOELECTRICITY: <Content>{
+    reference: {
+      title: 'Community Livestream | Bioelectricity',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.semf],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=XBNh3Yoxei0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  QUANTUM_GRAVITY_WOLFRAM_PHYSICS_PROJECT: <Content>{
+    reference: {
+      title: 'Quantum Gravity & Wolfram Physics Project',
+      authors: [{name: 'Jonathan Gorard'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=ioXwL-c1RXQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PARADIGM_SHIFT_GHOST_PARTICLES_CONSTRUCTOR_THEORY: <Content>{
+    reference: {
+      title: 'Paradigm Shift, Ghost Particles, Constructor Theory',
+      authors: [{name: 'Chiara Marletto'}, {name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=40CB12cj_aM&t=6443s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_STRING_THEORY_ICEBERG_EXPLAINED: <Content>{
+    reference: {
+      title: 'The String Theory Iceberg EXPLAINED',
+      authors: [{name: 'Curt Jaimungal'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.toe],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=X4PdPnQuwjY&t=9496s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  EXPLORING_SNIFFING_NVIDIAS_IOCTLS_OPEN_GPU_KERNEL_MODULES_DEBUG_PTX_CUDA: <Content>{
+    reference: {
+      title: 'Exploring | sniffing NVIDIA\'s ioctls | open-gpu-kernel-modules | DEBUG | PTX | CUDA',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=rUsx1b7rQ8Q&t=9910s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PROGRAMMING_WRITING_A_FUZZER_AND_NOT_GETTING_TRIGGERED_WHEN_THE_AMD_GPU_CRASHES_UMR: <Content>{
+    reference: {
+      title: 'Programming | writing a fuzzer and not getting triggered when the AMD GPU crashes UMR',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=BCnTXwhzzxA&t=9780s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PROGRAMMING_RIPPING_OUT_ALL_OF_AMDS_USERSPACE_AMDGPU_IOCTLS_GPU_MEMORY_HSA_KFD: <Content>{
+    reference: {
+      title: 'Programming | ripping out all of AMD\'s userspace, AMDGPU ioctls | GPU memory | HSA KFD',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=-iH5wvFnsKs"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALL_IN_PODCAST_E169: <Content>{
+    reference: {
+      title: 'All-In Podcast E169',
+      authors: [{name: 'Chamath Palihapitiya'}, {name: 'Jason Calacanis'}, {name: 'David Friedberg'}, {name: 'David O. Sacks'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.all_in],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=snbTCWL6rxo"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALL_IN_PODCAST_E170: <Content>{
+    reference: {
+      title: 'All-In Podcast E170',
+      authors: [{name: 'Chamath Palihapitiya'}, {name: 'Jason Calacanis'}, {name: 'David Friedberg'}, {name: 'David O. Sacks'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.all_in],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=uMajFsCkzxY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALL_IN_PODCAST_E171: <Content>{
+    reference: {
+      title: 'All-In Podcast E171',
+      authors: [{name: 'Chamath Palihapitiya'}, {name: 'Jason Calacanis'}, {name: 'David Friedberg'}, {name: 'David O. Sacks'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.all_in],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=3tEcLAud7Nc"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALL_IN_PODCAST_E172: <Content>{
+    reference: {
+      title: 'All-In Podcast E172',
+      authors: [{name: 'Chamath Palihapitiya'}, {name: 'Jason Calacanis'}, {name: 'David Friedberg'}, {name: 'David O. Sacks'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.all_in],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=4t4YkHSTZbw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  SHANNON_LUMINARY_LECTURE_SERIES___STEPHEN_FRY: <Content>{
+    reference: {
+      title: 'Shannon Luminary Lecture Series - Stephen Fry',
+      authors: [{name: 'Stephen Fry'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2017)',
+      link: "https://www.youtube.com/watch?v=24F6C1KfbjM"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CONTAINERS_FOR_COMPILER_ARCHITECTURE: <Content>{
+    reference: {
+      title: 'Containers for compiler architecture',
+      authors: [{name: 'Andre Videla'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=BnzAxT-O0Y8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WHY_IT_WAS_ALMOST_IMPOSSIBLE_TO_MAKE_THE_BLUE_LED: <Content>{
+    reference: {
+      title: 'Why It Was Almost Impossible to Make the Blue LED',
+      authors: [{name: '@Veritasium'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=AF8d72mA41M"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  COMPOSITIONAL_GAME_THEORY_TOWARDS_INCENTIVES_MODELLING_AT_SCALE: <Content>{
+    reference: {
+      title: 'Compositional Game Theory – Towards Incentives Modelling at Scale',
+      authors: [{name: 'Jules Hedges'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=2b4hxOP7g9I"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_268_MATT_STRASSLER_ON_RELATIVITY_FIELDS_AND_THE_LANGUAGE_OF_REALITY: <Content>{
+    reference: {
+      title: 'Mindscape 268 | Matt Strassler on Relativity, Fields, and the Language of Reality',
+      authors: [{name: 'Matt Strassler'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=kCpELmx425w"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ACTINF_MATHSTREAM_0091_JONATHAN_GORARD_A_COMPUTATIONAL_PERSPECTIVE_ON_OBSERVATION_AND_COGNITION: <Content>{
+    reference: {
+      title: 'ActInf MathStream 009.1 ~ Jonathan Gorard: A computational perspective on observation and cognition',
+      authors: [{name: 'Jonathan Gorard'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.active_inference_institute],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=I3rhsT-8isk"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  A_CONVERSATION_WITH_MARK_ZUCKERBERG_PATRICK_COLLISON_AND_TYLER_COWEN: <Content>{
+    reference: {
+      title: 'A Conversation with Mark Zuckerberg, Patrick Collison and Tyler Cowen',
+      authors: [{name: 'Mark Zuckerberg'}, {name: 'Patrick Collison'}, {name: 'Tyler Cowen'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2019)',
+      link: "https://about.fb.com/news/2019/11/a-conversation-with-mark-zuckerberg-patrick-collison-and-tyler-cowen/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  SOLVING_SAT_VIA_POSITIVE_SUPERCOMPILATION: <Content>{
+    reference: {
+      title: 'Solving SAT via Positive Supercompilation',
+      authors: [{name: 'Tima Kinsart (Hirrolot)'}],
+      organizations: [],
+      year: '(2024)',
+      link: "https://hirrolot.github.io/posts/sat-supercompilation.html) ; *Tima Kinsart (Hirrolot"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  NAVIGATING_COGNITION_SPATIAL_CODES_FOR_HUMAN_THINKING: <Content>{
+    reference: {
+      title: 'Navigating cognition: Spatial codes for human thinking',
+      authors: [{name: 'Jacob L. S. Bellmund'}, {name: 'Peter Gärdenfors'}, {name: 'Edvard I. Moser'}, {name: 'Christian F. Doeller'}],
+      organizations: [],
+      year: '(2018)',
+      link: "https://www.science.org/doi/10.1126/science.aat6766"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  TOWARDS_A_STRUCTURAL_TURN_IN_CONSCIOUSNESS_SCIENCE: <Content>{
+    reference: {
+      title: 'Towards a structural turn in consciousness science',
+      authors: [{name: 'Johannes Kleiner'}],
+      organizations: [],
+      year: '(2024)',
+      link: "https://pubmed.ncbi.nlm.nih.gov/38422757/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_GLASS_BEAD_GAME: <Content>{
+    reference: {
+      title: 'The Glass Bead Game',
+      authors: [{name: 'Ralph Freedman'}],
+      organizations: [],
+      year: '(1970)',
+      link: "https://www.nytimes.com/1970/01/04/archives/the-glass-bead-game-glass-bead.html"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  AN_INTRODUCTION_TO_HIGHER_ARITY_SCIENCE: <Content>{
+    reference: {
+      title: 'An Introduction to Higher Arity Science',
+      authors: [{name: 'Carlos Zapata-Carratalá'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2021)',
+      link: "https://www.youtube.com/watch?v=62UFbGsj5Jg"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  HISTORY_OF_SCIENCE_AND_TECHNOLOGY_QA_FEBRUARY_28: <Content>{
+    reference: {
+      title: 'History of Science and Technology Q&A (February 28,',
+      authors: [{name: 'Stephen Wolfram'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2024)',
+      link: "https://www.youtube.com/watch?v=kNXXksujIHM"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  GRETA_SEMINAR_HIGHER_ARITY_ALGEBRA_VIA_HYPERGRAPH_REWRITING: <Content>{
+    reference: {
+      title: 'GReTA seminar: Higher-Arity Algebra via Hypergraph Rewriting',
+      authors: [{name: 'Carlos Zapata-Carratalá'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=ZBjagJvNEn8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WORKSHOP_AXIOMATIC_CREATION: <Content>{
+    reference: {
+      title: 'Workshop | Axiomatic Creation',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.semf],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=StNfdknDQ9c"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  COMMUNITY_LIVESTREAM_AXIOMS_CREATIVITY: <Content>{
+    reference: {
+      title: 'Community Livestream | Axioms & Creativity',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.semf],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=9ddJAJaYk_E"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CONCEPT_COLLIDER_GEOMETRY_OF_DATA_AND_NEURAL_CORRELATES: <Content>{
+    reference: {
+      title: 'Concept Collider | Geometry of Data and Neural Correlates',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.semf],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=mROz1U4VkGY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WOLFRAM_PHYSICS_PROJECT_WORKING_SESSION___CAUSAL_MULTIWAY_SYSTEMS: <Content>{
+    reference: {
+      title: 'Wolfram Physics Project: Working Session - Causal Multiway Systems',
+      authors: [{name: 'Stephen Wolfram'}, {name: 'Jonathan Gorard'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram],
+      year: '(2020)',
+      link: "https://www.youtube.com/watch?v=OXSE6KhRUF4"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  SCIENCE_RESEARCH_SESSION_HYPORULIAD: <Content>{
+    reference: {
+      title: 'Science Research Session: Hyporuliad',
+      authors: [{name: 'Stephen Wolfram'}, {name: 'Jonathan Gorard'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram],
+      year: '(2023)',
+      link: "https://www.youtube.com/watch?v=lZaBjuHk7Ms"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  A_CONVERSATION_BETWEEN_BOB_COECKE_AND_STEPHEN_WOLFRAM: <Content>{
+    reference: {
+      title: 'A conversation between Bob Coecke and Stephen Wolfram',
+      authors: [{name: 'Bob Coecke'}, {name: 'Stephen Wolfram'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram],
+      year: '(2021)',
+      link: "https://www.youtube.com/watch?v=8CUTXaGqvSQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  STEVE_JOBS: <Content>{
+    reference: {
+      title: 'Steve Jobs',
+      authors: [{name: 'Walter Isaacson'}],
+      organizations: [],
+      year: '(2011)',
+      link: "https://en.wikipedia.org/wiki/Steve_Jobs_(book)"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December", type: 'book'
+  },
+  JOHN_CLEESE_ON_CREATIVITY_IN_MANAGEMENT: <Content>{
+    reference: {
+      title: 'John Cleese on Creativity In Management',
+      authors: [{name: 'John Cleese'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2017)',
+      link: "https://www.youtube.com/watch?v=Pb5oIIPO62g"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_TRILLION_DOLLAR_EQUATION: <Content>{
+    reference: {
+      title: 'The Trillion Dollar Equation',
+      authors: [{name: '@Veritasium'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(Veritasium)',
+      link: "https://www.youtube.com/watch?v=A5w-dEgIU1M"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  STEVE_JOBS_PRESIDENT_CEO_NEXT_COMPUTER_CORP_AND_APPLE_MIT_SLOAN_DISTINGUISHED_SPEAKER_SERIES: <Content>{
+    reference: {
+      title: 'Steve Jobs President & CEO, NeXT Computer Corp and Apple. MIT Sloan Distinguished Speaker Series',
+      authors: [{name: 'Steve Jobs'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(1992)',
+      link: "https://www.youtube.com/watch?v=Gk-9Fd2mEnI"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CARL_SAGAN_AT_MIT___MANAGEMENT_IN_THE_YEAR_2000_SLOAN_SCHOOL_SYMPOSIUM: <Content>{
+    reference: {
+      title: 'Carl Sagan at MIT - Management in the Year 2000: Sloan School Symposium',
+      authors: [{name: 'Carl Sagan'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(1987)',
+      link: "https://www.youtube.com/watch?v=gLOZsTMuars"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CHAMATH_PALIHAPITIYA_SOCIALCAPITAL_STARTUP_GRIND: <Content>{
+    reference: {
+      title: 'Chamath Palihapitiya (SocialCapital) @ Startup Grind',
+      authors: [{name: 'Chamath Palihapitiya'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2015)',
+      link: "https://www.youtube.com/watch?v=ncjum-bkW98"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CHAMATH_PALIHAPITIYA_SPEAKING_AT_WATERLOO_INNOVATION_SUMMIT: <Content>{
+    reference: {
+      title: 'Chamath Palihapitiya speaking at Waterloo Innovation Summit',
+      authors: [{name: 'Chamath Palihapitiya'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '(2016)',
+      link: "https://www.youtube.com/watch?v=D82_ppT2iic"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALL_IN_PODCAST_E165: <Content>{
+    reference: {
+      title: 'All-In Podcast E165',
+      authors: [{name: 'Chamath Palihapitiya'}, {name: 'Jason Calacanis'}, {name: 'David Friedberg'}, {name: 'David O. Sacks'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.all_in],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=FHO4hoXc75k"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ALL_IN_PODCAST_E164: <Content>{
+    reference: {
+      title: 'All-In Podcast E164',
+      authors: [{name: 'Chamath Palihapitiya'}, {name: 'Jason Calacanis'}, {name: 'David Friedberg'}, {name: 'David O. Sacks'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.all_in],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=bUuEE2jmP2c"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CONCEPT_COLLIDER_MATHEMATICAL_PHYSICS_ACTIVE_INFERENCE_FREE_ENERGY_ENTROPY: <Content>{
+    reference: {
+      title: 'Concept Collider | Mathematical Physics + Active Inference, Free Energy & Entropy',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.semf],
+      year: '(2024)',
+      link: "https://www.youtube.com/watch?v=GwbLOCCI2yE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CRDTS_GO_BRRR: <Content>{
+    reference: {
+      title: 'CRDTs go brrr',
+      authors: [{name: 'Seph Gentle'}],
+      organizations: [],
+      year: '2021',
+      link: "https://josephg.com/blog/crdts-go-brrr/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THIS_WEEKS_FINDS_18_CATEGORIFYING_THE_QUANTUM_HARMONIC_OSCILLATOR: <Content>{
+    reference: {
+      title: 'This Week\'s Finds 18: categorifying the quantum harmonic oscillator',
+      authors: [{name: 'John Baez'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=pvVm3L92pdc"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WOLFRAM_PHYSICS_PROJECT_WORKING_SESSION_QUANTUM_BLACK_HOLES_AND_OTHER_THINGS: <Content>{
+    reference: {
+      title: 'Wolfram Physics Project Working Session: Quantum Black Holes and Other Things',
+      authors: [{name: 'Stephen Wolfram'}, {name: 'Jonathan Gorard'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=fFEVq76_Pu0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CAUSAL_INVARIANCE_VERSUS_CONFLUENCE: <Content>{
+    reference: {
+      title: 'Causal invariance versus confluence',
+      authors: [{name: 'Jonathan Gorard'}, {name: 'Mark Jeffery'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=LYFzm_xSWXw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CRDTS_THE_HARD_PARTS: <Content>{
+    reference: {
+      title: 'CRDTs: The Hard Parts',
+      authors: [{name: 'Martin Kleppmann'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2020',
+      link: "https://www.youtube.com/watch?v=x7drE24geUw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  RIAK_DYNAMO_FIVE_YEARS_LATER_PRESENTED: <Content>{
+    reference: {
+      title: 'Riak & Dynamo, Five Years Later Presented',
+      authors: [{name: 'Andy Gross'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2013',
+      link: "https://www.youtube.com/watch?v=AxG9DROsnqg"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  RIAK_CORE___AN_ERLANG_DISTRIBUTED_SYSTEMS_TOOLKIT: <Content>{
+    reference: {
+      title: 'Riak Core - An Erlang Distributed Systems Toolkit',
+      authors: [{name: 'Andy Gross'}],
+      organizations: [],
+      year: '2011',
+      link: "https://vimeo.com/21772889"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ZXLIVE___AN_INTERACTIVE_GUI_FOR_THE_ZX_CALCULUS___RAZIN_A_SHAIKH: <Content>{
+    reference: {
+      title: 'ZXLive - An Interactive GUI for the ZX Calculus - Razin A. Shaikh',
+      authors: [{name: 'Razin A. Shaikh'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.zx_calculus],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=J--c2q-KOc8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  GRAPHICAL_CSS_CODE_TRANSFORMATION_USING_ZX_CALCULUS: <Content>{
+    reference: {
+      title: 'Graphical CSS Code Transformation Using ZX Calculus',
+      authors: [{name: 'Jiaxin Huang'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.zx_calculus],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=ZhfQxdjodNs"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_ZETA_CALCULUS: <Content>{
+    reference: {
+      title: 'The Zeta Calculus',
+      authors: [{name: 'Nicklas Botö'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.zx_calculus],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=iUHEy3PZCso"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  HOW_TO_TAKE_THE_FACTORIAL_OF_ANY_NUMBER: <Content>{
+    reference: {
+      title: 'How to Take the Factorial of Any Number',
+      authors: [{name: '@Lines That Connect'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2022',
+      link: "https://www.youtube.com/watch?v=v_HeaeUUOnc"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  JEFF_BEZOS_AMAZON_AND_BLUE_ORIGIN_LEX_FRIDMAN_PODCAST_405: <Content>{
+    reference: {
+      title: 'Jeff Bezos: Amazon and Blue Origin | Lex Fridman Podcast #405',
+      authors: [{name: 'Jeff Bezos'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=DcWqzZ3I2cY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  HR_TALK_INTRO_TO_LARGE_LANGUAGE_MODELS: <Content>{
+    reference: {
+      title: '[1hr Talk] Intro to Large Language Models',
+      authors: [{name: 'Andrej Karpathy'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=zjkBMFhNj_g"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  STREAM_0_WHY_ALL_VIDEO_GAME_PROGRAMMERS_SHOULD_LEARN_GEOMETRIC_ALGEBRA: <Content>{
+    reference: {
+      title: 'Stream #0: Why all video game programmers should learn geometric algebra',
+      authors: [{name: 'Hamish Todd'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=pHKOdxgr5lE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  THE_PERIODIC_TABLE_OF_GEOMETRIC_ALGEBRAS___CL301_DOES_ALL_3D_GAME_MATH_SO_WHAT_DOES_CLPQR_D: <Content>{
+    reference: {
+      title: 'The Periodic Table of Geometric Algebras - CL(3,0,1) does all 3D game math, so what does CL(p,q,r) d',
+      authors: [{name: 'Hamish Todd'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=oXcp3gA8erQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  GEOMETRIC_ALGEBRA_AS_A_TOOL_IN_TECHNICAL_COMMUNICATION: <Content>{
+    reference: {
+      title: 'Geometric Algebra as a tool in technical communication',
+      authors: [{name: 'Hamish Todd'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2020',
+      link: "https://www.youtube.com/watch?v=hR-MQm3c13Q"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_260_RICARD_SOLE_ON_THE_SPACE_OF_COGNITIONS: <Content>{
+    reference: {
+      title: 'Mindscape 260 | Ricard Solé on the Space of Cognitions',
+      authors: [{name: 'Ricard Solé'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=lJltHIlUHvQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_261_SANJANA_CURTIS_ON_THE_ORIGINS_OF_THE_ELEMENTS: <Content>{
+    reference: {
+      title: 'Mindscape 261 | Sanjana Curtis on the Origins of the Elements',
+      authors: [{name: 'Sanjana Curtis'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=V28YdLuYnjk"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_264_SABINE_STANLEY_ON_WHATS_INSIDE_PLANETS: <Content>{
+    reference: {
+      title: 'Mindscape 264 | Sabine Stanley on What\'s Inside Planets',
+      authors: [{name: 'Sabine Stanley'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=myU8GNdpPjU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_263_CHRIS_QUIGG_ON_SYMMETRY_AND_THE_BIRTH_OF_THE_STANDARD_MODEL: <Content>{
+    reference: {
+      title: 'Mindscape 263 | Chris Quigg on Symmetry and the Birth of the Standard Model',
+      authors: [{name: 'Chris Quigg'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=-q-HBIBiTQ0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_262_ERIC_SCHWITZGEBEL_ON_THE_WEIRDNESS_OF_THE_WORLD: <Content>{
+    reference: {
+      title: 'Mindscape 262 | Eric Schwitzgebel on the Weirdness of the World',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mindscape],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=V0evRaWV_HU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  JUST_CHATTING_TECHNO_OPTIMISM_WINNING_OVER_NATURE_PROGRESSIVE_ACCELERATION: <Content>{
+    reference: {
+      title: 'Just Chatting | techno optimism | Winning over nature | Progressive | Acceleration',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=WS5wGal3ukw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PROGRAMMING_DECISION_TRANSFORMER_REINFORCEMENT_LEARNING_RL_LUNARLANDER_PART_1: <Content>{
+    reference: {
+      title: 'Programming | Decision Transformer Reinforcement Learning (RL) | LunarLander | Part 1',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=8U8kK3SpLTU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PROGRAMMING_RL_IS_DUMB_AND_DOESNT_WORK_REINFORCEMENT_LEARNING_LUNARLANDER_PART_2: <Content>{
+    reference: {
+      title: 'Programming | RL is dumb and doesn\'t work | Reinforcement Learning LunarLander Part 2',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=-tZkb0vgaDk"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  RESEARCHING_RL_IS_DUMB_AND_DOESNT_WORK_THEORY_REINFORCEMENT_LEARNING_PART_3: <Content>{
+    reference: {
+      title: 'Researching | RL is dumb and doesn\'t work (theory) | Reinforcement Learning | Part 3',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=Ul5-NKOP8RQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  RESEARCHING_MULTIGPU_WITH_HIP_OR_MAYBE_WITHOUT_HIP_HSA_HIP_GRAPH_PART_1: <Content>{
+    reference: {
+      title: 'Researching | multiGPU with HIP (or maybe without HIP) | HSA | HIP Graph | Part 1',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=X4J_GUhp9jI"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PROGRAMMING_MULTIGPU_WITH_HIP_OR_MAYBE_WITHOUT_HIP_HSA_DISABLE_CACHE1_PART_2: <Content>{
+    reference: {
+      title: 'Programming | multiGPU with HIP (or maybe without HIP) | HSA_DISABLE_CACHE=1 | Part 2',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2024',
+      link: "https://www.youtube.com/watch?v=kh2z9J_gXWg"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  STRING_DIAGRAM_REWRITE_THEORY_II_REWRITING_WITH_SYMMETRIC_MONOIDAL_STRUCTURE: <Content>{
+    reference: {
+      title: 'String Diagram Rewrite Theory II: Rewriting with Symmetric Monoidal Structure',
+      authors: [{name: 'Filippo Bonchi'}, {name: 'Fabio Gadducci'}, {name: 'Aleks Kissinger'}, {name: 'Pawel Sobocinski'}, {name: 'Fabio Zanasi'}],
+      organizations: [],
+      year: '2022',
+      link: "https://arxiv.org/abs/2104.14686"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CHYP_COMPOSING_HYPERGRAPHS_PROVING_THEOREMS: <Content>{
+    reference: {
+      title: 'Chyp: Composing Hypergraphs, Proving Theorems',
+      authors: [{name: 'Aleks Kissinger'}],
+      organizations: [],
+      year: '2023',
+      link: "https://act2023.github.io/papers/paper25.pdf"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  OBSERVER_THEORY: <Content>{
+    reference: {
+      title: 'Observer Theory',
+      authors: [{name: 'Stephen Wolfram'}],
+      organizations: [],
+      year: '2023',
+      link: "https://writings.stephenwolfram.com/2023/12/observer-theory/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WASM_SPECTEC_ENGINEERING_A_FORMAL_LANGUAGE_STANDARD: <Content>{
+    reference: {
+      title: 'Wasm SpecTec: Engineering a Formal Language Standard',
+      authors: [{name: 'Joachim Breitner'}, {name: 'Philippa Gardner'}, {name: 'Jaehyun Lee'}, {name: 'Sam Lindley'}, {name: 'Matija Pretnar'}, {name: 'Xiaojia Rao'}, {name: 'Andreas Rossberg'}, {name: 'Sukyoung Ryu'}, {name: 'Wonho Shin'}, {name: 'Conrad Watt'}, {name: 'Dongjun Youn'}],
+      organizations: [ORGANIZATIONS.wasm],
+      year: '2023',
+      link: "https://arxiv.org/pdf/2311.07223.pdf"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  MINDSCAPE_259_ADAM_FRANK_ON_WHAT_ALIENS_MIGHT_BE_LIKE: <Content>{
+    reference: {
+      title: 'Mindscape 259 | Adam Frank on What Aliens Might Be Like',
+      authors: [{name: 'Adam Frank'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.preposterous_universe],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=UzmlA3g2nRE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  ANIMATION_VS_PHYSICS: <Content>{
+    reference: {
+      title: 'Animation vs. Physics',
+      authors: [{name: 'Alan Becker + Team'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=ErMSHiQRnc8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  WHY_LIGHT_CAN_SLOW_DOWN_AND_WHY_IT_DEPENDS_ON_COLOR_OPTICS_PUZZLES: <Content>{
+    reference: {
+      title: 'Why light can “slow down”, and why it depends on color | Optics puzzles',
+      authors: [{name: '3Blue1Brown'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=KTzGBJPuJwM"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  LEE_CRONIN_CONTROVERSIAL_NATURE_PAPER_ON_EVOLUTION_OF_LIFE_AND_UNIVERSE_LEX_FRIDMAN_PODCAST_404: <Content>{
+    reference: {
+      title: 'Lee Cronin: Controversial Nature Paper on Evolution of Life and Universe | Lex Fridman Podcast #404',
+      authors: [{name: 'Lee Cronin'}, {name: 'Lex Fridman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.lex_fridman_podcast],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=CGiDqhSdLHk"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  BERKELEY_SEMINAR_DAVID_JAZ_MYERS_872023: <Content>{
+    reference: {
+      title: 'Berkeley Seminar: David Jaz Myers, 8/7/2023',
+      authors: [{name: 'David Jaz Myers'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.topos_institute],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=WvniD62U_W4"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  YUGOSLAVIAS_DIGITAL_TWIN: <Content>{
+    reference: {
+      title: 'Yugoslavia’s Digital Twin',
+      authors: [{name: 'Kaloyan Kolev'}],
+      organizations: [],
+      year: '2023',
+      link: "https://www.thedial.world/issue-9/yugolsav-wars-yu-domain-history-icann"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PHYSICS_EXPLAINS_WHY_THERE_IS_NO_INFORMATION_ON_SOCIAL_MEDIA: <Content>{
+    reference: {
+      title: 'Physics explains why there is no information on social media',
+      authors: [{name: 'Tiernan Ray'}],
+      organizations: [],
+      year: '2021',
+      link: "https://www.zdnet.com/article/physics-explains-why-there-is-no-information-on-social-media/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  HOW_TO_ASK_QUESTIONS_THE_SMART_WAY: <Content>{
+    reference: {
+      title: 'How To Ask Questions The Smart Way',
+      authors: [{name: 'Eric S. Raymond'}, {name: 'Rick Moen'}],
+      organizations: [],
+      year: '2001-2014',
+      link: "http://www.catb.org/~esr/faqs/smart-questions.html"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  COMPLEXITY_MATHEMATICS_COMMUNITY_LIVESTREAM: <Content>{
+    reference: {
+      title: 'Complexity & Mathematics | Community Livestream',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.semf],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=MWQ7XFjkOhs"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  HOLIDAY_SPECIAL_LIVESTREAM: <Content>{
+    reference: {
+      title: 'Holiday Special Livestream',
+      authors: [{name: ''}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.semf],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=m_rATW4Nrqk"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  JUST_CHATTING_TESLA_AI_DAY_2022_SCIENCE_TECHNOLOGY: <Content>{
+    reference: {
+      title: 'Just Chatting | Tesla AI Day 2022 | Science & Technology',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2022',
+      link: "https://www.youtube.com/watch?v=lSXwIzww6Us"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PROGRAMMING_MISTRAL_MIXTRAL_ON_A_TINYBOX_AMD_P2P_MULTI_GPU_MIXTRAL_8X7B_32KSEQLEN: <Content>{
+    reference: {
+      title: 'Programming | Mistral mixtral on a tinybox | AMD P2P multi-GPU mixtral-8x7b-32kseqlen',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=H40QRJFzThQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PROGRAMMING_WHAT_IS_THE_Q_ALGORITHM_OPENAI_Q_STAR_ALGORITHM_MISTRAL_7B_PRM800K: <Content>{
+    reference: {
+      title: 'Programming | what is the Q* algorithm? OpenAI Q Star Algorithm | Mistral 7B | PRM800K',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=2QO3vzwHXhg"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  JUST_CHATTING_EFFECTIVE_ACCELERATIONISM_EACC_TECHNO_PESSIMISM_DECELERATION: <Content>{
+    reference: {
+      title: 'Just Chatting | effective accelerationism | e/acc | Techno-pessimism | Deceleration',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=YrWEDOQQ8pw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  SCIENCE_THERMODYNAMICS_IS_TO_ENERGY_AS_IS_TO_INTELLIGENCE: <Content>{
+    reference: {
+      title: 'Science | Thermodynamics is to Energy as ??? is to Intelligence',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=vn9Dq24RDn8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  SCIENCE_THERMODYNAMICS_IS_TO_ENERGY_AS_ENTROPICS_IS_TO_INTELLIGENCE_PART_2: <Content>{
+    reference: {
+      title: 'Science | Thermodynamics is to Energy as Entropics is to Intelligence | Part 2',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=mEoiQ_PZNTE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PROGRAMMING_A_TINY_TOUR_THROUGH_TINYGRAD_NOOB_LESSON: <Content>{
+    reference: {
+      title: 'Programming | a tiny tour through tinygrad (noob lesson)',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=-MhwhiReY-s"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  PROGRAMMING_TINYGRAD_WRITING_TUTORIALS_FOR_NOOBS: <Content>{
+    reference: {
+      title: 'Programming | tinygrad: writing tutorials for noobs',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=Sk35MKtCXfQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  RANT_COMPLAINING_ABOUT_HOW_TERRIBLE_QUALCOMM_IS_THE_BUSINESS_WORLD: <Content>{
+    reference: {
+      title: 'Rant | Complaining about how terrible Qualcomm is | The business world',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=rzb2cuT9vaY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  CHATTING_CHALLENGES_HIRING_PEOPLE_VISION_BUILDING_A_COMPANY_TINY_CORP_TINYGRADORG: <Content>{
+    reference: {
+      title: 'Chatting | challenges hiring people, vision, building a company tiny corp tinygrad.org',
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=4_6eY-8dibI"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+  READING_TALKING_LETS_READ_ML_PAPERS: <Content>{
+    reference: {
+      title: `Reading & Talking | let's read ML papers`,
+      authors: [{name: 'George Hotz'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.tinycorp],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=YrWEDOQQ8pw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, December"
+  },
+
+  STRING_DIAGRAM_REWRITE_THEORY_I: <Content>{
+    reference: {
+      title: 'String Diagram Rewrite Theory I: Rewriting with Frobenius Structure',
+      authors: [{name: 'Filippo Bonchi'}, {name: 'Fabio Gadducci'}, {name: 'Aleks Kissinger'}, {name: 'Pawel Sobocinski'}, {name: 'Fabio Zanasi'},],
+      year: '2023',
+      link: "https://arxiv.org/abs/2012.01847"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  REPTAR: <Content>{
+    reference: {
+      title: 'Reptar',
+      authors: [{name: 'Tavis Ormandy'}],
+      year: '2023',
+      link: "https://lock.cmpxchg8b.com/reptar.html"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  AGGREGATION_AND_TILING_AS_MULTICOMPUTATIONAL_PROCESSES: <Content>{
+    reference: {
+      title: 'Aggregation and Tiling as Multicomputational Processes',
+      authors: [{name: 'Stephen Wolfram'}],
+      year: '2023',
+      link: "https://writings.stephenwolfram.com/2023/11/aggregation-and-tiling-as-multicomputational-processes/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  PHYSICS_AND_ECONOMICS_SEMF_COMMUNITY_LIVESTREAM: <Content>{
+    reference: {
+      title: 'Physics & Economics | SEMF Community Livestream',
+      authors: [],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.semf],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=enR68VVQPtY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  WOLFRAM_INSTITUTES_INFRAGEOMETRY_LIVESTREAMS: <Content>{
+    reference: {
+      title: 'Wolfram Institute\'s Infrageometry Project Livestreams',
+      authors: [{name: 'Jonathan Gorard'}, {name: 'Carlos Zapata-Carratalá'}, {name: 'Nikolay Murzin'}, {name: 'Utkarsh Bajaj'},],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '2023',
+      link: "https://www.youtube.com/playlist?list=PLtbvsohNkWeVO_PMxoZfDEiiY8tuYOjgf"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  HYPERMATRIX_WORKSHOP: <Content>{
+    reference: {
+      title: 'HyperMatrix Workshop',
+      authors: [{name: 'Edinah Koffi Gnang'}, {name: 'Richard Kerner'}, {name: 'Luke Oeding'}, {name: 'Joshua Grochow'}, {name: 'Harm Derksen'}, {name: 'Tali Beynon'}, {name: 'Michel Rausch'}, {name: 'Carlos Zapata-Carratalá'},],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.wolfram_institute],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=E8s9Daqy_2A"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  WOLFRAM_PHYSICS_PROJECT_RELATIONS_TO_CATEGORY_THEORY: <Content>{
+    reference: {
+      title: 'Wolfram Physics Project: Relations to Category Theory',
+      authors: [{name: 'Stephen Wolfram'}, {name: 'Fabrizio Remano Genovese'}, {name: 'Matteo Capucci'}, {name: 'Jonathan Gorard'}, {name: 'Tali Beynon'},],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2020',
+      link: "https://www.youtube.com/watch?v=0LAtNXo9rbE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  ALL_CONCEPTS_ARE_CAT_SHARP: <Content>{
+    reference: {
+      title: 'All Concepts are Cat#',
+      authors: [{name: 'David Spivak'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.topos_institute],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=_1-rueSZMGc"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  HIGHER_CATEGORY_THEORY_IN_CAT_SHARP: <Content>{
+    reference: {
+      title: '(Higher) category theory in Cat^#',
+      authors: [{name: 'Brandon Shapiro'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.topos_institute],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=AKyHHykroWg"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  ABSTRACTION_ENGINEERING_WITH_THE_PVS: <Content>{
+    reference: {
+      title: 'Abstraction Engineering with the Prototype Verification System (PVS)',
+      authors: [{name: 'Nat Shankar'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.topos_institute],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=MHf07noO9KA"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  CAUSAL_VS_ACAUSAL_MODELING_BY_EXAMPLE: <Content>{
+    reference: {
+      title: 'Causal vs Acausal Modeling By Example: Why Julia ModelingToolkit.jl Scales',
+      authors: [{name: 'Chris Rackauckas'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=ZYkojUozeC4"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  RP_159: <Content>{
+    reference: {
+      title: 'Entropic Gravity, Black Holes, and the Holographic Principle | RP#159',
+      authors: [{name: 'Erik Verlinde'}, {name: 'Robinson Erhardt'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=TgQg1Oy37r0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  RP_118: <Content>{
+    reference: {
+      title: 'Quantum Physics, the Multiverse, and Time Travel | RP #118',
+      authors: [{name: 'Slavoj Žižek'}, {name: 'Sean Carroll'}, {name: 'Robinson Erhardt'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=735mYcl3Lrg"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  MINDSCAPE_256: <Content>{
+    reference: {
+      title: 'Mindscape 256 | Kelly & Zach Weinersmith on Building Cities on the Moon and Mars',
+      authors: [{name: 'Kelly & Zach Weinersmith'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.preposterous_universe],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=dJqr_cCi9tM"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  THIS_WEEKS_FINDS_15: <Content>{
+    reference: {
+      title: 'This Week\'s Finds 15: combinatorics, groupoid cardinality and species',
+      authors: [{name: 'John Baez'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=yLtgs7Fz8aw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  THIS_WEEKS_FINDS_14: <Content>{
+    reference: {
+      title: 'This Week\'s Finds 14: the 3-strand braid group',
+      authors: [{name: 'John Baez'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=MnS4hduP5xg"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  SCALES_AND_SCIENCE_FICTION_WITH_BIOLOGIST_MICHAEL_LEVIN: <Content>{
+    reference: {
+      title: 'Scales and Science Fiction with Biologist Michael Levin',
+      authors: [{name: 'Michael Levi'}, {name: 'Andrea Hiott'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=n15xS4YcyG0"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  DELIMITED_CONTINUATIONS_FOR_EVERYONE: <Content>{
+    reference: {
+      title: 'Delimited Continuations for Everyone',
+      authors: [{name: 'Kenichi Asai'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.papers_we_love],
+      year: '2017',
+      link: "https://www.youtube.com/watch?v=QNM-njddhIw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  HOMOTOPY_TYPE_THEORY_101: <Content>{
+    reference: {
+      title: 'Homotopy Type Theory 101',
+      authors: [{name: 'Carlo Angiuli'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=VMqF06fDljU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  FROM_CATEGORICAL_SYSTEMS_THEORY_TO_CATEGORICAL_CYBERNETICS: <Content>{
+    reference: {
+      title: 'From categorical systems theory to categorical cybernetics',
+      authors: [{name: 'Matteo Capucci'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2022',
+      link: "https://www.youtube.com/watch?v=wtgfyjFIHBQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  THE_SEARCH_FOR_THE_PERFECT_DOOR: <Content>{
+    reference: {
+      title: 'The Search for the Perfect Door',
+      authors: [{name: 'Deviant Ollam'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2016',
+      link: "https://www.youtube.com/watch?v=4YYvBLAF4T8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  EVOLVING_BRAINS_SOLID_LIQUID_AND_SYNTHETIC: <Content>{
+    reference: {
+      title: 'Evolving Brains: Solid, Liquid and Synthetic',
+      authors: [{name: 'Ricard Solé'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.santa_fe_institute],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=EIb5-LJbcIM"
+    }, status: Viewed.VIEWED, viewed_at: "2023, November"
+  },
+
+  CRITICAL_THINKING_1: <Content>{
+    reference: {
+      title: 'Critical Thinking - Episode 1: Introductions, Bug Bounty Reports, and BB Tips',
+      authors: [{name: 'Joel Margolis'}, {name: 'Justin Gardner'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.criticalthinkingpodcast.io/episode-1-introductions-bug-bounty-reports-and-bb-tips/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  MINDSCAPE_253: <Content>{
+    reference: {
+      title: 'Mindscape 253 | David Deutsch on Science, Complexity, and Explanation',
+      authors: [{name: 'David Deutsch'}, {name: 'Sean Carroll'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=ldgK7EhEnto"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  PAST_PRESENT_AND_FUTURE_OF_MATHEMATICS: <Content>{
+    reference: {
+      title: 'Past, Present, & Future of Mathematics',
+      authors: [{name: 'Grant Sanderson'}, {name: 'Dwarkesh Patel'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=oDyviiN4NVo"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  GOD_MODE_UNLOCKED_HARDWARE_BACKDOORS_IN_X86_CPUS: <Content>{
+    reference: {
+      title: 'GOD MODE UNLOCKED - Hardware Backdoors in x86 CPUs',
+      authors: [{name: 'Christopher Domas'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2018',
+      link: "https://www.youtube.com/watch?v=_eSAF_qT_FY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  BREAKING_THE_X86_INSTRUCTION_SET: <Content>{
+    reference: {
+      title: 'Breaking the x86 Instruction Set',
+      authors: [{name: 'Christopher Domas'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2017',
+      link: "https://www.youtube.com/watch?v=KrksBdWcZgQ"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  REDUCTIO_AD_ABSURDUM: <Content>{
+    reference: {
+      title: 'reductio ad absurdum',
+      authors: [{name: 'Christopher Domas'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2017',
+      link: "https://www.youtube.com/watch?v=NmWwRmvjAE8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  THE_RING_0_FACADE_AWAKENING_THE_PROCESSORS_INNER_DEMONS: <Content>{
+    reference: {
+      title: 'The Ring 0 Facade Awakening the Processors Inner Demons',
+      authors: [{name: 'Christopher Domas'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2018',
+      link: "https://www.youtube.com/watch?v=XH0F9r0siTI"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  THE_DISCOVER_OF_ZENBLEED: <Content>{
+    reference: {
+      title: 'The Discovery of Zenbleed',
+      authors: [{name: 'Tavis Ormandy'}, {name: ' Fabian Faessler (LiveOverflow)'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=neWc0H1k2Lc"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  HIGHER_ORDER_COMPANY_ORIGINS_OF_THE_HVM: <Content>{
+    reference: {
+      title: 'Higher Order Company - Origins of the HVM',
+      authors: [{name: 'Victor Taelin'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=UQNNs77SpXA"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  MLST_OBSERVERS: <Content>{
+    reference: {
+      title: 'MLST - Observers',
+      authors: [{name: 'Stephen Wolfram'}, {name: 'Karl Friston'}, {name: 'Keith Duggar'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.mlst],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=6iaT-0Dvhnc"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  COMPOSITIONAL_INTELLIGENCE: <Content>{
+    reference: {
+      title: 'Compositional Intelligence',
+      authors: [{name: 'Bob Coecke'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.topos_institute],
+      year: '2022',
+      link: "https://www.youtube.com/watch?v=03ZPDyj8TtM"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  MODERNIZING_COMPILER_DESIGN_FOR_CARBON_TOOLCHAIN: <Content>{
+    reference: {
+      title: 'Modernizing Compiler Design for Carbon Toolchain',
+      authors: [{name: 'Chandler Carruth'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=ZI198eFghJk"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  YASP_EPISODE_2: <Content>{
+    reference: {
+      title: 'Automated Reasoning, SMT Solvers, Artificial Intelligence • YASP #2',
+      authors: [{name: 'Clark Barrett'}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=RVjQkUI0kcw"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  CURSORLESS_A_SPOKEN_LANGUAGE_FOR_EDITING_CODE: <Content>{
+    reference: {
+      title: 'Cursorless: A spoken language for editing code',
+      authors: [{name: 'Pokey Rule'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=NcUJnmBqHTY"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  COMPUTATIONAL_PHSYICS_BEYOND_THE_GLASS: <Content>{
+    reference: {
+      title: 'Computational Physics, Beyond the Glass',
+      authors: [{name: 'Sam Ritchie'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=Jv2JgzAl5yU"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  AN_APPROACH_TO_COMPUTING_AND_SUSTAINABILITY_INSPIRED_FROM_PERMACULTURE: <Content>{
+    reference: {
+      title: 'An approach to computing and sustainability inspired from permaculture',
+      authors: [{name: 'Devine Lu Linvega'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=T3u7bGgVspM"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  THE_ECONOMICS_OF_PROGRAMMING_LANGUAGES: <Content>{
+    reference: {
+      title: 'The Economics of Programming Languages',
+      authors: [{name: 'Evan Czaplicki'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=XZ3w_jec1v8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  WAR_TIME_PROOFS_AND_FUTURISTIC_PROGRAMS: <Content>{
+    reference: {
+      title: 'War Time Proofs and Futuristic Programs',
+      authors: [{name: 'Valeria de Paiva'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=4_6uboxUYR8"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  FROM_GEOMETRY_TO_ALGEBRA_AND_BACK_AGAIN_4000_YEARS_OF_PAPERS: <Content>{
+    reference: {
+      title: 'From Geometry to Algebra and Back Again: 4000 Years of Papers',
+      authors: [{name: 'Jack Rusher'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=1cRFfYQYGxE"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+
+  WE_REALLY_DONT_KNOW_HOW_TO_COMPUTE: <Content>{
+    reference: {
+      title: 'We Really Don\'t Know How to Compute!',
+      authors: [{name: 'Gerald Sussman'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=HB5TrK7A4pI"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+  WHY_PROGRAMMING_LANGUAGES_MATTER: <Content>{
+    reference: {
+      title: 'Why Programming Languages Matter',
+      authors: [{name: 'Andrew Black'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=JqYCt9rTG8g"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+  IPVM_SEAMLESS_SERVICES_FOR_AN_OPEN_WORLD: <Content>{
+    reference: {
+      title: 'IPVM: Seamless Services for an Open World',
+      authors: [{name: 'Brooklyn Zelenka'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop, ORGANIZATIONS.wasm],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=Z5U8JQZXABs"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+  INSIDE_THE_WIZARD_RESEARCH_ENGINE: <Content>{
+    reference: {
+      title: 'Inside the Wizard Research Engine',
+      authors: [{name: 'Ben L. Titzer'}],
+      organizations: [ORGANIZATIONS.youtube, ORGANIZATIONS.strangeloop, ORGANIZATIONS.wasm],
+      year: '2023',
+      link: "https://www.youtube.com/watch?v=43ENxjq2Vhc"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+  CURRY_HOWARD_IS_OVERRATED: <Content>{
+    reference: {
+      title: 'Curry-Howard is overrated',
+      authors: [{name: 'Simon Cruanes'}],
+      year: '2021',
+      link: "https://blag.cedeela.fr/curry-howard-scam/"
+    }, status: Viewed.VIEWED, viewed_at: "2023, October"
+  },
+  DUNE: <Content>{
+    reference: {
+      title: 'Dune',
+      authors: [{name: 'Herbert, Frank'}],
+      published: [{name: 'Ace Books'}],
+      year: '1965',
+      link: "https://en.wikipedia.org/wiki/Dune_(novel)"
+    }, status: Viewed.VIEWED, found_at: "2021", viewed_at: "2021", type: 'book'
+  },
+  DUNE_MESSIAH: <Content>{
+    reference: {
+      title: 'Dune Messiah',
+      authors: [{name: 'Herbert, Frank'}],
+      published: [{name: 'Ace Books'}],
+      year: '1969',
+      link: 'https://en.wikipedia.org/wiki/Dune_Messiah'
+    }, status: Viewed.VIEWED, found_at: "2021", viewed_at: "2021", type: 'book'
+  },
+  CHILDREN_OF_DUNE: <Content>{
+    reference: {
+      title: "Children of Dune",
+      authors: [{name: "Herbert, Frank"}],
+      published: [{name: "Ace Books"}],
+      year: "1976",
+      link: "https://en.wikipedia.org/wiki/Children_of_Dune"
+    }, status: Viewed.VIEWED, found_at: "2021", viewed_at: "2021", type: 'book'
+  },
+  GOD_EMPEROR_OF_DUNE: <Content>{
+    reference: {
+      title: "God Emperor of Dune",
+      authors: [{name: "Herbert, Frank"}],
+      published: [{name: "Ace Books"}],
+      year: "1981",
+      link: "https://en.wikipedia.org/wiki/God_Emperor_of_Dune",
+    }, status: Viewed.VIEWED, found_at: "2021", viewed_at: "2022", type: 'book'
+  },
+  HERETICS_OF_DUNE: <Content>{
+    reference: {
+      title: "Heretics of Dune",
+      authors: [{name: "Herbert, Frank"}],
+      published: [{name: "Ace Books"}],
+      year: "1984",
+      link: "https://en.wikipedia.org/wiki/Heretics_of_Dune"
+    }, status: Viewed.VIEWED, found_at: "2021", viewed_at: "2022", type: 'book'
+  },
+  CHAPTERHOUSE_DUNE: <Content>{
+    reference: {
+      title: "Chapterhouse: Dune",
+      authors: [{name: "Herbert, Frank"}],
+      published: [{name: "Ace Books"}],
+      year: "1985",
+      link: "https://en.wikipedia.org/wiki/Chapterhouse:_Dune"
+    }, status: Viewed.IN_PROGRESS, found_at: "2021", viewed_at: "2022 - ", type: 'book'
+  },
+
+  FLUID_CONCEPTS_AND_CREATIVE_ANALOGIES: <Content>{
+    reference: {
+      title: "Fluid concepts and creative analogies: Computer models of the fundamental mechanisms of thought",
+      authors: [{name: "Hofstadter, Douglas R"}],
+      published: [{name: "Basic books"}],
+      year: "1995",
+      link: "https://en.wikipedia.org/wiki/Fluid_Concepts_and_Creative_Analogies",
+    }, status: Viewed.VIEWED, found_at: "January, 2022", viewed_at: "January, 2022 - May, 2022", type: 'book'
+  },
+
+  GODEL_ESCHER_BACH: <Content>{
+    reference: {
+      title: "Gödel, escher, bach",
+      authors: [{name: "Hofstadter, Douglas R"}],
+      published: [{name: "New York: Basic books"}],
+      year: "1979",
+      link: "https://en.wikipedia.org/wiki/G%C3%B6del,_Escher,_Bach",
+    }, status: Viewed.IN_PROGRESS, found_at: "March, 2022", viewed_at: "March, 2022 - ", type: 'book'
+  },
+
+  QUANTUM_EINSTEIN_BOHR_AND_THE_GREAT_DEBATE_ABOUT_THE_NATURE_OF_REALITY: <Content>{
+    reference: {
+      title: "Quantum: Einstein, Bohr and the great debate about the nature of reality",
+      authors: [{name: "Kumar, Manjit"}],
+      published: [{name: "Icon Books Ltd"}],
+      year: "2008",
+      link: "https://en.wikipedia.org/wiki/Quantum_(book)",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "2022 - October, 2022", type: 'book'
+  },
+
+  THE_ART_OF_WAR: <Content>{
+    reference: {
+      title: "The Art of War / Sun Tzu",
+      authors: [{name: "Cleary, Thomas"}],
+      published: [{name: "Thomas Clearly translation. Shambhala Publications"}],
+      year: "6th cent. B.C.",
+      link: "https://en.wikipedia.org/wiki/Thomas_Cleary",
+    }, status: Viewed.IN_PROGRESS, found_at: "2022", viewed_at: "2022", archived: true, type: 'book'
+  },
+
+  _1984: <Content>{
+    reference: {
+      title: "1984",
+      authors: [{name: "Orwell, George"}],
+      published: [{name: "Secker & Warburg"}],
+      year: "1949",
+      link: "https://en.wikipedia.org/wiki/Nineteen_Eighty-Four",
+    }, status: Viewed.VIEWED, found_at: "2021", viewed_at: "2021", type: 'book'
+  },
+
+  ANIMAL_FARM: <Content>{
+    reference: {
+      title: "Animal Farm",
+      authors: [{name: "Orwell, George"}],
+      published: [{name: "Secker & Warburg"}],
+      year: "1945",
+      link: "https://en.wikipedia.org/wiki/Animal_Farm",
+    }, status: Viewed.IN_PROGRESS, found_at: "2021", viewed_at: "2021", archived: true
+  },
+
+  THE_FUTURE_OF_HUMANITY: <Content>{
+    reference: {
+      title: "The Future of Humanity: Terraforming Mars, Interstellar Travel, Immortality, and Our Destiny Beyond Earth",
+      authors: [{name: "Kaku, Michio"}],
+      published: [{name: "Doubleday"}],
+      year: "2018",
+      link: "https://en.wikipedia.org/wiki/The_Future_of_Humanity",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "November, 2022"
+  },
+
+  FOUNDATION: <Content>{
+    reference: {
+      title: "Foundation",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Gnome Press"}],
+      year: "1951",
+      link: "https://en.wikipedia.org/wiki/Foundation_(Asimov_novel)",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "October, 2022", type: 'book'
+  },
+
+  SECOND_FOUNDATION: <Content>{
+    reference: {
+      title: "Second Foundation",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Gnome Press"}],
+      year: "1953",
+      link: "https://en.wikipedia.org/wiki/Second_Foundation",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "October, 2022 - January, 2023", type: 'book'
+  },
+
+  FOUNDATION_AND_EMPIRE: <Content>{
+    reference: {
+      title: "Foundation and Empire",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Gnome Press"}],
+      year: "1952",
+      link: "https://en.wikipedia.org/wiki/Foundation_and_Empire",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "January, 2023", type: 'book'
+  },
+
+  PRELUDE_TO_FOUNDATION: <Content>{
+    reference: {
+      title: "Prelude to Foundation",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Doubleday"}],
+      year: "1988",
+      link: "https://en.wikipedia.org/wiki/Prelude_to_Foundation",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "April, 2023", type: 'book'
+  },
+
+  FOUNDATIONS_EDGE: <Content>{
+    reference: {
+      title: "Foundation's Edge",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Doubleday"}],
+      year: "1982",
+      link: "https://en.wikipedia.org/wiki/Foundation%27s_Edge",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "March, 2023", type: 'book'
+  },
+
+  FOUNDATION_AND_EARTH: <Content>{
+    reference: {
+      title: "Foundation and Earth",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Doubleday"}],
+      year: "1986",
+      link: "https://en.wikipedia.org/wiki/Foundation_and_Earth",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "March, 2023", type: 'book'
+  },
+
+  FORWARD_THE_FOUNDATION: <Content>{
+    reference: {
+      title: "Forward the Foundation",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Doubleday"}],
+      year: "1993",
+      link: "https://en.wikipedia.org/wiki/Forward_the_Foundation",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "May, 2023", type: 'book'
+  },
+
+  I_ROBOT: <Content>{
+    reference: {
+      title: "I, Robot",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Gnome Press"}],
+      year: "1950",
+      link: "https://en.wikipedia.org/wiki/I,_Robot",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "April, 2023", type: 'book'
+  },
+
+  THE_REST_OF_THE_ROBOTS: <Content>{
+    reference: {
+      title: "The Rest of the Robots",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Doubleday"}],
+      year: "1964",
+      link: "https://en.wikipedia.org/wiki/The_Rest_of_the_Robots",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "May, 2023", type: 'book'
+  },
+
+  THE_COMPLETE_ROBOT: <Content>{
+    reference: {
+      title: "The Complete Robot",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Doubleday"}],
+      year: "1982",
+      link: "https://en.wikipedia.org/wiki/The_Complete_Robot",
+    }, status: Viewed.IN_PROGRESS, found_at: "2022", viewed_at: "June, 2023", type: 'book'
+  },
+
+  THE_CAVES_OF_STEEL: <Content>{
+    reference: {
+      title: "The Caves of Steel",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Doubleday"}],
+      year: "1954",
+      link: "https://en.wikipedia.org/wiki/The_Caves_of_Steel",
+    }, status: Viewed.IN_PROGRESS, found_at: "2022", viewed_at: "August, 2023", type: 'book'
+  },
+
+  THE_NAKED_SUN: <Content>{
+    reference: {
+      title: "The Naked Sun",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Doubleday"}],
+      year: "1957",
+      link: "https://en.wikipedia.org/wiki/The_Naked_Sun",
+    }, status: Viewed.IN_PROGRESS, found_at: "2022", viewed_at: "August, 2023", type: 'book'
+  },
+
+  THE_ROBOTS_OF_DAWN: <Content>{
+    reference: {
+      title: "The Robots of Dawn",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Doubleday"}],
+      year: "1983",
+      link: "https://en.wikipedia.org/wiki/The_Robots_of_Dawn",
+    }, status: Viewed.IN_PROGRESS, found_at: "2022", viewed_at: "September, 2023", type: 'book'
+  },
+
+  ROBOTS_AND_EMPIRE: <Content>{
+    reference: {
+      title: "Robots and Empire",
+      authors: [{name: "Asimov, Isaac"}],
+      published: [{name: "Doubleday"}],
+      year: "1985",
+      link: "https://en.wikipedia.org/wiki/Robots_and_Empire",
+    }, status: Viewed.IN_PROGRESS, found_at: "2022", viewed_at: "October, 2023", type: 'book'
+  },
+
+  THE_RISE_AND_FALL_OF_THE_THIRD_REICH: <Content>{
+    reference: {
+      title: "The Rise and Fall of the Third Reich",
+      authors: [{name: "Shirer, William L"}],
+      published: [{name: "Simon & Schuster"}],
+      year: "1960",
+      link: "https://en.wikipedia.org/wiki/The_Rise_and_Fall_of_the_Third_Reich",
+    }, status: Viewed.IN_PROGRESS, found_at: "July, 2022", viewed_at: "September, 2022 - ", type: 'book'
+  },
+
+  A_NEW_KIND_OF_SCIENCE: <Content>{
+    reference: {
+      title: "A new kind of science?",
+      authors: [{name: "Wolfram, Stephen"}, {name: "M. Gad-el-Hak"}],
+      published: [{name: "Appl. Mech. Rev. 56.2"}],
+      year: "2003",
+      link: "https://www.wolframscience.com/nks/",
+    }, status: Viewed.IN_PROGRESS,
+  },
+
+  A_PROJECT_TO_FIND_THE_FUNDAMENTAL_THEORY_OF_PHYSICS: <Content>{
+    reference: {
+      title: "A Project to Find the Fundamental Theory of Physics",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: "Wolfram Media, Inc."}],
+      year: "2020",
+      link: "https://www.wolframphysics.org/",
+    }, status: Viewed.IN_PROGRESS, found_at: "2022", viewed_at: "December, 2022 - ", type: 'book'
+  },
+
+  COMBINATORS_A_CENTENNIAL_VIEW: <Content>{
+    reference: {
+      title: "Combinators, A Centennial View",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: "Wolfram Media, Inc."}],
+      year: "2021",
+      link: "https://arxiv.org/pdf/2103.12811.pdf",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "December, 2022 - January, 2023", type: 'book'
+  },
+
+  METAMATHEMATICS: <Content>{
+    reference: {
+      title: "Metamathematics: Foundations & Physicalization",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: "Wolfram Media, Inc."}],
+      year: "2022",
+      link: "https://arxiv.org/abs/2204.05123",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "May, 2023", type: 'book'
+  },
+
+  TWENTY_YEARS_NKS: <Content>{
+    reference: {
+      title: "Twenty Years of a New Kind of Science",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: "Wolfram Media, Inc."}],
+      year: "2022",
+      link: "https://www.wolfram-media.com/products/twenty-years-of-a-new-kind-of-science/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "June, 2023", type: 'book'
+  },
+
+  THE_SELFISH_GENE: <Content>{
+    reference: {
+      title: "The Selfish Gene",
+      authors: [{name: "Dawkins, Richard"}],
+      published: [{name: "Oxford University Press"}],
+      year: "1976",
+      link: "https://en.wikipedia.org/wiki/The_Selfish_Gene",
+    }, status: Viewed.IN_PROGRESS, found_at: "2022", viewed_at: "February 2023 - ", type: 'book'
+  },
+
+  TRANSFORMER: <Content>{
+    reference: {
+      title: "Transformer: The Deep Chemistry of Life and Death",
+      authors: [{name: "Lane, Nick"}],
+      published: [{name: "W.W. Norton & Company"}],
+      year: "2022",
+      link: "https://en.wikipedia.org/wiki/Nick_Lane",
+    }, status: Viewed.IN_PROGRESS, found_at: "2022", viewed_at: "May 2023 - "
+  },
+
+  THE_VITAL_QUESTION: <Content>{
+    reference: {
+      title: "The Vital Question: Why Is Life The Way It Is?",
+      authors: [{name: "Lane, Nick"}],
+      published: [{name: "Profile Books"}],
+      year: "2015",
+      link: "https://en.wikipedia.org/wiki/Nick_Lane",
+    }, status: Viewed.IN_PROGRESS, found_at: "2022", viewed_at: "May 2023 - "
+  },
+
+  A_THOUSAND_BRAINS: <Content>{
+    reference: {
+      title: "A Thousand Brains: A New Theory of Intelligence",
+      authors: [{name: "Hawkins, Jeff"}],
+      published: [{name: ""}],
+      year: "2021",
+      link: "https://www.numenta.com/resources/books/a-thousand-brains-by-jeff-hawkins/",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "May 2022", type: 'book'
+  },
+
+  REASONING_WITH_BELIEF_FUNCTIONS: <Content>{
+    reference: {
+      title: "Reasoning with belief functions: An analysis of compatibility",
+      authors: [{name: "Pearl, Judea"}],
+      published: [{name: "International Journal of Approximate Reasoning"}],
+      year: "1990",
+      link: "https://www.sciencedirect.com/science/article/pii/0888613X9090013R/pdf",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "October 2022"
+  },
+
+  CONTEXT_AWARE_COMPUTING_APPLICATIONS: <Content>{
+    reference: {
+      title: "Context-Aware Computing Applications",
+      authors: [{name: "Schilit, Bill, Norman Adams, and Roy Want"}],
+      published: [{name: "first workshop on mobile computing systems and applications. IEEE"}],
+      year: "1994",
+      link: "https://www.cs.cmu.edu/~./jasonh/courses/ubicomp-sp2007/papers/12-wmc-94-schilit.pdf",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "May 2022"
+  },
+
+  IS_REALISM_COMPATIBLE_WITH_TRUE_RANDOMNESS: <Content>{
+    reference: {
+      title: "Is realism compatible with true randomness?",
+      authors: [{name: "Gisin, Nicolas"}],
+      published: [{name: "arXiv"}],
+      year: "2010",
+      link: "https://arxiv.org/pdf/1012.2536",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "September 2022"
+  },
+
+  WHAT_IS_A_KNOWLEDGE_REPRESENTATION: <Content>{
+    reference: {
+      title: "What Is a Knowledge Representation?",
+      authors: [{name: "Davis, Randall, Howard Shrobe, and Peter Szolovits"}],
+      published: [{name: "AI magazine 14.1"}],
+      year: "1993",
+      link: "https://ojs.aaai.org/index.php/aimagazine/article/download/1029/947",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "May 2022"
+  },
+
+  LEARNING_TO_REPRESENT_PROGRAMS_WITH_GRAPHS: <Content>{
+    reference: {
+      title: "Learning to Represent Programs with Graphs",
+      authors: [{name: "Allamanis, Miltiadis, Marc Brockschmidt, and Mahmoud Khademi"}],
+      published: [{name: "arXiv"}],
+      year: "2017",
+      link: "https://arxiv.org/pdf/1711.00740",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "May 2022"
+  },
+
+  A_THEORY_OF_INCREMENTAL_COMPRESSION: <Content>{
+    reference: {
+      title: "A theory of incremental compression",
+      authors: [{name: "Franz, Arthur, Oleksandr Antonenko, and Roman Soletskyi"}],
+      published: [{name: "Information Sciences 547"}],
+      year: "2021",
+      link: "https://arxiv.org/pdf/1908.03781",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "August 2022"
+  },
+
+  ON_THE_MEASURE_OF_INTELLIGENCE: <Content>{
+    reference: {
+      title: "On the Measure of Intelligence",
+      authors: [{name: "Chollet, François"}],
+      published: [{name: "arXiv"}],
+      year: "2019",
+      link: "https://arxiv.org/pdf/1911.01547",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "December 2022"
+  },
+
+  EMPIRICISM_SEMANTICS_AND_ONTOLOGY: <Content>{
+    reference: {
+      title: "Empiricism, Semantics, and Ontology",
+      authors: [{name: "Carnap, Rudolf"}],
+      published: [{name: "Revue internationale de philosophie"}],
+      year: "1950",
+      link: "https://authortomharper.com/wp-content/uploads/2022/04/1950-Empiricism-Semantics-and-Ontology-Carnap.pdf",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "October 2022"
+  },
+
+  HUTTER_PRIZE: <Content>{
+    reference: {
+      title: "Hutter Prize",
+      authors: [{name: "Hutter, Marcus"}],
+      link: "https://en.wikipedia.org/wiki/Hutter_Prize",
+    }, status: Viewed.VIEWED
+  },
+
+  GOING_BEYOND_THE_POINT_NEURON: <Content>{
+    reference: {
+      title: "Going Beyond the Point Neuron: Active Dendrites and Sparse Representations for Continual Learning",
+      authors: [{name: "Grewal, Karan, et al."}],
+      published: [{name: "bioRxiv"}],
+      year: "2021",
+      link: "https://www.biorxiv.org/content/biorxiv/early/2021/10/26/2021.10.25.465651.full.pdf",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "September 2022"
+  },
+
+  THE_GENERAL_THEORY_OF_GENERAL_INTELLIGENCE: <Content>{
+    reference: {
+      title: "The General Theory of General Intelligence: A Pragmatic Patternist Perspective",
+      authors: [{name: "Goertzel, Ben"}],
+      published: [{name: "arXiv"}],
+      year: "2021",
+      link: "https://arxiv.org/pdf/2103.15100",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "September 2022"
+  },
+
+  EMBODIED_SITUATED_AND_GROUNDED_INTELLIGENCE: <Content>{
+    reference: {
+      title: "Embodied, Situated, and Grounded Intelligence: Implications for AI",
+      authors: [{name: "Millhouse, Tyler, Melanie Moses, and Melanie Mitchell"}],
+      published: [{name: "arXiv"}],
+      year: "2022",
+      link: "https://arxiv.org/pdf/2210.13589",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "October 2022"
+  },
+
+  THE_DEBATE_OVER_UNDERSTANDING_IN_AI_LARGE_LANGUAGE_MODELS: <Content>{
+    reference: {
+      title: "The Debate Over Understanding in AI’s Large Language Models",
+      authors: [{name: "Mitchell, Melanie, and David C. Krakauer"}],
+      published: [{name: "Proceedings of the National Academy of Sciences 120.13"}],
+      year: "2023",
+      link: "https://www.pnas.org/doi/full/10.1073/pnas.2215907120",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "November 2022"
+  },
+
+  BEYOND_PROGRAMMING_LANGUAGES: <Content>{
+    reference: {
+      title: "Beyond Programming Languages",
+      authors: [{name: "Winograd, Terry"}],
+      published: [{name: "Communications of the ACM 22.7"}],
+      year: "1979",
+      link: "https://dl.acm.org/doi/pdf/10.1145/359131.359133",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "May 2022"
+  },
+
+  DATA_COMPRESSION_EXPLAINED: <Content>{
+    reference: {
+      title: "Data Compression Explained",
+      authors: [{name: "Mahoney, Matt"}],
+      published: [{name: "Mahoney, Matt"}],
+      year: "2010",
+      link: "https://mattmahoney.net/dc/dce.html",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "June 2022"
+  },
+
+  IPFS_FAN_A_FUNCTION_ADDRESSABLE_COMPUTATION_NETWORK: <Content>{
+    reference: {
+      title: "IPFS-FAN: A Function-Addressable Computation Network",
+      authors: [{name: "de la Rocha, Alfonso, Yiannis Psaras, and David Dias"}],
+      published: [{name: "IFIP Networking Conference (IFIP Networking). IEEE"}],
+      year: "2021",
+      link: "http://opendl.ifip-tc6.org/db/conf/networking/networking2021/1570713481.pdf",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "December 2022"
+  },
+
+  AVOIDING_CATASTROPHE_ACTIVE_DENDRITES_ENABLE_MULTI_TASK_LEARNING_IN_DYNAMICS_ENVIRONMENTS: <Content>{
+    reference: {
+      title: "Avoiding Catastrophe: Active Dendrites Enable Multi-Task Learning in Dynamic Environments",
+      authors: [{name: "Iyer, Abhiram, et al."}],
+      published: [{name: "Frontiers in neurorobotics 16"}],
+      year: "2022",
+      link: "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC9100780/",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: " 2022"
+  },
+
+  GAMES_AND_PUZZLES_AS_MULTICOMPUTATIONAL_SYSTEMS: <Content>{
+    reference: {
+      title: "Games and Puzzles as Multicomputational Systems",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: ""}],
+      year: "2022",
+      link: "https://writings.stephenwolfram.com/2022/06/games-and-puzzles-as-multicomputational-systems/",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "November 2022"
+  },
+
+  A_THOUSAND_BRAINS_TOWARD_BIOLOGICALLY_CONSTRAINED_AI: <Content>{
+    reference: {
+      title: "A thousand brains: toward biologically constrained AI",
+      authors: [{name: "Hole, Kjell Jørgen, and Subutai Ahmad"}],
+      published: [{name: "SN Applied Sciences 3.8"}],
+      year: "2021",
+      link: "https://link.springer.com/article/10.1007/s42452-021-04715-0",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "May 2022"
+  },
+
+  IS_PROBABILITY_THEORY_RELEVANT_FOR_UNCERTAINTY: <Content>{
+    reference: {
+      title: "Is Probability Theory Relevant for Uncertainty? A Post Keynesian Perspective",
+      authors: [{name: "Davidson, Paul"}],
+      published: [{name: "Journal of Economic Perspectives 5.1"}],
+      year: "1991",
+      link: "https://pubs.aeaweb.org/doi/pdf/10.1257/jep.5.1.129",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: " 2022"
+  },
+
+  MULTICOMPUTATION_A_FOURTH_PARADIGM_FOR_THEORETICAL_SCIENCE: <Content>{
+    reference: {
+      title: "Multicomputation: A Fourth Paradigm for Theoretical Science",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: ""}],
+      year: "2021",
+      link: "https://writings.stephenwolfram.com/2021/09/multicomputation-a-fourth-paradigm-for-theoretical-science/",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "December 2022"
+  },
+
+  ATTENTION_IS_ALL_YOU_NEED: <Content>{
+    reference: {
+      title: "Attention Is All You Need",
+      authors: [{name: "Vaswani, Ashish, et al."}],
+      published: [{name: "Advances in neural information processing systems 30"}],
+      year: "2017",
+      link: "https://proceedings.neurips.cc/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "November 2022"
+  },
+
+  ON_THE_EINSTEIN_PODOLSKY_ROSEN_PARADOX: <Content>{
+    reference: {
+      title: "On the Einstein Podolsky Rosen Paradox",
+      authors: [{name: "Bell, John S."}],
+      published: [{name: "Physics Physique Fizika 1.3 "}],
+      year: "1964",
+      link: "https://link.aps.org/pdf/10.1103/PhysicsPhysiqueFizika.1.195",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "June 2022"
+  },
+
+  THE_ALGORITHMIC_ORIGINS_OF_LIFE: <Content>{
+    reference: {
+      title: "The algorithmic origins of life",
+      authors: [{name: "Walker, Sara Imari, and Paul CW Davies"}],
+      published: [{name: "Journal of the Royal Society Interface 10.79"}],
+      year: "2013",
+      link: "https://royalsocietypublishing.org/doi/full/10.1098/rsif.2012.0869",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "November 2022"
+  },
+
+  THE_COMPUTER_FOR_THE_21ST_CENTURY: <Content>{
+    reference: {
+      title: "The computer for the 21st century",
+      authors: [{name: "Weiser, Mark"}],
+      published: [{name: "Scientific american 265.3 "}],
+      year: "1991",
+      link: "https://www.academia.edu/download/50943771/scientificamerican0991-9420161217-28996-1rvsbxf.pdf",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "May 2022"
+  },
+
+  SOK_SANITIZING_FOR_SECURITY: <Content>{
+    reference: {
+      title: "SoK: Sanitizing for Security",
+      authors: [{name: "Song, Dokyung, et al."}],
+      published: [{name: "IEEE Symposium on Security and Privacy (SP). IEEE"}],
+      year: "2019",
+      link: "https://arxiv.org/pdf/1806.04355",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "May 2022"
+  },
+
+  UNCERTAINTY_BELIEF_AND_PROBABILITY: <Content>{
+    reference: {
+      title: "Uncertainty, belief, and probability",
+      authors: [{name: "Fagin, Ronald, and Joseph Y. Halpern"}],
+      published: [{name: "Computational Intelligence 7.3"}],
+      year: "1991",
+      link: "https://s3.us.cloud-object-storage.appdomain.cloud/res-files/500-comint91.pdf",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "September 2022"
+  },
+
+  ON_DEFINING_ARTIFICAL_INTELLIGENCE: <Content>{
+    reference: {
+      title: "On Defining Artificial Intelligence",
+      authors: [{name: "Wang, Pei"}],
+      published: [{name: "Journal of Artificial General Intelligence 10.2"}],
+      year: "2019",
+      link: "https://sciendo.com/downloadpdf/journals/jagi/10/2/article-p1.pdf",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "August 2022"
+  },
+
+  ROBUST_SPEECH_RECOGNITION_VIA_LARGE_SCALE_WEAK_SUPERVISION: <Content>{
+    reference: {
+      title: "Robust Speech Recognition via Large-Scale Weak Supervision",
+      authors: [{name: "Radford, Alec, et al."}],
+      published: [{name: "arXiv"}],
+      year: "2022",
+      link: "https://arxiv.org/pdf/2212.04356",
+    }, status: Viewed.VIEWED, found_at: "2022", viewed_at: "December 2022"
+  },
+
+
+//
+
+
+  INTERACTION_COMBINATORS: <Content>{
+    reference: {
+      title: "Interaction Combinators",
+      authors: [{name: "Lafont, Yves."}],
+      published: [{name: "Information and Computation 137.1"}],
+      year: "1997",
+      link: "https://www.sciencedirect.com/science/article/pii/S0890540197926432/pdf?md5=30965cec6dd7605a865bbec4076f65e4&pid=1-s2.0-S0890540197926432-main.pdf",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "January 2023"
+  },
+
+  VON_NEUMANNS_IMPOSSIBILITY_PROOF_MATHEMATICS_IN_THE_SERVICE_OF_RHETORICS: <Content>{
+    reference: {
+      title: "Von Neumann’s Impossibility Proof: Mathematics in the Service of Rhetorics",
+      authors: [{name: "Dieks, Dennis"}],
+      published: [{name: "Studies in History and Philosophy of Science Part B: Studies in History and Philosophy of Modern Physics 60"}],
+      year: "2017",
+      link: "https://arxiv.org/pdf/1801.09305",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "February 2023"
+  },
+
+  PERFECTLY_SECURE_STEGANOGRAPHY_USING_MINIMUM_ENTROPY_COUPLING: <Content>{
+    reference: {
+      title: "Perfectly Secure Steganography Using Minimum Entropy Coupling",
+      authors: [{name: "de Witt, Christian Schroeder, et al."}],
+      published: [{name: "arXiv"}],
+      year: "2022",
+      link: "https://arxiv.org/pdf/2210.14889",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "March 2023"
+  },
+
+  GENERAL_INTELLIGENCE_REQUIRES_RETHINKING_EXPLORATION: <Content>{
+    reference: {
+      title: "General Intelligence Requires Rethinking Exploration",
+      authors: [{name: "Jiang, Minqi, Tim Rocktäschel, and Edward Grefenstette"}],
+      published: [{name: "arXiv"}],
+      year: "2022",
+      link: "https://arxiv.org/pdf/2211.07819",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "March 2023"
+  },
+
+  DENSEPOSE_FROM_WIFI: <Content>{
+    reference: {
+      title: "DensePose From WiFi",
+      authors: [{name: "Geng, Jiaqi, Dong Huang, and Fernando De la Torre"}],
+      published: [{name: "arXiv"}],
+      year: "2022",
+      link: "https://arxiv.org/pdf/2301.00250",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "February 2023"
+  },
+
+  A_MECHANIZED_FORMALIZATION_OF_THE_WEBASSEMBLY_SPECIFICATION_IN_COQ: <Content>{
+    reference: {
+      title: "A Mechanized Formalization of the WebAssembly Specification in Coq",
+      authors: [{name: "Huang, Xuan"}],
+      published: [{name: "RIT Computer Science"}],
+      year: "2019",
+      link: "https://www.semanticscholar.org/paper/A-Mechanized-Formalization-of-the-WebAssembly-in-Huang/2fde569f52c37fe8e45ebf05268e1b4341b58cbf",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "May 2023"
+  },
+
+  A_DENOTATIONAL_SEMANTICS_FOR_THE_SYMMETRIC_INTERACTION_COMBINATORS: <Content>{
+    reference: {
+      title: "A Denotational Semantics for the Symmetric Interaction Combinators",
+      authors: [{name: "Mazza, Damian"}],
+      published: [{name: "Mathematical Structures in Computer Science 17.3 "}],
+      year: "2007",
+      link: "https://www.researchgate.net/profile/Damiano-Mazza/publication/220173732_A_denotational_semantics_for_the_symmetric_interaction_combinators/links/0912f50f4273696c14000000/A-denotational-semantics-for-the-symmetric-interaction-combinators.pdf",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "January 2023"
+  },
+
+  DEEP_SELF_MODELING_AS_A_FUNDAMENTAL_PRINCIPLE_IN_THE_DESIGN_OF_INTELLIGENT_SYSTEMS: <Content>{
+    reference: {
+      title: "Deep self-modeling as a fundamental principle in the design of intelligent systems",
+      authors: [{name: "Dean, George"}],
+      published: [{name: "Lab42"}],
+      year: "2022",
+      link: "https://lab42.global/past-challenges/essay-intelligence/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "January 2023"
+  },
+  AI_ARTIFICIAL_INTELLIGENCE_OR_ARTIFICAL_IGNORANCE: <Content>{
+    reference: {
+      title: "A.I. (Artificial Intelligence or Artificial Ignorance?",
+      authors: [{name: "Pavan, Massimiliano"}],
+      published: [{name: "Lab42"}],
+      year: "2022",
+      link: "https://lab42.global/past-challenges/essay-intelligence/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "January 2023"
+  },
+  FROM_HUME_TO_HUMAN_AI_A_RETURN_TO_THE_FOUNDATIONS_AND_RESTRICTIONS_OF_HUMEAN_REASONING: <Content>{
+    reference: {
+      title: "From Hume to Human AI: A return to the foundations and restrictions of hum(e)an reasoning",
+      authors: [{name: "Burke, Cassidy, Maura"}],
+      published: [{name: "Lab42"}],
+      year: "2022",
+      link: "https://lab42.global/past-challenges/essay-intelligence/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "January 2023"
+  },
+  BUILDING_HUMAN_LIKE_INTELLIGENCE_AN_EVOLUTIONARY_PERSPECTIVE: <Content>{
+    reference: {
+      title: "Building human-like intelligence: an evolutionary perspective",
+      authors: [{name: "Ouellette, Simon"}],
+      published: [{name: "Lab42"}],
+      year: "2022",
+      link: "https://lab42.global/past-challenges/essay-intelligence/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "January 2023"
+  },
+  A_CASE_FOR_COMPUTATIONAL_INTELLIGENCE_AS_RECURSIVE_ABSTRACTION_AND_GOAL_ORIENTED_SYNTHESIS: <Content>{
+    reference: {
+      title: "A Case for Computational Intelligence as Recursive Abstraction and Goal-Oriented Synthesis",
+      authors: [{name: "Song, Yiding"}],
+      published: [{name: "Lab42"}],
+      year: "2022",
+      link: "https://lab42.global/past-challenges/essay-intelligence/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "January 2023"
+  },
+
+  REVERSE_ENGINEERING_WEBASSEMBLY: <Content>{
+    reference: {
+      title: "Reverse Engineering WebAssembly",
+      authors: [{name: "Falliere, Nicolas"}],
+      published: [{name: "PNF Software"}],
+      year: "2018",
+      link: "https://www.pnfsoftware.com/reversing-wasm.pdf",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "May 2023"
+  },
+
+  TOROIDAL_TOPOLOGY_OF_POPULATION_ACTIVITY_IN_GRID_CELLS: <Content>{
+    reference: {
+      title: "Toroidal topology of population activity in grid cells",
+      authors: [{name: "Gardner, Richard J., et al."}],
+      published: [{name: "Nature 602.7895"}],
+      year: "2022",
+      link: "https://www.nature.com/articles/s41586-021-04268-7",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "March 2023"
+  },
+
+  A_50_YEAR_QUEST_MY_PERSONAL_JOURNEY_WITH_THE_SECOND_LAW_OF_THERMODYNAMICS: <Content>{
+    reference: {
+      title: "A 50-Year Quest: My Personal Journey with the Second Law of Thermodynamics",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://writings.stephenwolfram.com/2023/02/a-50-year-quest-my-personal-journey-with-the-second-law-of-thermodynamics/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "March 2023"
+  },
+  ALIEN_INTELLIGENCE_AND_THE_CONCEPT_OF_TECHNOLOGY: <Content>{
+    reference: {
+      title: "Alien Intelligence and the Concept of Technology",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: ""}],
+      year: "2022",
+      link: "https://writings.stephenwolfram.com/2022/06/alien-intelligence-and-the-concept-of-technology/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "March 2023"
+  },
+  CHATGPT_GETS_ITS_WOLFRAM_SUPERPOWERS: <Content>{
+    reference: {
+      title: "ChatGPT Gets Its “Wolfram Superpowers”!",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://writings.stephenwolfram.com/2023/03/chatgpt-gets-its-wolfram-superpowers/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "March 2023"
+  },
+  COMPUTATIONAL_FOUNDATIONS_FOR_THE_SECOND_LAW_OF_THERMODYNAMICS: <Content>{
+    reference: {
+      title: "Computational Foundations for the Second Law of Thermodynamics",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://writings.stephenwolfram.com/2023/02/computational-foundations-for-the-second-law-of-thermodynamics/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "March 2023"
+  },
+  FASTER_THAN_LIGHT_IN_OUR_MODEL_OF_PHYSICS_SOME_PRELIMINARY_THOUGHTS: <Content>{
+    reference: {
+      title: "Faster than Light in Our Model of Physics: Some Preliminary Thoughts",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: ""}],
+      year: "2020",
+      link: "https://writings.stephenwolfram.com/2020/10/faster-than-light-in-our-model-of-physics-some-preliminary-thoughts/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "March 2023"
+  },
+  HOW_DID_WE_GET_HERE_THE_TANGLED_HISTORY_OF_THE_SECOND_LAW_OF_THERMODYNAMICS: <Content>{
+    reference: {
+      title: "How Did We Get Here? The Tangled History of the Second Law of Thermodynamics",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://writings.stephenwolfram.com/2023/01/how-did-we-get-here-the-tangled-history-of-the-second-law-of-thermodynamics/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "March 2023"
+  },
+  MULTICOMPUTATIONAL_IRREDUCIBILITY: <Content>{
+    reference: {
+      title: "Multicomputational Irreducibility",
+      authors: [{name: "Boyd, James"}],
+      published: [{name: "Wolfram Institute"}],
+      year: "2022",
+      link: "https://www.wolframphysics.org/bulletins/2022/06/multicomputational-irreducibility/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "March 2023"
+  },
+
+  ZX_CALCULUS_AND_EXTENDED_HYPERGRAPH_REWRITING_SYSTEMS_I: <Content>{
+    reference: {
+      title: "ZX-Calculus and Extended Hypergraph Rewriting Systems I: A Multiway Approach to Categorical Quantum Information Theory",
+      authors: [{name: "Gorard, Jonathan, Manojna Namuduri, and Xerxes D. Arsiwalla"}],
+      published: [{name: "arXiv"}],
+      year: "2020",
+      link: "https://arxiv.org/pdf/2010.02752",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "June 2023"
+  },
+
+  FAST_AUTOMATED_REASONING_OVER_STRING_DIAGRAMS_USING_MULTIWAY_CAUSAL_STRUCTURE: <Content>{
+    reference: {
+      title: "Fast Automated Reasoning over String Diagrams using Multiway Causal Structure",
+      authors: [{name: "Gorard, Jonathan, Manojna Namuduri, and Xerxes D. Arsiwalla"}],
+      published: [{name: "arXiv"}],
+      year: "2021",
+      link: "https://arxiv.org/pdf/2105.04057",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "June 2023"
+  },
+
+  LAGRANGIAN_NEURAL_NETWORKS: <Content>{
+    reference: {
+      title: "Lagrangian Neural Networks",
+      authors: [{name: "Cranmer, Miles, et al"}],
+      published: [{name: "arXiv"}],
+      year: "2020",
+      link: "https://arxiv.org/pdf/2003.04630",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "June 2023"
+  },
+
+  QUANTOMATRIC_A_PROOF_ASSISTANT_FOR_DIAGRAMMATIC_REASONING: <Content>{
+    reference: {
+      title: "Quantomatic: A proof assistant for diagrammatic reasoning",
+      authors: [{name: "Kissinger, Aleks, and Vladimir Zamdzhiev"}],
+      published: [{name: "Automated Deduction-CADE-25: 25th International Conference on Automated Deduction, Berlin, Germany"}],
+      year: "2015",
+      link: "https://arxiv.org/pdf/1503.01034",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "June 2023"
+  },
+
+  THE_SEMANTIC_CONCEPTION_OF_TRUTH_AND_THE_FOUNDATIONS_OF_SEMANTICS: <Content>{
+    reference: {
+      title: "The semantic conception of truth: and the foundations of semantics",
+      authors: [{name: "Tarski, Alfred"}],
+      published: [{name: "The semantic conception of truth: and the foundations of semantics"}],
+      year: "1944",
+      link: "https://sites.google.com/site/filosofiaetc/histfil/Tarski_SCT_1944.pdf",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "June 2023"
+  },
+
+  RESIDUALITY_THEORY_RANDOM_SIMULATION_AND_ATTRACTOR_NETWORKS: <Content>{
+    reference: {
+      title: "Residuality Theory, random simulation, and attractor networks",
+      authors: [{name: "O’Reilly, Barry M."}],
+      published: [{name: "Procedia Computer Science 201"}],
+      pointer: '639-645',
+      year: "2022",
+      link: "https://www.sciencedirect.com/science/article/pii/S1877050922004975/pdf?md5=faa21ad837ec9eba6fac3beb2cd93f9f&pid=1-s2.0-S1877050922004975-main.pdf",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "July 2023"
+  },
+
+  A_FUNCTORIAL_PERSPECTIVE_ON_MULTICOMPUTATIONAL_IRREDUCIBILITY: <Content>{
+    reference: {
+      title: "A Functorial Perspective on (Multi)computational Irreducibility",
+      authors: [{name: "Gorard, Jonathan"}],
+      published: [{name: "arXiv"}],
+      year: "2022",
+      link: "https://arxiv.org/pdf/2301.04690",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "July 2023"
+  },
+
+  BIOELECTRIC_NETWORKS_THE_COGNITIVE_GLUE_ENABLING_EVOLUTIONARY_SCALING_FROM_PHYSIOLOGY_TO_MIND: <Content>{
+    reference: {
+      title: "Bioelectric networks: the cognitive glue enabling evolutionary scaling from physiology to mind",
+      authors: [{name: "Levin, Michael"}],
+      published: [{name: "Animal Cognition"}],
+      year: "2023",
+      link: "https://link.springer.com/article/10.1007/s10071-023-01780-3",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "July 2023"
+  },
+
+  COMPETENCY_IN_NAVIGATING_ARBITRARY_SPACES_AS_AN_INVARIANT_FOR_ANALYZING_COGNITION_IN_DIVERSE_EMBODIMENTS: <Content>{
+    reference: {
+      title: "Competency in Navigating Arbitrary Spaces as an Invariant for Analyzing Cognition in Diverse Embodiments",
+      authors: [{name: "Fields, Chris, and Levin, Michael"}],
+      pointer: '819',
+      published: [{name: "Entropy 24.6"}],
+      year: "2022",
+      link: "https://www.mdpi.com/1099-4300/24/6/819",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "July 2023"
+  },
+
+  CHROME_SHIPS_WEBGPU: <Content>{
+    reference: {
+      title: "Chrome ships WebGPU",
+      authors: [{name: "Beaufort, François and Wallez, Corentin"}],
+      published: [{name: "Chrome Developers Blog"}],
+      year: "2023",
+      link: "https://developer.chrome.com/blog/webgpu-release/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "July 2023"
+  },
+
+  GET_STARTED_WITH_GPU_COMPUTE_ON_THE_WEB: <Content>{
+    reference: {
+      title: "Get started with GPU Compute on the web",
+      authors: [{name: "Beaufort, François"}],
+      published: [{name: "Chrome Developers Blog"}],
+      year: "2023",
+      link: "https://developer.chrome.com/articles/gpu-compute/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "July 2023"
+  },
+
+  SPAWNING_A_WASI_THREAD_WITH_RAW_WEBASSEMBLY: <Content>{
+    reference: {
+      title: "Spawning a WASI Thread with raw WebAssembly",
+      authors: [{name: "Das Surma"}],
+      published: [{name: "surma.dev"}],
+      year: "2023",
+      link: "https://surma.dev/postits/wasi-threads/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "July 2023"
+  },
+
+  WEBGPU_ALL_OF_THE_CORES_NONE_OF_THE_CANVAS: <Content>{
+    reference: {
+      title: "WebGPU — All of the cores, none of the canvas",
+      authors: [{name: "Das Surma"}],
+      published: [{name: "surma.dev"}],
+      year: "2022",
+      link: "https://surma.dev/things/webgpu/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "July 2023"
+  },
+
+  REMEMBERING_THE_IMPROBABLE_LIFE_OF_ED_FREDKIN: <Content>{
+    reference: {
+      title: "Remembering the Improbable Life of Ed Fredkin (1934–2023) and His World of Ideas and Stories",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://writings.stephenwolfram.com/2023/08/remembering-the-improbable-life-of-ed-fredkin-1934-2023-and-his-world-of-ideas-and-stories/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "August, 2023"
+  },
+
+  REMEMBERING_DOUG_LENAT: <Content>{
+    reference: {
+      title: "Remembering Doug Lenat (1950–2023) and His Quest to Capture the World with Logic",
+      authors: [{name: "Wolfram, Stephen"}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://writings.stephenwolfram.com/2023/09/remembering-doug-lenat-1950-2023-and-his-quest-to-capture-the-world-with-logic/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "September, 2023"
+  },
+
+  THE_ALEXANDRIA_PROJECT_WHAT_HAS_BEEN_ACCOMPLISHED: <Content>{
+    reference: {
+      title: "The ALEXANDRIA Project: what has been accomplished?",
+      authors: [{name: "Paulson, Lawrence C."}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://lawrencecpaulson.github.io/2023/04/27/ALEXANDRIA_outcomes.html",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "September, 2023"
+  },
+  THE_END_OF_THE_ALEXANDRIA_PROJECT: <Content>{
+    reference: {
+      title: "The End (?) of the ALEXANDRIA Project",
+      authors: [{name: "Paulson, Lawrence C."}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://lawrencecpaulson.github.io/2023/08/31/ALEXANDRIA_finished.html",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "September, 2023"
+  },
+  WHEN_IS_A_COMPUTER_PROOF_A_PROOF: <Content>{
+    reference: {
+      title: "When is a computer proof a proof?",
+      authors: [{name: "Paulson, Lawrence C."}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://lawrencecpaulson.github.io/2023/08/09/computer_proof.html",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "September, 2023"
+  },
+  ALEXANDRIA_LARGE_SCALE_FORMAL_PROOF_FOR_THE_WORKING_MATHEMATICIAN: <Content>{
+    reference: {
+      title: "ALEXANDRIA: Large-Scale Formal Proof for the Working Mathematician",
+      authors: [{name: "Paulson, Lawrence C."}],
+      published: [{name: ""}],
+      year: "2021",
+      link: "https://lawrencecpaulson.github.io/2021/12/08/ALEXANDRIA.html",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "September, 2023"
+  },
+  THE_ORIGINS_AND_MOTIVATIONS_OF_UNIVALENT_FOUNDATIONS: <Content>{
+    reference: {
+      title: "The Origins and Motivations of Univalent Foundations",
+      authors: [{name: "Voevodsky, Vladimir"}],
+      published: [{name: ""}],
+      year: "2014",
+      link: "https://www.ias.edu/ideas/2014/voevodsky-origins",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "September, 2023"
+  },
+
+  ZENBLEED: <Content>{
+    reference: {
+      title: "Zenbleed",
+      authors: [{name: "Ormandy, Tavis"}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://lock.cmpxchg8b.com/zenbleed.html",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "October, 2023"
+  },
+  DOWNFALL: <Content>{
+    reference: {
+      title: "Downfall: Exploiting Speculative Data Gathering",
+      authors: [{name: "Moghimi, Daniel"}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://downfall.page/media/downfall.pdf",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "October, 2023"
+  },
+  ASSEMBLY_THEORY_EXPLAINS_AND_QUANTIFIES_SELECTION_AND_EVOLUTION: <Content>{
+    reference: {
+      title: "Assembly theory explains and quantifies selection and evolution",
+      authors: [{name: "Abhishek Sharma, Dániel Czégel, Michael Lachmann, Christopher P. Kempes, Sara I. Walker and Leroy Cronin"}],
+      published: [{name: ""}],
+      year: "2023",
+      link: "https://www.nature.com/articles/s41586-023-06600-9",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "October, 2023"
+  },
+
+  WILL_COMPUTERS_REDEFINE_THE_ROOTS_OF_MATH: <Content>{
+    reference: {
+      title: "Will Computers Redefine the Roots of Math?",
+      authors: [{name: "Hartnett, Kevin"}],
+      published: [{name: ""}],
+      year: "2015",
+      link: "https://www.quantamagazine.org/will-computers-redefine-the-roots-of-math-20150519/",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "August, 2023"
+  },
+
+  QUANTUM_IN_PICTURES: <Content>{
+    reference: {
+      title: "Quantum in Pictures",
+      authors: [{name: "Coecke, Bob and Gogioso, Stefano"}],
+      published: [{name: "Quantinuum"}],
+      year: "2023",
+      link: "https://www.quantinuum.com/news/quantum-in-pictures",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "August, 2023", type: 'book'
+  },
+
+  CATEGORY_THEORY_I: <Content>{
+    reference: {
+      title: "Category Theory I",
+      authors: [{name: "Milewski, Bartosz"}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: "2016",
+      link: "https://www.youtube.com/watch?v=I8LbkfSSR58&list=PLbgaMIhjbmEnaH_LTkxLI7FMa2HsnawM_",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "August, 2023"
+  },
+  CATEGORY_THEORY_II: <Content>{
+    reference: {
+      title: "Category Theory II",
+      authors: [{name: "Milewski, Bartosz"}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: "2017",
+      link: "https://www.youtube.com/watch?v=3XTQSx1A3x8&list=PLbgaMIhjbmElia1eCEZNvsVscFef9m0dm",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "August, 2023"
+  },
+  CATEGORY_THEORY_III: <Content>{
+    reference: {
+      title: "Category Theory III",
+      authors: [{name: "Milewski, Bartosz"}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: "2018",
+      link: "https://www.youtube.com/watch?v=F5uEpKwHqdk&list=PLbgaMIhjbmEn64WVX4B08B4h2rOtueWIL",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "August, 2023"
+  },
+
+  DIHEAPS_A_NEW_SPECIES_OF_ALGEBRAIC_STRUCTURE: <Content>{
+    reference: {
+      title: "Diheaps: a new species of algebraic structure",
+      authors: [{name: "Zapata, Carlos"}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: "2023",
+      link: "https://www.youtube.com/watch?v=YOfIXwBHPFU",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "August, 2023"
+  },
+
+  HACKENBUSH_A_WINDOW_TO_A_NEW_WORLD_OF_MATH: <Content>{
+    reference: {
+      title: "HACKENBUSH: a window to a new world of math\n",
+      authors: [{name: "Maitzen, Owen"}],
+      organizations: [ORGANIZATIONS.youtube],
+      year: "2021",
+      link: "https://www.youtube.com/watch?v=ZYj4NkeGPdM",
+    }, status: Viewed.VIEWED, found_at: "2023", viewed_at: "August, 2023"
+  },
+
+  EXPLORER_ORBITMINES_RESEARCH: <Content>{
+    reference: {
+      title: "Independent Researcher - OrbitMines Research",
+      organizations: [ORGANIZATIONS.orbitmines_research],
+      year: "July, 2022 - Present",
+      link: "https://orbitmines.com/"
+    }, status: Viewed.VIEWED, viewed_at: "July, 2022 - Present"
+  },
+  SOFTWARE_DEVELOPER_AT_BREACHLOCK_INC: <Content>{
+    reference: {
+      title: "Software Developer - BreachLock Inc.",
+      organizations: [{name: "BreachLock Inc."}],
+      year: "November, 2021 - May, 2022",
+      link: "https://www.linkedin.com/company/breachlock/"
+    }, status: Viewed.VIEWED, viewed_at: "November, 2021 - May, 2022"
+  },
+  CONTRACTOR_AT_MARTI_ORBAK_SOFTWARE: <Content>{
+    reference: {
+      title: "Contractor - MartiOrbak Software",
+      organizations: [{name: "MartiOrbak Software"}],
+      year: "November, 2020 - March 2021",
+      link: "https://www.linkedin.com/company/marti-orbak-software/"
+    }, status: Viewed.VIEWED, viewed_at: "November, 2020 - March 2021"
+  },
+  BACKEND_DEVELOPER_AT_MOBIEL_NL: <Content>{
+    reference: {
+      title: "Backend Developer - Mobiel.nl",
+      organizations: [{name: "Mobiel.nl"}],
+      year: "November, 2018 - August, 2019",
+      link: "https://www.linkedin.com/company/mobiel.nl/",
+    },
+    status: Viewed.VIEWED,
+    viewed_at: "November, 2018 - August, 2019",
+    description: "My first interaction working at a SME."
+  },
+  FOUNDER_AT_ORBITMINES_MINECRAFT: <Content>{
+    reference: {
+      title: "Founder - OrbitMines (Minecraft)",
+      organizations: [ORGANIZATIONS.orbitmines_research],
+      year: "October, 2013 - May, 2019",
+      link: "https://www.youtube.com/@OrbitMines/videos",
+    },
+    status: Viewed.VIEWED,
+    viewed_at: "October, 2013 - May, 2019",
+    description: "I introduced myself to software engineering during this period by designing and maintaining my own Minecraft game server, which had a small community of concurrent players."
+  },
+
+
+  LEIDEN_UNIVERSITY: <Content>{
+    reference: {
+      title: "(Unfinished) Computer Science (BSc)",
+      published: [{name: "Leiden University"}],
+      year: "2020: I stop attending Leiden University. If you could call what I did there as attending in the first place. Perhaps more of an (immature) severe disinterest",
+    }, status: Viewed.IN_PROGRESS, viewed_at: "September, 2019 - December, 2020", archived: true
+  },
+
+  VWO: <Content>{
+    reference: {
+      title: "VWO / Science & Engineering",
+      year: "2012 - 2019"
+    }, status: Viewed.VIEWED, viewed_at: "2012 - 2019"
+  },
+
+  SEMF_2023: <Content>{
+    reference: {
+      title: "SEMF School of 2023",
+      organizations: [ORGANIZATIONS.semf],
+      year: "2023",
+      link: "https://semf.org.es/school2023/"
+    }, status: Viewed.VIEWED, found_at: "July, 2023", viewed_at: "2023"
+  },
+  SEMF_2025: <Content>{
+    reference: {
+      title: "SEMF School of 2025",
+      organizations: [ORGANIZATIONS.semf],
+      year: "2025",
+      link: "https://semf.org.es/school2025/"
+    }, status: Viewed.VIEWED, found_at: "July, 2023", viewed_at: "2023"
+  },
+
+  URSPRUNG_IV: <Content>{
+    reference: {
+      title: "Ursprung IV",
+      organizations: [ORGANIZATIONS.ursprung],
+      year: "2026",
+      link: "https://ursprung.community/"
+    }, status: Viewed.VIEWED, found_at: "July, 2026", viewed_at: "2026"
+  },
+
+  SYCO_12: <Content>{
+    reference: {
+      title: "Twelfth Symposium on Compositional Structures (SYCO 12)",
+      organizations: [ORGANIZATIONS.syco],
+      year: "2024 @ Birmingham, UK",
+      link: "https://www.cl.cam.ac.uk/events/syco/12/"
+    }, status: Viewed.VIEWED, found_at: "2024", viewed_at: "2024"
+  },
+
+  INTO_THE_INFORMATION_CONTINUUM_2024_03_09: <Content>{
+    reference: {
+      title: "In-Person Workshop | Into the Information Continuum",
+      organizations: [ORGANIZATIONS.semf],
+      year: "2024, 9 March @ Amsterdam",
+      link: "https://www.youtube.com/watch?v=KM97bUcVPDE&t=2786s"
+    }, status: Viewed.VIEWED, found_at: "2024", viewed_at: "2024"
+  },
+  INTO_THE_INFORMATION_CONTINUUM_2024_05_04: <Content>{
+    reference: {
+      title: "In-Person Workshop | Into the Information Continuum",
+      organizations: [ORGANIZATIONS.semf],
+      year: "2024, 4 May @ Amsterdam",
+      link: "https://www.youtube.com/watch?v=KM97bUcVPDE&t=2786s"
+    }, status: Viewed.VIEWED, found_at: "2024", viewed_at: "2024"
+  },
+
+  NGI_FORUM_2023: <Content>{
+    reference: {
+      title: "NGI FORUM 2023",
+      organizations: [ORGANIZATIONS.ngi],
+      year: "2023",
+      link: "https://www.ngi.eu/event/ngi-forum-2023/"
+    }, status: Viewed.VIEWED, found_at: "July, 2023", viewed_at: "2023"
+  },
+
+  RUST: <Content>{
+    reference: {title: "Rust", link: "https://en.wikipedia.org/wiki/Rust_(programming_language)"},
+    status: Viewed.VIEWED
+  },
+  JAVA: <Content>{
+    reference: {title: "Java", link: "https://en.wikipedia.org/wiki/Java_(programming_language)"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  KOTLIN: <Content>{
+    reference: {title: "Kotlin", link: "https://en.wikipedia.org/wiki/Kotlin_(programming_language)"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  RUBY_ON_RAILS: <Content>{
+    reference: {title: "Ruby (on Rails)", link: "https://en.wikipedia.org/wiki/Ruby_on_Rails"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  C_SHARP: <Content>{
+    reference: {title: "C#", link: "https://en.wikipedia.org/wiki/C_Sharp_(programming_language)"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  DOT_NET: <Content>{
+    reference: {title: ".NET", link: "https://en.wikipedia.org/wiki/.NET"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  BLAZOR: <Content>{
+    reference: {title: "Blazor", link: "https://en.wikipedia.org/wiki/Blazor"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  JAVASCRIPT: <Content>{
+    reference: {title: "JavaScript", link: "https://en.wikipedia.org/wiki/JavaScript"},
+    status: Viewed.VIEWED
+  },
+  CSS: <Content>{reference: {title: "CSS", link: "https://en.wikipedia.org/wiki/CSS"}, status: Viewed.VIEWED},
+  SASS: <Content>{
+    reference: {title: "SASS", link: "https://en.wikipedia.org/wiki/Sass_(stylesheet_language)"},
+    status: Viewed.VIEWED
+  },
+  HTML: <Content>{reference: {title: "HTML", link: "https://en.wikipedia.org/wiki/HTML"}, status: Viewed.VIEWED},
+  WEBPACK: <Content>{reference: {title: "Webpack", link: "https://webpack.js.org/"}, status: Viewed.VIEWED},
+  TYPESCRIPT: <Content>{
+    reference: {title: "TypeScript", link: "https://en.wikipedia.org/wiki/TypeScript"},
+    status: Viewed.VIEWED
+  },
+  REACT: <Content>{
+    reference: {title: "React", link: "https://en.wikipedia.org/wiki/React_(JavaScript_library)"},
+    status: Viewed.VIEWED
+  },
+  BLUEPRINT_JS: <Content>{
+    reference: {title: "Blueprint.js", link: "https://github.com/palantir/blueprint"},
+    status: Viewed.VIEWED
+  },
+  SLATE: <Content>{
+    reference: {title: "Slate", link: "https://github.com/ianstormtaylor/slate"},
+    status: Viewed.IN_PROGRESS
+  },
+  THREEJS: <Content>{
+    reference: {title: "Three.js", link: "https://github.com/mrdoob/three.js/"},
+    status: Viewed.IN_PROGRESS
+  },
+  NEXTJS: <Content>{
+    reference: {title: "Next.js", link: "https://nextjs.org/"},
+    status: Viewed.IN_PROGRESS
+  },
+  DREI: <Content>{reference: {title: "drei", link: "https://github.com/pmndrs/drei"}, status: Viewed.IN_PROGRESS},
+  WASM: <Content>{
+    reference: {title: "WebAssembly", link: "https://en.wikipedia.org/wiki/WebAssembly"},
+    status: Viewed.IN_PROGRESS
+  },
+  ASSEMBLY_SCRIPT: <Content>{
+    reference: {title: "AssemblyScript", link: "https://en.wikipedia.org/wiki/AssemblyScript"},
+    status: Viewed.IN_PROGRESS
+  },
+  CPP: <Content>{reference: {title: "C++", link: "https://en.wikipedia.org/wiki/C%2B%2B"}, status: Viewed.VIEWED},
+  PYTHON: <Content>{
+    reference: {title: "Python", link: "https://en.wikipedia.org/wiki/Python_(programming_language)"},
+    status: Viewed.VIEWED
+  },
+  GO: <Content>{
+    reference: {title: "Go", link: "https://en.wikipedia.org/wiki/Go_(programming_language)"},
+    status: Viewed.VIEWED
+  },
+  HASKELL: <Content>{
+    reference: {title: "Haskell", link: "https://en.wikipedia.org/wiki/Haskell"},
+    status: Viewed.VIEWED
+  },
+  WOLFRAM_LANGUAGE: <Content>{
+    reference: {
+      title: "Wolfram Language",
+      link: "https://en.wikipedia.org/wiki/Wolfram_Language"
+    }, status: Viewed.VIEWED
+  },
+  LLVM: <Content>{reference: {title: "LLVM", link: "https://en.wikipedia.org/wiki/LLVM"}, status: Viewed.IN_PROGRESS},
+  IPFS: <Content>{
+    reference: {title: "IPFS", link: "https://en.wikipedia.org/wiki/InterPlanetary_File_System"},
+    status: Viewed.VIEWED
+  },
+  IPVM: <Content>{reference: {title: "IPVM", link: "https://github.com/ipvm-wg"}, status: Viewed.VIEWED},
+  SQL: <Content>{
+    reference: {title: "SQL", link: "https://en.wikipedia.org/wiki/SQL"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  MYSQL: <Content>{
+    reference: {title: "MySQL", link: "https://en.wikipedia.org/wiki/MySQL"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  POSTGRESQL: <Content>{
+    reference: {title: "PostgreSQL", link: "https://en.wikipedia.org/wiki/PostgreSQL"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  MONGO_DB: <Content>{
+    reference: {title: "MongoDB", link: "https://en.wikipedia.org/wiki/MongoDB"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  REDIS: <Content>{
+    reference: {title: "Redis", link: "https://en.wikipedia.org/wiki/Redis"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  RABBIT_MQ: <Content>{
+    reference: {title: "RabbitMQ", link: "https://en.wikipedia.org/wiki/RabbitMQ"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  GIT: <Content>{reference: {title: "Git", link: "https://en.wikipedia.org/wiki/Git"}, status: Viewed.VIEWED},
+  GITLAB: <Content>{
+    reference: {title: "GitLab", link: "https://en.wikipedia.org/wiki/GitLab"},
+    status: Viewed.VIEWED
+  },
+  GITHUB: <Content>{
+    reference: {title: "GitHub", link: "https://en.wikipedia.org/wiki/GitHub"},
+    status: Viewed.VIEWED
+  },
+  BITBUCKET: <Content>{
+    reference: {title: "Bitbucket", link: "https://en.wikipedia.org/wiki/Bitbucket"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  DOCKER: <Content>{
+    reference: {title: "Docker", link: "https://en.wikipedia.org/wiki/Docker_(software)"},
+    status: Viewed.VIEWED
+  },
+  KUBERNETES: <Content>{
+    reference: {title: "Kubernetes", link: "https://en.wikipedia.org/wiki/Kubernetes"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  NGINX: <Content>{reference: {title: "NGINX", link: "https://en.wikipedia.org/wiki/Nginx"}, status: Viewed.VIEWED},
+  NPM: <Content>{
+    reference: {title: "NPM", link: "https://en.wikipedia.org/wiki/Npm_(software)"},
+    status: Viewed.VIEWED
+  },
+  MAVEN: <Content>{
+    reference: {title: "Maven", link: "https://en.wikipedia.org/wiki/Apache_Maven"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  LINUX: <Content>{reference: {title: "Linux", link: "https://en.wikipedia.org/wiki/Linux"}, status: Viewed.VIEWED},
+  ANDROID: <Content>{
+    reference: {title: "Android", link: "https://en.wikipedia.org/wiki/Android_(operating_system)"},
+    status: Viewed.VIEWED
+  },
+  GCP: <Content>{
+    reference: {title: "GCP", link: "https://en.wikipedia.org/wiki/Google_Cloud_Platform"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  AZURE: <Content>{
+    reference: {title: "Azure", link: "https://en.wikipedia.org/wiki/Microsoft_Azure"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  AWS: <Content>{
+    reference: {title: "AWS", link: "https://en.wikipedia.org/wiki/Amazon_Web_Services"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  SPIGOT_MC: <Content>{
+    reference: {title: "SpigotMC", link: "https://www.spigotmc.org/"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  BUNGEE_CORD: <Content>{
+    reference: {title: "BungeeCord", link: "https://www.spigotmc.org/"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  BUKKIT: <Content>{
+    reference: {title: "Bukkit", link: "https://dev.bukkit.org/"},
+    status: Viewed.VIEWED,
+    archived: true
+  },
+  FLATPAK: <Content>{
+    reference: {title: "Flatpak", link: "https://en.wikipedia.org/wiki/Flatpak"},
+    status: Viewed.VIEWED,
+    archived: false
+  },
+  OBS: <Content>{
+    reference: {title: "OBS Studio", link: "https://en.wikipedia.org/wiki/OBS_Studio"},
+    status: Viewed.VIEWED,
+    archived: false
+  },
+  CLOUDFLARE: <Content>{
+    reference: {title: "Cloudflare", link: "https://en.wikipedia.org/wiki/Cloudflare"},
+    status: Viewed.VIEWED,
+    archived: false
+  },
+  CHYP: <Content>{
+    reference: {title: "Chyp", link: "https://github.com/akissinger/chyp"},
+    status: Viewed.VIEWED,
+    archived: false
+  },
+  WEBGPU: <Content>{
+    reference: {title: "WebGPU", link: "https://github.com/gpuweb/gpuweb"},
+    status: Viewed.VIEWED,
+    archived: false
+  },
+  INTELLI_J: <Content>{
+    reference: {title: "IntelliJ", link: "https://github.com/JetBrains/intellij-community"},
+    status: Viewed.VIEWED,
+    archived: false
+  },
+  VS_CODE: <Content>{
+    reference: {title: "VS Code", link: "https://github.com/microsoft/vscode"},
+    status: Viewed.VIEWED,
+    archived: false
+  },
+  ECLIPSE: <Content>{
+    reference: {title: "Eclipse", link: "https://github.com/eclipse-platform/eclipse.platform"},
+    status: Viewed.VIEWED,
+    archived: false
+  },
+}
+
+export default REFERENCES;
+
+export const ARTICLES_2026: Content[] = [
+  REFERENCES.THE_METAVERSE_BUILDING_THE_SPATIAL_INTERNET,
+  REFERENCES.THE_DECOMPILATION_WIKI,
+  REFERENCES.DECOMPILING_2024_A_YEAR_OF_RESURGENCE_IN_DECOMPILATION_RESEARCH,
+  REFERENCES._30_YEARS_OF_DECOMPILATION_AND_THE_UNSOLVED_STRUCTURING_PROBLEM_PART_1,
+  REFERENCES._30_YEARS_OF_DECOMPILATION_AND_THE_UNSOLVED_STRUCTURING_PROBLEM_PART_2,
+  REFERENCES.FFMPEG_THE_INCREDIBLE_TECHNOLOGY_BEHIND_VIDEO_ON_THE_INTERNET_496,
+  REFERENCES.CREATOR_OF_CPP_BELL_LABS_NEGATIVE_OVERHEAD_ABSTRACTION_MISTAKES_BJARNE_STROUSTRUP,
+  REFERENCES.THE_MAGIC_OF_ARM_W_CASEY_MURATORI,
+  REFERENCES.X86_NEEDS_TO_DIE,
+  REFERENCES.THE_REAL_PROBLEMS_W_GIT,
+  REFERENCES.THE_ONLY_UNBREAKABLE_LAW,
+
+  REFERENCES.AN_INFINITY_OF_WORLDS_COSMIC_INFLATION_AND_THE_BEGINNING_OF_THE_UNIVERSE,
+  REFERENCES.STATE_OF_AI_IN_2026_LLMS_CODING_SCALING_LAWS_CHINA_AGENTS_GPUS_AGI_490,
+  REFERENCES.OPENCLAW_THE_VIRAL_AI_AGENT_THAT_BROKE_THE_INTERNET___PETER_STEINBERGER_491,
+  REFERENCES.JEFF_KAPLAN_WORLD_OF_WARCRAFT_OVERWATCH_BLIZZARD_AND_FUTURE_OF_GAMING_493,
+  REFERENCES.JENSEN_HUANG_NVIDIA___THE_4_TRILLION_COMPANY_THE_AI_REVOLUTION_494,
+  REFERENCES.VIKINGS_RAGNAR_BERSERKERS_VALHALLA_THE_WARRIORS_OF_THE_VIKING_AGE_495,
+  REFERENCES._31_JOSHUA_WINN___EXOPLANET_NEW_DISCOVERIES_HISTORY_AND_FUTURE,
+  REFERENCES._32_CHRIS_LINTOTT___TECHNOSIGNATURES_CITIZEN_SCIENCE_SCICOMM,
+  REFERENCES.DAN_GHICA_DESIGNING_AND_DEVELOPING_AN_INDUSTRIAL_STRENGTH_PROGRAMMING_LANGUAGE,
+  REFERENCES.WHERE_WE_RE_GOING_WE_DON_T_NEED_ROWS_COLUMNAR_DATA_CONNECTIVITY_WITH_APACHE_ARROW_ADBC,
+  REFERENCES.VORTEX_LLVM_FOR_FILE_FORMATS,
+  REFERENCES.DUCKLAKE_LEARNING_FROM_CLOUD_DATA_WAREHOUSES_TO_BUILD_A_ROBUST_LAKEHOUSE,
+  REFERENCES.AN_EXTREMELY_TECHNICAL_OVERVIEW_OF_HOW_APACHE_ICEBERG_PLANNING_ACTUALLY_WORKS,
+
+  REFERENCES.THE_STRANGEST_MAN,
+  REFERENCES.ECCE_HOMO,
+  REFERENCES.THE_THREE_BODY_PROBLEM,
+  REFERENCES.SHIFT,
+  REFERENCES.PAUL_ROSOLIE_UNCONTACTED_TRIBES_IN_THE_AMAZON_JUNGLE_489,
+]
+
+export const ARTICLES_2025: Content[] = [
+  REFERENCES.WOOL,
+  REFERENCES.HARRY_POTTER_1_7,
+  REFERENCES.PROPOSITIONS_AS_TYPES,
+  REFERENCES.PROGRAMMING_DISTRIBUTED_SYSTEMS,
+  REFERENCES.DAN_HOUSER_GTA_RED_DEAD_REDEMPTION_ROCKSTAR_ABSURD_FUTURE_OF_GAMING_484,
+  REFERENCES.DECIPHERING_SECRETS_OF_ANCIENT_CIVILIZATIONS_NOAHS_ARK_AND_FLOOD_MYTHS_487,
+  REFERENCES.PAVEL_DUROV_TELEGRAM_FREEDOM_CENSORSHIP_MONEY_POWER_HUMAN_NATURE_482,
+  REFERENCES.DAVID_KIRTLEY_NUCLEAR_FUSION_PLASMA_PHYSICS_AND_THE_FUTURE_OF_ENERGY_485,
+  REFERENCES.INFINITY_PARADOXES_GÖDEL_INCOMPLETENESS_THE_MATHEMATICAL_MULTIVERSE_488,
+  REFERENCES._26_WILL_KINNEY___BEFORE_THE_BIG_BANG_INFLATION_INFINITY_OF_WORLDS,
+  REFERENCES._27_JASON_STEFFEN___KEPLER_MISSION_LEGACY_PARTICLE_PHYSICS_OPTIMAL_PLANE_BOARDING,
+  REFERENCES._28_NÉSTOR_ESPINOZA___JWST_EXOPLANET_ATMOSPHERES_MOLECULE_DETECTION,
+
+  REFERENCES.CRAFTING_INTERPRETERS,
+  REFERENCES.FUNCTIONAL_PROGRAMMING_IN_LEAN,
+  REFERENCES.REFLECTIONS_ON_EQUALITY,
+  REFERENCES.CUBICAL_TYPE_THEORY,
+  REFERENCES.ABSTRACT_INTERPRETATION_IN_A_NUTSHELL,
+  REFERENCES.ABSTRACT_INTERPRETATION_A_UNIFIED_LATTICE_MODEL_FOR_STATIC_ANALYSIS_OF_PROGRAMS_BY_CONSTRUCTION_OR_APPROXIMATION_OF_FIXPOINTS,
+  REFERENCES.LEVIATHAN_WAKES,
+  REFERENCES.CUBICAL_TYPES_FOR_THE_WORKING_FORMALIZER,
+  REFERENCES.EASY_ABSTRACT_INTERPRETATION_WITH_SPARTA,
+  REFERENCES.A_LITTLE_TASTE_OF_DEPENDENT_TYPES,
+  REFERENCES._24___MODERN_COSMOLOGY_HUBBLE_TENSION_EXOTIC_PHYSICS,
+  REFERENCES._25___PBS_SPACETIME_SCIENCE_ON_YOUTUBE_QUASARS,
+  REFERENCES.DAVE_PLUMMER_PROGRAMMING_AUTISM_AND_OLD_SCHOOL_MICROSOFT_STORIES_479,
+  REFERENCES.DAVE_HONE_T_REX_DINOSAURS_EXTINCTION_EVOLUTION_AND_JURASSIC_PARK_480,
+  REFERENCES.TIM_SWEENEY_FORTNITE_UNREAL_ENGINE_AND_THE_FUTURE_OF_GAMING_467,
+  REFERENCES.QUANTUM_THEORY_AS_A_NEW_KIND_OF_STOCHASTIC_PROCESS,
+  REFERENCES.KEYNOTE_HIGHER_INDUCTIVE_TYPES_IN_HOMOTOPY_TYPE_THEORY,
+  REFERENCES.THE_VERSE_PROGRAMMING_LANGUAGE_GDC_2023,
+
+  REFERENCES.READY_PLAYER_ONE,
+  REFERENCES.READY_PLAYER_TWO,
+  REFERENCES.MSP_101_GENERALISATION_IN_LLMS_PETAR_VELIČKOVIĆ,
+  REFERENCES.SUNDAR_PICHAI_CEO_OF_GOOGLE_AND_ALPHABET_471,
+  REFERENCES.TERENCE_TAO_HARDEST_PROBLEMS_IN_MATHEMATICS_PHYSICS_THE_FUTURE_OF_AI_472,
+  REFERENCES.DHH_FUTURE_OF_PROGRAMMING_AI_RUBY_ON_RAILS_PRODUCTIVITY_PARENTING_474,
+  REFERENCES.DEMIS_HASSABIS_FUTURE_OF_AI_SIMULATING_REALITY_PHYSICS_AND_VIDEO_GAMES_475,
+  REFERENCES.MINDSCAPE_323_JACOB_BARANDES_ON_INDIVISIBLE_STOCHASTIC_QUANTUM_MECHANICS,
+  REFERENCES._23___FINE_TUNING_MULTIVERSE_COSMOLOGICAL_TENSIONS,
+
+  REFERENCES.STRING_DIAGRAM_REWRITE_THEORY_III_CONFLUENCE_WITH_AND_WITHOUT_FROBENIUS,
+  REFERENCES.INFLUENCE_OF_TEMPORAL_INFORMATION_GAPS_ON_DECISION_MAKING_DESCRIBING_THE_DYNAMICS_OF_WORKING_MEMORY,
+  REFERENCES.BLACK_HOLES_WORMHOLES_ALIENS_PARADOXES_EXTRA_DIMENSIONS_468,
+  REFERENCES._19___INFLATION_B_MODES_AND_LOSING_THE_NOBEL_PRIZE,
+  REFERENCES._20___KEPLER_MISSION_EXOPLANETS_WITH_JWST_FUTURE_IMAGERS,
+  REFERENCES._21___EARLY_MARS_TERRAFORMINGSETTLING_MARS,
+  REFERENCES._22___ORIGIN_OF_LIFE_ASSEMBLY_THEORY_BIOSIGNATURES,
+  REFERENCES.RULES_THAT_REALITY_PLAYS_BY___343,
+  REFERENCES.MISTAKING_THE_MAP_FOR_THE_TERRITORY_IN_PHYSICS___344,
+
+  REFERENCES.THE_EQUIVALENCE_BETWEEN_GEOMETRICAL_STRUCTURES_AND_ENTROPY,
+  REFERENCES.DEEPSEEK_CHINA_OPENAI_NVIDIA_XAI_TSMC_STARGATE_AND_AI_MEGACLUSTERS_459,
+  REFERENCES.WHY_PHYSICS_WITHOUT_PHILOSOPHY_IS_DEEPLY_BROKEN_PART_2,
+  REFERENCES.HARVARD_SCIENTIST_THERE_IS_NO_QUANTUM_MULTIVERSE_PART_3,
+  REFERENCES.HARVARD_PHYSICIST_DEBUNKS_PARTICLE_SUPERPOSITION,
+  REFERENCES.TOP_AI_SCIENTIST_UNIFIES_WOLFRAM_LEIBNIZ_CONSCIOUSNESS,
+  REFERENCES.THE_THEORY_THAT_EXPLAINS_YOU_FREE_ENERGY_PRINCIPLE,
+
+  REFERENCES.EINSTEIN_HIS_LIFE_AND_UNIVERSE,
+  REFERENCES.THE_FUTURE_OF_BRAIN_EMULATION_IS_LOOKING_SPIKY,
+  REFERENCES.WHY_THE_GODFATHER_OF_AI_NOW_FEARS_HIS_OWN_CREATION,
+  REFERENCES.THE_MAJOR_FLAWS_IN_FUNDAMENTAL_PHYSICS,
+  REFERENCES.THE_CRISIS_IN_STRING_THEORY_IS_WORSE_THAN_YOU_THINK,
+  REFERENCES.MATH_HAS_CHANGED_FOREVER
+]
+
+export const ARTICLES_2024: Content[] = [
+  REFERENCES.APPLIED_CATEGORY_THEORY_IN_CHEMISTRY_COMPUTING_AND_SOCIAL_NETWORKS,
+  REFERENCES.UNIQUENESS_TREES_A_POSSIBLE_POLYNOMIAL_APPROACH_TO_THE_GRAPH_ISOMORPHISM_PROBLEM,
+  REFERENCES.ALIEN_CIVILIZATIONS_AND_THE_SEARCH_FOR_EXTRATERRESTRIAL_LIFE_LEX_FRIDMAN_PODCAST_455,
+  REFERENCES.THERES_NO_WAVE_FUNCTION,
+  REFERENCES.THE_POTENTIAL_OF_THE_HUMAN_BRAIN,
+  REFERENCES.THE_UNIVERSE_WRITES_ITSELF_INTO_EXISTENCE_MOMENT_BY_MOMENT,
+
+  REFERENCES.HUNTERS_OF_DUNE,
+  REFERENCES.THE_LITTLE_BOOK_OF_DEEP_LEARNING,
+  REFERENCES.PREFACE_WHAT_IS_OPENGL,
+  REFERENCES.FOUNDATIONS_OF_BIDIRECTIONAL_PROGRAMMING_I_WELL_TYPED_SUBSTRUCTURAL_LANGUAGES,
+  REFERENCES.FOUNDATIONS_OF_BIDIRECTIONAL_PROGRAMMING_II_NEGATIVE_TYPES,
+  REFERENCES.THE_YOGA_OF_CONTEXTS_I,
+  REFERENCES.WHY_DOES_BIOLOGICAL_EVOLUTION_WORK_A_MINIMAL_MODEL_FOR_BIOLOGICAL_EVOLUTION_AND_OTHER_ADAPTIVE_PROCESSES,
+  REFERENCES._20TH_CENTURY_S_GREATEST_LIVING_SCIENTIST_SIR_ROGER_PENROSE,
+  REFERENCES.THE_QUANTUM_HERETIC_A_NEW_THEORY_OF_EVERYTHING,
+  REFERENCES.MAYA_AZTEC_INCA_AND_LOST_CIVILIZATIONS_OF_SOUTH_AMERICA_LEX_FRIDMAN_PODCAST_446,
+  REFERENCES.THE_ROMAN_EMPIRE___RISE_AND_FALL_OF_ANCIENT_ROME_LEX_FRIDMAN_PODCAST_443,
+  REFERENCES.MINDSCAPE_289_THE_NEXT_GENERATION_OF_PARTICLE_EXPERIMENTS,
+  REFERENCES.MINDSCAPE_291_THE_BIOLOGY_OF_DEATH_AND_AGING,
+  REFERENCES.MATHS_OF_QUANTUM_MECHANICS,
+
+  REFERENCES.COMPUTING_MACHINERY_AND_INTELLIGENCE,
+  REFERENCES.VON_NEUMANN_AND_LATTICE_THEORY,
+  REFERENCES.WHEN_EXACTLY_WILL_THE_ECLIPSE_HAPPEN_A_MULTIMILLENNIUM_TALE_OF_COMPUTATION,
+  REFERENCES.ARE_ALL_FISH_THE_SAME_SHAPE_IF_YOU_STRETCH_THEM_THE_VICTORIAN_TALE_OF_ON_GROWTH_AND_FORM,
+  REFERENCES.WHATS_REALLY_GOING_ON_IN_MACHINE_LEARNING_SOME_MINIMAL_MODELS,
+  REFERENCES.THE_HYDROGEN_ATOM_INTRO_TO_QUANTUM,
+  REFERENCES.MINDSCAPE_287_INSTITUTIONS_AND_THE_LEGACY_OF,
+  REFERENCES.LIVE_SCIENCE_SPINAL_GRAPHS_HYPERGRAPH_CONFLUENCE_SYMMETRY_AND,
+  REFERENCES.LIVE_SCIENCE_INFRAGEOMETRY_CORRESPONDENCES_DIFFERENTIAL_GEOMETRY_HYPERGRAPH,
+  REFERENCES.LIVE_SCIENCE_QUANTUM_PARADOXES_DELAYED_CHOICE_QUANTUM_ERASER_CHSH_GAME,
+  REFERENCES.CONSCIOUSNESS_BIOLOGY_UNIVERSAL_MIND_EMERGENCE_CANCER,
+  REFERENCES.THE_CRISIS_IN_FUNDAMENTAL_PHYSICS_IS_WORSE_THAN_YOU,
+  REFERENCES.NEURALINK_AND_THE_FUTURE_OF_HUMANITY_LEX_FRIDMAN_PODCAST,
+  REFERENCES.PHYSICS_OF_LIFE_TIME_COMPLEXITY_AND_ALIENS_LEX_FRIDMAN_PODCAST,
+
+  REFERENCES.PLURALISTIC_THE_DISENSHITTIFIED_INTERNET_STARTS_WITH_LOYAL_USER_AGENTS,
+  REFERENCES.ELON_MUSK,
+  REFERENCES.FUN_RAISING_FUNDING_SCHOOL_QA_SEMF,
+  REFERENCES.HUMAN_MEMORY_IMAGINATION_DEJA_VU_AND_FALSE_MEMORIES_LEX_FRIDMAN_PODCAST,
+  REFERENCES.JUNGLE_APEX_PREDATORS_ALIENS_UNCONTACTED_TRIBES_AND_GOD_LEX_FRIDMAN_PODCAST,
+  REFERENCES.LONGEVITY_MEDITATION_PHILOSOPHIES_CONSCIOUSNESS_NATURE_OF,
+
+  REFERENCES.REVERSE_ENGINEERING_SAME_THING_WE_DO_EVERY_WEEKEND_DOCUMENTING_THE_AMD_7900XTX_PART2,
+  REFERENCES.RESEARCHING_DOCUMENTING_THE_AMD_7900XTX_SO_WE_CAN_UNDERSTAND_WHY_IT_CRASHES_RDNA_3,
+  REFERENCES.WHAT_MAKES_HIGH_DIMENSIONAL_NETWORKS_PRODUCE_LOW_DIM_ACTIVITY,
+  REFERENCES.LISA_RANDALL_DARK_MATTER_THEORETICAL_PHYSICS_AND_EXTINCTION_EVENTS_LEX_FRIDMAN_PODCAST_403,
+  REFERENCES.REALITY_IS_A_PARADOX___MATHEMATICS_PHYSICS_TRUTH_LOVE_LEX_FRIDMAN_PODCAST_370,
+  REFERENCES.THE_LANGLANDS_PROGRAM___NUMBERPHILE,
+  REFERENCES.TIME_AND_QUANTUM_MECHANICS_SOLVED_LEE_SMOLIN,
+  REFERENCES.EDWARD_FRENKEL_INFINITY_AI_STRING_THEORY_DEATH_THE_SELF,
+  REFERENCES.LIVE_SCIENCE_INFRAGEOMETRY_CORE_DEFINITIONS_DIFFERENTIAL_GEOMETRY_TANGENT_BUNDLES_FUNCTIONS,
+  REFERENCES.LIVE_SCIENCE_INFRAGEOMETRY_WORKING_SESSION_FUNCTIONS_EDGES_PLACES_BIPARTITE_GRAPHS,
+  REFERENCES.FELLOW_FOCUS_RICHARD_ASSAR_METAMETAVERSE_ALIEN_MINDS_MACHINE_LEARNING_CELLULAR_AUTOMATA,
+  REFERENCES.FELLOW_FOCUS_NIK_MURZIN_QUANTUM_FRAMEWORK,
+  REFERENCES.EXPLORE_LEARN_THE_MAP_OF_INSTITUTE_RESEARCH_QUANTUM_PROBABILITIES_MULTICOMPUTATION_CAUSALITY,
+  REFERENCES.EXPLORE_LEARN_THE_MAP_OF_INSTITUTE_RESEARCH_MULTICOMPUTATION_INFRAGEOMETRY_RULIAD,
+  REFERENCES.EXPLORE_LEARN_FUNDAMENTALS_WHATS_HYPE_ABOUT_HYPERGRAPHS_GRAPH_THEORY_HYPERMATRIX_ARITY,
+  REFERENCES.MINDSCAPE_274_GIZEM_GUMUSKAYA_ON_BUILDING_ROBOTS_FROM_HUMAN_CELLS,
+  REFERENCES.COMMUNITY_LIVESTREAM_DATA_DIMENSIONALITY,
+  REFERENCES.ALL_IN_PODCAST_E173,
+  REFERENCES.ALL_IN_PODCAST_E174,
+  REFERENCES.ALL_IN_PODCAST_E175,
+  REFERENCES.ALL_IN_PODCAST_E176,
+
+  REFERENCES.CALCULUS_RATIOCINATOR_VS_CHARACTERISTICA_UNIVERSALIS_THE_TWO_TRADITIONS_IN_LOGIC_REVISITED,
+  REFERENCES.CARGO_CULT_SCIENCE,
+  REFERENCES.MILLIONS_OF_CHILDREN_LEARN_ONLY_VERY_LITTLE_HOW_CAN_THE_WORLD_PROVIDE_A_BETTER_EDUCATION_TO_THE_NEXT_GENERATION,
+  REFERENCES.STRIPES_2023_ANNUAL_LETTER,
+  REFERENCES.PLAYING_VALUING_AND_LIVING_EXAMINING_NIETZSCHES_PLAYFUL_RESPONSE_TO_NIHILISM,
+  REFERENCES.THE_BUILD_YOUR_OWN_OPEN_GAMES_ENGINE_BOOTCAMP_PART_I_LENSES,
+  REFERENCES.CAN_AI_SOLVE_SCIENCE,
+  REFERENCES.COMMUNITY_LIVESTREAM_BIOELECTRICITY,
+  REFERENCES.QUANTUM_GRAVITY_WOLFRAM_PHYSICS_PROJECT,
+  REFERENCES.PARADIGM_SHIFT_GHOST_PARTICLES_CONSTRUCTOR_THEORY,
+  REFERENCES.THE_STRING_THEORY_ICEBERG_EXPLAINED,
+  REFERENCES.EXPLORING_SNIFFING_NVIDIAS_IOCTLS_OPEN_GPU_KERNEL_MODULES_DEBUG_PTX_CUDA,
+  REFERENCES.PROGRAMMING_WRITING_A_FUZZER_AND_NOT_GETTING_TRIGGERED_WHEN_THE_AMD_GPU_CRASHES_UMR,
+  REFERENCES.PROGRAMMING_RIPPING_OUT_ALL_OF_AMDS_USERSPACE_AMDGPU_IOCTLS_GPU_MEMORY_HSA_KFD,
+  REFERENCES.ALL_IN_PODCAST_E169,
+  REFERENCES.ALL_IN_PODCAST_E170,
+  REFERENCES.ALL_IN_PODCAST_E171,
+  REFERENCES.ALL_IN_PODCAST_E172,
+  REFERENCES.SHANNON_LUMINARY_LECTURE_SERIES___STEPHEN_FRY,
+  REFERENCES.CONTAINERS_FOR_COMPILER_ARCHITECTURE,
+  REFERENCES.WHY_IT_WAS_ALMOST_IMPOSSIBLE_TO_MAKE_THE_BLUE_LED,
+  REFERENCES.COMPOSITIONAL_GAME_THEORY_TOWARDS_INCENTIVES_MODELLING_AT_SCALE,
+  REFERENCES.MINDSCAPE_268_MATT_STRASSLER_ON_RELATIVITY_FIELDS_AND_THE_LANGUAGE_OF_REALITY,
+  REFERENCES.ACTINF_MATHSTREAM_0091_JONATHAN_GORARD_A_COMPUTATIONAL_PERSPECTIVE_ON_OBSERVATION_AND_COGNITION,
+  REFERENCES.A_CONVERSATION_WITH_MARK_ZUCKERBERG_PATRICK_COLLISON_AND_TYLER_COWEN,
+
+  REFERENCES.SOLVING_SAT_VIA_POSITIVE_SUPERCOMPILATION,
+  REFERENCES.NAVIGATING_COGNITION_SPATIAL_CODES_FOR_HUMAN_THINKING,
+  REFERENCES.TOWARDS_A_STRUCTURAL_TURN_IN_CONSCIOUSNESS_SCIENCE,
+  REFERENCES.THE_GLASS_BEAD_GAME,
+  REFERENCES.AN_INTRODUCTION_TO_HIGHER_ARITY_SCIENCE,
+  REFERENCES.HISTORY_OF_SCIENCE_AND_TECHNOLOGY_QA_FEBRUARY_28,
+  REFERENCES.GRETA_SEMINAR_HIGHER_ARITY_ALGEBRA_VIA_HYPERGRAPH_REWRITING,
+  REFERENCES.WORKSHOP_AXIOMATIC_CREATION,
+  REFERENCES.COMMUNITY_LIVESTREAM_AXIOMS_CREATIVITY,
+  REFERENCES.CONCEPT_COLLIDER_GEOMETRY_OF_DATA_AND_NEURAL_CORRELATES,
+  REFERENCES.WOLFRAM_PHYSICS_PROJECT_WORKING_SESSION___CAUSAL_MULTIWAY_SYSTEMS,
+  REFERENCES.SCIENCE_RESEARCH_SESSION_HYPORULIAD,
+  REFERENCES.A_CONVERSATION_BETWEEN_BOB_COECKE_AND_STEPHEN_WOLFRAM,
+  REFERENCES.STEVE_JOBS,
+  REFERENCES.JOHN_CLEESE_ON_CREATIVITY_IN_MANAGEMENT,
+  REFERENCES.THE_TRILLION_DOLLAR_EQUATION,
+  REFERENCES.STEVE_JOBS_PRESIDENT_CEO_NEXT_COMPUTER_CORP_AND_APPLE_MIT_SLOAN_DISTINGUISHED_SPEAKER_SERIES,
+  REFERENCES.CARL_SAGAN_AT_MIT___MANAGEMENT_IN_THE_YEAR_2000_SLOAN_SCHOOL_SYMPOSIUM,
+  REFERENCES.CHAMATH_PALIHAPITIYA_SOCIALCAPITAL_STARTUP_GRIND,
+  REFERENCES.CHAMATH_PALIHAPITIYA_SPEAKING_AT_WATERLOO_INNOVATION_SUMMIT,
+  REFERENCES.ALL_IN_PODCAST_E165,
+  REFERENCES.ALL_IN_PODCAST_E164,
+  REFERENCES.CONCEPT_COLLIDER_MATHEMATICAL_PHYSICS_ACTIVE_INFERENCE_FREE_ENERGY_ENTROPY,
+  REFERENCES.CRDTS_GO_BRRR,
+  REFERENCES.THIS_WEEKS_FINDS_18_CATEGORIFYING_THE_QUANTUM_HARMONIC_OSCILLATOR,
+  REFERENCES.WOLFRAM_PHYSICS_PROJECT_WORKING_SESSION_QUANTUM_BLACK_HOLES_AND_OTHER_THINGS,
+  REFERENCES.CAUSAL_INVARIANCE_VERSUS_CONFLUENCE,
+  REFERENCES.CRDTS_THE_HARD_PARTS,
+  REFERENCES.RIAK_DYNAMO_FIVE_YEARS_LATER_PRESENTED,
+  REFERENCES.RIAK_CORE___AN_ERLANG_DISTRIBUTED_SYSTEMS_TOOLKIT,
+  REFERENCES.ZXLIVE___AN_INTERACTIVE_GUI_FOR_THE_ZX_CALCULUS___RAZIN_A_SHAIKH,
+  REFERENCES.GRAPHICAL_CSS_CODE_TRANSFORMATION_USING_ZX_CALCULUS,
+  REFERENCES.THE_ZETA_CALCULUS,
+  REFERENCES.HOW_TO_TAKE_THE_FACTORIAL_OF_ANY_NUMBER,
+  REFERENCES.JEFF_BEZOS_AMAZON_AND_BLUE_ORIGIN_LEX_FRIDMAN_PODCAST_405,
+  REFERENCES.HR_TALK_INTRO_TO_LARGE_LANGUAGE_MODELS,
+  REFERENCES.STREAM_0_WHY_ALL_VIDEO_GAME_PROGRAMMERS_SHOULD_LEARN_GEOMETRIC_ALGEBRA,
+  REFERENCES.THE_PERIODIC_TABLE_OF_GEOMETRIC_ALGEBRAS___CL301_DOES_ALL_3D_GAME_MATH_SO_WHAT_DOES_CLPQR_D,
+  REFERENCES.GEOMETRIC_ALGEBRA_AS_A_TOOL_IN_TECHNICAL_COMMUNICATION,
+  REFERENCES.MINDSCAPE_260_RICARD_SOLE_ON_THE_SPACE_OF_COGNITIONS,
+  REFERENCES.MINDSCAPE_261_SANJANA_CURTIS_ON_THE_ORIGINS_OF_THE_ELEMENTS,
+  REFERENCES.MINDSCAPE_264_SABINE_STANLEY_ON_WHATS_INSIDE_PLANETS,
+  REFERENCES.MINDSCAPE_263_CHRIS_QUIGG_ON_SYMMETRY_AND_THE_BIRTH_OF_THE_STANDARD_MODEL,
+  REFERENCES.MINDSCAPE_262_ERIC_SCHWITZGEBEL_ON_THE_WEIRDNESS_OF_THE_WORLD,
+  REFERENCES.JUST_CHATTING_TECHNO_OPTIMISM_WINNING_OVER_NATURE_PROGRESSIVE_ACCELERATION,
+  REFERENCES.PROGRAMMING_DECISION_TRANSFORMER_REINFORCEMENT_LEARNING_RL_LUNARLANDER_PART_1,
+  REFERENCES.PROGRAMMING_RL_IS_DUMB_AND_DOESNT_WORK_REINFORCEMENT_LEARNING_LUNARLANDER_PART_2,
+  REFERENCES.RESEARCHING_RL_IS_DUMB_AND_DOESNT_WORK_THEORY_REINFORCEMENT_LEARNING_PART_3,
+  REFERENCES.RESEARCHING_MULTIGPU_WITH_HIP_OR_MAYBE_WITHOUT_HIP_HSA_HIP_GRAPH_PART_1,
+  REFERENCES.PROGRAMMING_MULTIGPU_WITH_HIP_OR_MAYBE_WITHOUT_HIP_HSA_DISABLE_CACHE1_PART_2
+]
+
+
+export const ARTICLES_2023: Content[] = [
+  REFERENCES.STRING_DIAGRAM_REWRITE_THEORY_II_REWRITING_WITH_SYMMETRIC_MONOIDAL_STRUCTURE,
+  REFERENCES.CHYP_COMPOSING_HYPERGRAPHS_PROVING_THEOREMS,
+  REFERENCES.OBSERVER_THEORY,
+  REFERENCES.WASM_SPECTEC_ENGINEERING_A_FORMAL_LANGUAGE_STANDARD,
+  REFERENCES.MINDSCAPE_259_ADAM_FRANK_ON_WHAT_ALIENS_MIGHT_BE_LIKE,
+  REFERENCES.ANIMATION_VS_PHYSICS,
+  REFERENCES.WHY_LIGHT_CAN_SLOW_DOWN_AND_WHY_IT_DEPENDS_ON_COLOR_OPTICS_PUZZLES,
+  REFERENCES.LEE_CRONIN_CONTROVERSIAL_NATURE_PAPER_ON_EVOLUTION_OF_LIFE_AND_UNIVERSE_LEX_FRIDMAN_PODCAST_404,
+  REFERENCES.BERKELEY_SEMINAR_DAVID_JAZ_MYERS_872023,
+  REFERENCES.YUGOSLAVIAS_DIGITAL_TWIN,
+  REFERENCES.PHYSICS_EXPLAINS_WHY_THERE_IS_NO_INFORMATION_ON_SOCIAL_MEDIA,
+  REFERENCES.HOW_TO_ASK_QUESTIONS_THE_SMART_WAY,
+  REFERENCES.COMPLEXITY_MATHEMATICS_COMMUNITY_LIVESTREAM,
+  REFERENCES.HOLIDAY_SPECIAL_LIVESTREAM,
+  REFERENCES.JUST_CHATTING_TESLA_AI_DAY_2022_SCIENCE_TECHNOLOGY,
+  REFERENCES.PROGRAMMING_MISTRAL_MIXTRAL_ON_A_TINYBOX_AMD_P2P_MULTI_GPU_MIXTRAL_8X7B_32KSEQLEN,
+  REFERENCES.PROGRAMMING_WHAT_IS_THE_Q_ALGORITHM_OPENAI_Q_STAR_ALGORITHM_MISTRAL_7B_PRM800K,
+  REFERENCES.JUST_CHATTING_EFFECTIVE_ACCELERATIONISM_EACC_TECHNO_PESSIMISM_DECELERATION,
+  REFERENCES.SCIENCE_THERMODYNAMICS_IS_TO_ENERGY_AS_IS_TO_INTELLIGENCE,
+  REFERENCES.SCIENCE_THERMODYNAMICS_IS_TO_ENERGY_AS_ENTROPICS_IS_TO_INTELLIGENCE_PART_2,
+  REFERENCES.PROGRAMMING_A_TINY_TOUR_THROUGH_TINYGRAD_NOOB_LESSON,
+  REFERENCES.PROGRAMMING_TINYGRAD_WRITING_TUTORIALS_FOR_NOOBS,
+  REFERENCES.RANT_COMPLAINING_ABOUT_HOW_TERRIBLE_QUALCOMM_IS_THE_BUSINESS_WORLD,
+  REFERENCES.CHATTING_CHALLENGES_HIRING_PEOPLE_VISION_BUILDING_A_COMPANY_TINY_CORP_TINYGRADORG,
+  REFERENCES.READING_TALKING_LETS_READ_ML_PAPERS,
+
+  REFERENCES.STRING_DIAGRAM_REWRITE_THEORY_I,
+  REFERENCES.REPTAR,
+  REFERENCES.AGGREGATION_AND_TILING_AS_MULTICOMPUTATIONAL_PROCESSES,
+  REFERENCES.PHYSICS_AND_ECONOMICS_SEMF_COMMUNITY_LIVESTREAM,
+  REFERENCES.WOLFRAM_INSTITUTES_INFRAGEOMETRY_LIVESTREAMS,
+  REFERENCES.HYPERMATRIX_WORKSHOP,
+  REFERENCES.WOLFRAM_PHYSICS_PROJECT_RELATIONS_TO_CATEGORY_THEORY,
+  REFERENCES.ALL_CONCEPTS_ARE_CAT_SHARP,
+  REFERENCES.HIGHER_CATEGORY_THEORY_IN_CAT_SHARP,
+  REFERENCES.ABSTRACTION_ENGINEERING_WITH_THE_PVS,
+  REFERENCES.CAUSAL_VS_ACAUSAL_MODELING_BY_EXAMPLE,
+  REFERENCES.RP_159,
+  REFERENCES.RP_118,
+  REFERENCES.MINDSCAPE_256,
+  REFERENCES.THIS_WEEKS_FINDS_15,
+  REFERENCES.THIS_WEEKS_FINDS_14,
+  REFERENCES.SCALES_AND_SCIENCE_FICTION_WITH_BIOLOGIST_MICHAEL_LEVIN,
+  REFERENCES.DELIMITED_CONTINUATIONS_FOR_EVERYONE,
+  REFERENCES.HOMOTOPY_TYPE_THEORY_101,
+  REFERENCES.FROM_CATEGORICAL_SYSTEMS_THEORY_TO_CATEGORICAL_CYBERNETICS,
+  REFERENCES.THE_SEARCH_FOR_THE_PERFECT_DOOR,
+  REFERENCES.EVOLVING_BRAINS_SOLID_LIQUID_AND_SYNTHETIC,
+
+  REFERENCES.ZENBLEED,
+  REFERENCES.DOWNFALL,
+  REFERENCES.ASSEMBLY_THEORY_EXPLAINS_AND_QUANTIFIES_SELECTION_AND_EVOLUTION,
+  REFERENCES.INSIDE_THE_WIZARD_RESEARCH_ENGINE,
+  REFERENCES.IPVM_SEAMLESS_SERVICES_FOR_AN_OPEN_WORLD,
+  REFERENCES.WHY_PROGRAMMING_LANGUAGES_MATTER,
+  REFERENCES.WE_REALLY_DONT_KNOW_HOW_TO_COMPUTE,
+  REFERENCES.FROM_GEOMETRY_TO_ALGEBRA_AND_BACK_AGAIN_4000_YEARS_OF_PAPERS,
+  REFERENCES.WAR_TIME_PROOFS_AND_FUTURISTIC_PROGRAMS,
+  REFERENCES.THE_ECONOMICS_OF_PROGRAMMING_LANGUAGES,
+  REFERENCES.AN_APPROACH_TO_COMPUTING_AND_SUSTAINABILITY_INSPIRED_FROM_PERMACULTURE,
+  REFERENCES.COMPUTATIONAL_PHSYICS_BEYOND_THE_GLASS,
+  REFERENCES.CURSORLESS_A_SPOKEN_LANGUAGE_FOR_EDITING_CODE,
+
+  REFERENCES.YASP_EPISODE_2,
+  REFERENCES.MODERNIZING_COMPILER_DESIGN_FOR_CARBON_TOOLCHAIN,
+  REFERENCES.COMPOSITIONAL_INTELLIGENCE,
+  REFERENCES.MLST_OBSERVERS,
+  REFERENCES.HIGHER_ORDER_COMPANY_ORIGINS_OF_THE_HVM,
+  REFERENCES.THE_DISCOVER_OF_ZENBLEED,
+  REFERENCES.THE_RING_0_FACADE_AWAKENING_THE_PROCESSORS_INNER_DEMONS,
+  REFERENCES.REDUCTIO_AD_ABSURDUM,
+  REFERENCES.BREAKING_THE_X86_INSTRUCTION_SET,
+  REFERENCES.PAST_PRESENT_AND_FUTURE_OF_MATHEMATICS,
+  REFERENCES.MINDSCAPE_253,
+  REFERENCES.CRITICAL_THINKING_1,
+
+  REFERENCES.THE_ORIGINS_AND_MOTIVATIONS_OF_UNIVALENT_FOUNDATIONS,
+  REFERENCES.THE_END_OF_THE_ALEXANDRIA_PROJECT,
+  REFERENCES.WHEN_IS_A_COMPUTER_PROOF_A_PROOF,
+  REFERENCES.THE_ALEXANDRIA_PROJECT_WHAT_HAS_BEEN_ACCOMPLISHED,
+  REFERENCES.ALEXANDRIA_LARGE_SCALE_FORMAL_PROOF_FOR_THE_WORKING_MATHEMATICIAN,
+  REFERENCES.REMEMBERING_DOUG_LENAT,
+
+  REFERENCES.CATEGORY_THEORY_I,
+  REFERENCES.CATEGORY_THEORY_II,
+  REFERENCES.CATEGORY_THEORY_III,
+  REFERENCES.HACKENBUSH_A_WINDOW_TO_A_NEW_WORLD_OF_MATH,
+  REFERENCES.DIHEAPS_A_NEW_SPECIES_OF_ALGEBRAIC_STRUCTURE,
+  REFERENCES.QUANTUM_IN_PICTURES,
+  REFERENCES.REMEMBERING_THE_IMPROBABLE_LIFE_OF_ED_FREDKIN,
+  REFERENCES.WILL_COMPUTERS_REDEFINE_THE_ROOTS_OF_MATH,
+  REFERENCES.A_FUNCTORIAL_PERSPECTIVE_ON_MULTICOMPUTATIONAL_IRREDUCIBILITY,
+  REFERENCES.RESIDUALITY_THEORY_RANDOM_SIMULATION_AND_ATTRACTOR_NETWORKS,
+  REFERENCES.BIOELECTRIC_NETWORKS_THE_COGNITIVE_GLUE_ENABLING_EVOLUTIONARY_SCALING_FROM_PHYSIOLOGY_TO_MIND,
+  REFERENCES.COMPETENCY_IN_NAVIGATING_ARBITRARY_SPACES_AS_AN_INVARIANT_FOR_ANALYZING_COGNITION_IN_DIVERSE_EMBODIMENTS,
+  REFERENCES.CHROME_SHIPS_WEBGPU,
+  REFERENCES.GET_STARTED_WITH_GPU_COMPUTE_ON_THE_WEB,
+  REFERENCES.SPAWNING_A_WASI_THREAD_WITH_RAW_WEBASSEMBLY,
+  REFERENCES.WEBGPU_ALL_OF_THE_CORES_NONE_OF_THE_CANVAS,
+  REFERENCES.ZX_CALCULUS_AND_EXTENDED_HYPERGRAPH_REWRITING_SYSTEMS_I,
+  REFERENCES.FAST_AUTOMATED_REASONING_OVER_STRING_DIAGRAMS_USING_MULTIWAY_CAUSAL_STRUCTURE,
+  REFERENCES.LAGRANGIAN_NEURAL_NETWORKS,
+  REFERENCES.QUANTOMATRIC_A_PROOF_ASSISTANT_FOR_DIAGRAMMATIC_REASONING,
+  REFERENCES.THE_SEMANTIC_CONCEPTION_OF_TRUTH_AND_THE_FOUNDATIONS_OF_SEMANTICS,
+
+  REFERENCES.CHAPTERHOUSE_DUNE,
+
+  REFERENCES.FOUNDATIONS_EDGE,
+  REFERENCES.FOUNDATION_AND_EARTH,
+  REFERENCES.PRELUDE_TO_FOUNDATION,
+  REFERENCES.FORWARD_THE_FOUNDATION,
+
+  REFERENCES.I_ROBOT,
+  REFERENCES.THE_REST_OF_THE_ROBOTS,
+  REFERENCES.THE_COMPLETE_ROBOT,
+  REFERENCES.THE_CAVES_OF_STEEL,
+  REFERENCES.THE_NAKED_SUN,
+  REFERENCES.THE_ROBOTS_OF_DAWN,
+  REFERENCES.ROBOTS_AND_EMPIRE,
+
+  REFERENCES.THE_RISE_AND_FALL_OF_THE_THIRD_REICH,
+
+  REFERENCES.A_PROJECT_TO_FIND_THE_FUNDAMENTAL_THEORY_OF_PHYSICS,
+  REFERENCES.METAMATHEMATICS,
+  REFERENCES.TWENTY_YEARS_NKS,
+
+  REFERENCES.THE_SELFISH_GENE,
+  REFERENCES.TRANSFORMER,
+  REFERENCES.THE_VITAL_QUESTION,
+
+  REFERENCES.INTERACTION_COMBINATORS,
+  REFERENCES.VON_NEUMANNS_IMPOSSIBILITY_PROOF_MATHEMATICS_IN_THE_SERVICE_OF_RHETORICS,
+  REFERENCES.PERFECTLY_SECURE_STEGANOGRAPHY_USING_MINIMUM_ENTROPY_COUPLING,
+  REFERENCES.GENERAL_INTELLIGENCE_REQUIRES_RETHINKING_EXPLORATION,
+  REFERENCES.DENSEPOSE_FROM_WIFI,
+  REFERENCES.A_MECHANIZED_FORMALIZATION_OF_THE_WEBASSEMBLY_SPECIFICATION_IN_COQ,
+  REFERENCES.A_DENOTATIONAL_SEMANTICS_FOR_THE_SYMMETRIC_INTERACTION_COMBINATORS,
+  REFERENCES.DEEP_SELF_MODELING_AS_A_FUNDAMENTAL_PRINCIPLE_IN_THE_DESIGN_OF_INTELLIGENT_SYSTEMS,
+  REFERENCES.AI_ARTIFICIAL_INTELLIGENCE_OR_ARTIFICAL_IGNORANCE,
+  REFERENCES.FROM_HUME_TO_HUMAN_AI_A_RETURN_TO_THE_FOUNDATIONS_AND_RESTRICTIONS_OF_HUMEAN_REASONING,
+  REFERENCES.BUILDING_HUMAN_LIKE_INTELLIGENCE_AN_EVOLUTIONARY_PERSPECTIVE,
+  REFERENCES.A_CASE_FOR_COMPUTATIONAL_INTELLIGENCE_AS_RECURSIVE_ABSTRACTION_AND_GOAL_ORIENTED_SYNTHESIS,
+  REFERENCES.REVERSE_ENGINEERING_WEBASSEMBLY,
+  REFERENCES.TOROIDAL_TOPOLOGY_OF_POPULATION_ACTIVITY_IN_GRID_CELLS,
+  REFERENCES.A_50_YEAR_QUEST_MY_PERSONAL_JOURNEY_WITH_THE_SECOND_LAW_OF_THERMODYNAMICS,
+  REFERENCES.ALIEN_INTELLIGENCE_AND_THE_CONCEPT_OF_TECHNOLOGY,
+  REFERENCES.CHATGPT_GETS_ITS_WOLFRAM_SUPERPOWERS,
+  REFERENCES.COMPUTATIONAL_FOUNDATIONS_FOR_THE_SECOND_LAW_OF_THERMODYNAMICS,
+  REFERENCES.FASTER_THAN_LIGHT_IN_OUR_MODEL_OF_PHYSICS_SOME_PRELIMINARY_THOUGHTS,
+  REFERENCES.HOW_DID_WE_GET_HERE_THE_TANGLED_HISTORY_OF_THE_SECOND_LAW_OF_THERMODYNAMICS,
+  REFERENCES.MULTICOMPUTATIONAL_IRREDUCIBILITY
+]
+
+
+export const ARTICLES_2021: Content[] = [
+  REFERENCES.DUNE,
+  REFERENCES.DUNE_MESSIAH,
+  REFERENCES.CHILDREN_OF_DUNE,
+
+  REFERENCES._1984,
+]
+
+
+export const ARTICLES_2022: Content[] = [
+
+  REFERENCES.GOD_EMPEROR_OF_DUNE,
+  REFERENCES.HERETICS_OF_DUNE,
+
+  REFERENCES.FOUNDATION,
+  REFERENCES.FOUNDATION_AND_EMPIRE,
+  REFERENCES.SECOND_FOUNDATION,
+
+  REFERENCES.THE_ART_OF_WAR,
+
+  REFERENCES.A_THOUSAND_BRAINS,
+
+  REFERENCES.QUANTUM_EINSTEIN_BOHR_AND_THE_GREAT_DEBATE_ABOUT_THE_NATURE_OF_REALITY,
+  REFERENCES.THE_FUTURE_OF_HUMANITY,
+
+  REFERENCES.FLUID_CONCEPTS_AND_CREATIVE_ANALOGIES,
+  REFERENCES.GODEL_ESCHER_BACH,
+
+  REFERENCES.COMBINATORS_A_CENTENNIAL_VIEW,
+
+  REFERENCES.REASONING_WITH_BELIEF_FUNCTIONS,
+  REFERENCES.CONTEXT_AWARE_COMPUTING_APPLICATIONS,
+  REFERENCES.IS_REALISM_COMPATIBLE_WITH_TRUE_RANDOMNESS,
+  REFERENCES.WHAT_IS_A_KNOWLEDGE_REPRESENTATION,
+  REFERENCES.LEARNING_TO_REPRESENT_PROGRAMS_WITH_GRAPHS,
+  REFERENCES.A_THEORY_OF_INCREMENTAL_COMPRESSION,
+  REFERENCES.ON_THE_MEASURE_OF_INTELLIGENCE,
+  REFERENCES.EMPIRICISM_SEMANTICS_AND_ONTOLOGY,
+  REFERENCES.GOING_BEYOND_THE_POINT_NEURON,
+  REFERENCES.THE_GENERAL_THEORY_OF_GENERAL_INTELLIGENCE,
+  REFERENCES.EMBODIED_SITUATED_AND_GROUNDED_INTELLIGENCE,
+  REFERENCES.THE_DEBATE_OVER_UNDERSTANDING_IN_AI_LARGE_LANGUAGE_MODELS,
+  REFERENCES.BEYOND_PROGRAMMING_LANGUAGES,
+  REFERENCES.DATA_COMPRESSION_EXPLAINED,
+  REFERENCES.IPFS_FAN_A_FUNCTION_ADDRESSABLE_COMPUTATION_NETWORK,
+  REFERENCES.AVOIDING_CATASTROPHE_ACTIVE_DENDRITES_ENABLE_MULTI_TASK_LEARNING_IN_DYNAMICS_ENVIRONMENTS,
+  REFERENCES.GAMES_AND_PUZZLES_AS_MULTICOMPUTATIONAL_SYSTEMS,
+  REFERENCES.A_THOUSAND_BRAINS_TOWARD_BIOLOGICALLY_CONSTRAINED_AI,
+  REFERENCES.IS_PROBABILITY_THEORY_RELEVANT_FOR_UNCERTAINTY,
+  REFERENCES.MULTICOMPUTATION_A_FOURTH_PARADIGM_FOR_THEORETICAL_SCIENCE,
+  REFERENCES.ATTENTION_IS_ALL_YOU_NEED,
+  REFERENCES.ON_THE_EINSTEIN_PODOLSKY_ROSEN_PARADOX,
+  REFERENCES.THE_ALGORITHMIC_ORIGINS_OF_LIFE,
+  REFERENCES.THE_COMPUTER_FOR_THE_21ST_CENTURY,
+  REFERENCES.SOK_SANITIZING_FOR_SECURITY,
+  REFERENCES.UNCERTAINTY_BELIEF_AND_PROBABILITY,
+  REFERENCES.ON_DEFINING_ARTIFICAL_INTELLIGENCE,
+  REFERENCES.ROBUST_SPEECH_RECOGNITION_VIA_LARGE_SCALE_WEAK_SUPERVISION,
+]
+
+export const FAMILIAR_TOOLS: Content[] = [
+
+  REFERENCES.PYTHON,
+  // REFERENCES.GO,
+  // REFERENCES.CHYP,
+  // REFERENCES.LLVM,
+  // REFERENCES.HASKELL,
+  REFERENCES.JAVA,
+  REFERENCES.RUBY_ON_RAILS,
+  REFERENCES.C_SHARP,
+  REFERENCES.DOT_NET,
+  REFERENCES.BLAZOR,
+  REFERENCES.JAVASCRIPT,
+  REFERENCES.KOTLIN,
+  REFERENCES.CSS,
+  REFERENCES.SASS,
+  REFERENCES.HTML,
+  REFERENCES.WASM,
+  REFERENCES.WEBGPU,
+  REFERENCES.RUST,
+  REFERENCES.CPP,
+  REFERENCES.WOLFRAM_LANGUAGE,
+
+  REFERENCES.WEBPACK,
+
+  REFERENCES.ASSEMBLY_SCRIPT,
+  REFERENCES.TYPESCRIPT,
+  REFERENCES.REACT,
+  // REFERENCES.BLUEPRINT_JS,
+  // REFERENCES.SLATE,
+  REFERENCES.THREEJS,
+  REFERENCES.DREI,
+  REFERENCES.NEXTJS,
+
+  REFERENCES.IPFS,
+  REFERENCES.IPVM,
+  REFERENCES.SQL,
+  REFERENCES.MYSQL,
+  REFERENCES.POSTGRESQL,
+  REFERENCES.MONGO_DB,
+  REFERENCES.REDIS,
+  REFERENCES.RABBIT_MQ,
+
+  REFERENCES.GIT,
+  REFERENCES.GITLAB,
+  REFERENCES.GITHUB,
+  REFERENCES.BITBUCKET,
+
+  REFERENCES.DOCKER,
+  REFERENCES.KUBERNETES,
+  REFERENCES.NGINX,
+  REFERENCES.NPM,
+  REFERENCES.MAVEN,
+
+  REFERENCES.LINUX,
+  REFERENCES.ANDROID,
+
+  REFERENCES.GCP,
+  REFERENCES.AZURE,
+  REFERENCES.AWS,
+
+  // REFERENCES.SPIGOT_MC,
+  // REFERENCES.BUNGEE_CORD,
+  // REFERENCES.BUKKIT,
+
+  // REFERENCES.FLATPAK,
+  // REFERENCES.OBS,
+  // REFERENCES.CLOUDFLARE,
+
+  // REFERENCES.INTELLI_J,
+  // REFERENCES.VS_CODE,
+  // REFERENCES.ECLIPSE,
+];
diff --git a/orbitmines.com/src/routes/references.tsx b/orbitmines.com/src/routes/references.tsx
index f56f63c..8450243 100644
--- a/orbitmines.com/src/routes/references.tsx
+++ b/orbitmines.com/src/routes/references.tsx
@@ -237,21 +237,3 @@ export const PHYSICS: Content = { reference: {
   link: "https://orbitmines.com/physics"
 }, status: Viewed.VIEWED, found_at: "2026", viewed_at: "December, 2026",
 }
-
-export const RAY_CALCULI_AND_PHYSICS: Content = { reference: {
-  title: "2026 Physics: Notes on an XOR Universe",
-  subtitle: "An initial look at a discrete Ray Calculus for physics: specifically for gravity and electromagnetism, and a continuous model based on ideas of that discrete setup.",
-  draft: true,
-  date: "2026-12-31",
-  year: "2026",
-  external: {
-    discord: {serverId: '1055502602365845534', channelId: '1463219913044005018', link: () => "https://discord.com/channels/1055502602365845534/1463219913044005018/1463219913044005018"}
-  },
-  organizations: [ORGANIZATIONS.orbitmines_research],
-  authors: [{
-    ...PROFILES.fadi_shawki,
-    external: PROFILES.fadi_shawki.external?.filter((profile) => PLATFORMS.includes(profile.organization.key))
-  }],
-  published: [ORGANIZATIONS.orbitmines_research],
-  link: "https://orbitmines.com/archive/ray-calculi-and-physics"
-}, status: Viewed.VIEWED, found_at: "2026", viewed_at: "December, 2026", }

From eba626c10c3806e365105c516623b3350ea63202 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Thu, 13 Aug 2026 10:53:36 +0200
Subject: [PATCH 36/47] Move a few things around

---
 orbitmines.com/src/routes/Physics.tsx         | 160 +-----------------
 .../archive/2026.RayCalculiAndPhysics/law.tsx |   7 -
 2 files changed, 8 insertions(+), 159 deletions(-)

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index aa08c10..d93918e 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -9,7 +9,7 @@ import { bySide, Graph } from "./archive/2026.RayCalculiAndPhysics/discrete";
 import { Echoes } from "./archive/2026.RayCalculiAndPhysics/echoes";
 import { Beam, Sheet } from "./archive/2026.RayCalculiAndPhysics/figures";
 import {
-  B, Bar, Because, CLOCK, CONSTANTS, Eq, F, Frac, FULL, Hat, Head, K, LAW,
+  B, Bar, Because, CLOCK, Eq, F, Frac, FULL, Hat, Head, K, Law, LAW,
   MADE_FROM, MEETINGS, MET, METRIC, Paren, REACH, Rows, SPACE, Step, Sub, Sup, V,
 } from "./archive/2026.RayCalculiAndPhysics/law";
 import { lineGroups } from "./archive/2026.RayCalculiAndPhysics/lines";
@@ -209,145 +209,13 @@ const Physics = () => {
 
         <Sheet />
 
-        <Eq derive={{
-          label: 'l.SHEET',
-          title: <>the sheet — what the inverse square asks for</>,
-          body: <>
-            <Because>(1) the thing we are trying to end up with</Because>
-            <Step eq={<>
-              intensity ∝
-              <Frac over={<>1</>}
-                under={<><V><Bar>r</Bar></V><Sup><K>l.<Bar>D</Bar></K> - 1</Sup></>} />
-              <span style={{ padding: '0 1.2em', color: '#6c7080' }}>
-                = 1/<V><Bar>r</Bar></V><Sup>2</Sup> where <K>l.<Bar>D</Bar></K> = 3
-              </span>
-            </>}>
-              This one is not derived — it is the target, the inverse-square law
-              we would like to come out of the lattice, written for however many
-              dimensions the place has. Everything below is what having it costs,
-              and the point of the exercise is that it costs exactly one thing
-              and leaves nothing over to tune.
-            </Step>
-
-            <Because>(2) what a falloff can even be here, since nothing pushes</Because>
-            <Step eq={<>
-              chance(<V><Bar>r</Bar></V>) =
-              <Frac over={<>what was let go of</>} under={<>shell(<V><Bar>r</Bar></V>)</>} />
-            </>}>
-              There is no force in the rules — only rays that step and meet. So
-              the only way something can weaken with distance is by being{' '}
-              <i>spread thinner</i>: a source lets go of some charges, they step
-              outward a cell a tick (that is <K><Bar>c</Bar></K>), and after <V><Bar>r</Bar></V>{' '}
-              ticks they are somewhere on the shell at <V><Bar>r</Bar></V>. None is made
-              and none is destroyed on the way, so what is on that shell is what
-              left, however far it has got. The chance a given cell out there is
-              holding one is that count over the size of the shell.
-            </Step>
-
-            <Because>(3) so the target is really a statement about what it spreads over</Because>
-            <Step eq={<>
-              shell(<V><Bar>r</Bar></V>) = 4<V>π</V> <V><Bar>r</Bar></V><Sup><K>l.<Bar>D</Bar></K> - 1</Sup>
-              <span style={{ padding: '0 1.2em', color: '#6c7080' }}>
-                a surface: <K>l.<Bar>D</Bar></K> - 1 dimensional
-              </span>
-            </>}>
-              Put (1) and (2) together and the demand is that a fixed count be
-              diluted by <V><Bar>r</Bar></V><Sup><K>l.<Bar>D</Bar></K> - 1</Sup> — and a thing whose
-              size goes up by <V><Bar>r</Bar></V><Sup><V>n</V></Sup> when you scale it
-              by <V><Bar>r</Bar></V> is an <V>n</V> dimensional thing, because that is what
-              having a dimension <i>means</i>. So what the emission is spread
-              over has to be <K>l.<Bar>D</Bar></K> - 1 dimensional: a surface, and the one
-              surrounding the source, or there are directions the pull never
-              reaches. In three dimensions that is 4π<V><Bar>r</Bar></V><Sup>2</Sup>.
-            </Step>
-
-            <Because>(4) and it has to get onto that surface by turning</Because>
-            <Step eq={<>
-              emitted + 1 <F>(the turn)</F> = <K>l.<Bar>D</Bar></K>
-              <span style={{ padding: '0 1.2em' }} />
-              emitted = <K>l.<Bar>D</Bar></K> - 1 = 2
-            </>}>
-              A source cannot pulse into a whole sphere at once — a pulse leaves
-              along lattice directions, and the sphere is not a set of them. It
-              can pulse into a <i>sheet</i> and turn, and one rotation carries
-              whatever it emits through exactly one more dimension than that
-              emission already has. Its sweep has to be the whole space, so what
-              is emitted is one dimension short of it: a sheet, two dimensional
-              in three dimensional space.
-            </Step>
-
-            <Because>(5) not more, not less — both alternatives fail, differently</Because>
-            <Step eq={<>
-              <K>l.<Bar>D</Bar></K>: nothing left to turn
-              <span style={{ padding: '0 1.2em' }} />
-              <K>l.<Bar>D</Bar></K> - 2: the sweep is a surface, not a space
-            </>}>
-              Emit into all of space — every way out of the point, which is the
-              full 3<Sup><K>l.<Bar>D</Bar></K></Sup> - 1 = 26 — and there is no dimension
-              left for the turn to happen in; the sphere is covered by the pulse
-              itself and never gets thinner in the right way. Emit into a line
-              instead, two directions, and one turn sweeps a surface — a disc
-              through the source, with the rest of the space untouched. Only{' '}
-              <K>l.<Bar>D</Bar></K> - 1 both covers the space and needs the turn.
-            </Step>
-
-            <Because>(6) so count the directions that lie in the sheet</Because>
-            <Step eq={<>
-              <K>l.<Bar>SHEET</Bar></K> = 3<Sup><K>l.<Bar>D</Bar></K> - 1</Sup> - 1 = 8
-            </>}>
-              Along any one axis a ray can go down it, up it, or not along it —
-              three, and no more, because two steps in a tick is faster
-              than <K><Bar>c</Bar></K>. The axes do not constrain each other, so the
-              choices multiply: three of them over the <K>l.<Bar>D</Bar></K> - 1 axes
-              lying in the sheet, less the one that is zero on all of them,
-              which is standing still and is not a direction to leave in. In
-              three dimensions that is the 3×3 around the point with its middle
-              taken out. <b>Eight. Not the 26, not the 2</b> — and every part of
-              it was forced: the 3 is a tick's worth of one axis, the exponent is
-              what the turn in (4) needs, the −1 is standing still.
-            </Step>
-
-            <Because>(7) and reading it back the way a pulse actually runs</Because>
-            <Step eq={<>
-              chance(<V>m</V>, <V><Bar>r</Bar></V>) =
-              <Frac over={<><V>m</V> · <K>l.<Bar>SHEET</Bar></K></>}
-                under={<>4<V>π</V> <V><Bar>r</Bar></V><Sup><K>l.<Bar>D</Bar></K> - 1</Sup></>} />
-              &nbsp;=&nbsp;
-              <Frac over={<>8<V>m</V></>} under={<>4<V>π</V> <V><Bar>r</Bar></V><Sup>2</Sup></>} />
-            </>}>
-              Eight charges leave, the sheet they left in comes round as the
-              source turns so that over a revolution the space around it has all
-              been pulsed into, and those same eight are on the shell at{' '}
-              <V><Bar>r</Bar></V> a moment later. Eight over 4π<V><Bar>r</Bar></V><Sup>2</Sup>:{' '}
-              <b>the inverse square, back out</b>, which it had better be — this
-              step is the check, not the derivation.
-            </Step>
-
-            <Because>(8) what it cost, which is the reason for doing it this way</Because>
-            <Step>
-              <b>Nothing was fitted and nothing is left free.</b> The strength of
-              a source is not a constant anybody chose — it is eight, because
-              eight is what a sheet in three dimensions has in it, and a sheet is
-              what an inverse square asks for: <b>not the 26 and not the 2</b>.
-              The argument never mentioned three, so it runs the same in any{' '}
-              <K>l.<Bar>D</Bar></K> — sheet one dimension short of the space, count{' '}
-              3<Sup><K>l.<Bar>D</Bar></K> - 1</Sup> - 1, diluted over the surface
-              surrounding the source — and three is only where that comes out as
-              eight and an inverse <i>square</i>. And <K>l.<Bar>D</Bar></K> is{' '}
-              <i>local</i>, which is what the l. is for: it is the dimension
-              where the pulsing is happening, not a number set once for the
-              universe.
-            </Step>
-          </>,
-        }}>
+        <Eq>
           <K>l.<Bar>SHEET</Bar></K> = <>3<Sup><K>l.<Bar>D</Bar></K> - 1</Sup> - 1</>
         </Eq>
 
-        Whenever there's a derived equation, you can click on it to see how it was derived! Try it!
-
         <BR/>
 
-        Then the related number, all possible paths out of point (the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "degree", link: "https://en.wikipedia.org/wiki/Degree_(graph_theory)"}}/> assuming diagonals are included). 
+        Then the related number, all possible paths out of a point (the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "degree", link: "https://en.wikipedia.org/wiki/Degree_(graph_theory)"}}/> assuming diagonals are included). 
 
         <Eq>
           <K>l.<Bar>DEG</Bar></K> = <>3<Sup><K>l.<Bar>D</Bar></K></Sup> - 1</>
@@ -360,7 +228,7 @@ const Physics = () => {
         Let's dive into the continuous model to show you how.
 
         <Section head="The Continuous Model">
-
+          Whenever there's a derived equation, you can click on it to see how it was derived! Try it!
         </Section>
         <Section head="The Discrete Model">
         </Section>
@@ -454,13 +322,6 @@ const Physics = () => {
             Which leaves the constants, and this is the part I actually care about. <K>BIAS</K> is one way out of <K><Bar>DEG</Bar></K>. <V>c</V> is a step over a tick. And <V>G</V> is not measured, chosen or fitted — it is written entirely in counts we already have.
           </Para>
 
-          <Eq derive={CONSTANTS}>
-            <K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>DEG</K>} /> =
-            <Frac over={<>1</>} under={<>26</>} />
-            <span style={{ padding: '0 1.6em' }} />
-            <V>c</V> = <Frac over={<K>HALF</K>} under={<K>GRAIN</K>} />
-          </Eq>
-
           <Eq derive={FULL}
             note={<>the bracket is 1.08 at a core of half a lattice step and Mercury's
               separation — and 1 + 10⁻³⁸ at the grain a real lattice would have</>}>
@@ -572,10 +433,6 @@ const Physics = () => {
 
           <Head>so is that general relativity</Head>
 
-          <Para>
-            No, and I think the difference is the interesting part. Nothing is borrowed any more, but what came out is not Einstein's metric — it is the <i>exponential</i> one, and the two agree exactly where general relativity has been tested and part company where it has not.
-          </Para>
-
           <Rows of={[
             [<>where they agree</>,
               <>β = γ = 1, so every first-post-Newtonian test is identical: the
@@ -594,10 +451,6 @@ const Physics = () => {
                 wrong.</>],
           ]} />
 
-          <Para>
-            So the claim is not "general relativity, rederived". It is: <b>a metric theory built from counting, agreeing with general relativity on everything general relativity has passed, and disagreeing where nobody has looked closely yet.</b> That is a better position than agreement would be, because it can be shot at.
-          </Para>
-
           <Head>what a black hole is here</Head>
 
           <Para>
@@ -948,10 +801,13 @@ const Physics = () => {
 
           <Models models={MODELS} />
         </Section>
+        <Section head="TODO3">
+          <Law/>
+        </Section>
       </Section>
 
       <Section head="XOR: Gravity + Magnetism">
-        Instead of having our rays me neutral, we can introduce a polarity to them: positive/negative. When we do that gravity + magnetism comes down to three rules:
+        Instead of having our rays be neutral, we can introduce a polarity to them: positive/negative. When we do that gravity + magnetism comes down to three rules:
         <BR/>
         (G+M/1) Annihilation: When two opposite polarities meet, they annihilate, leaving a single neutral spatial point behind.
 
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 6d72b28..0ee972c 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -1734,13 +1734,6 @@ export const Law = () => {
       </Paren>
     </Eq>
 
-    <Eq derive={CONSTANTS} open={show}>
-      <K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>DEG</K>} /> =
-      <Frac over={<>1</>} under={<>26</>} />
-      <span style={{ padding: '0 1.6em' }} />
-      <V>c</V> = <Frac over={<K>HALF</K>} under={<K>GRAIN</K>} />
-    </Eq>
-
     <Head>what is put in</Head>
     <Note>Six countable facts about the lattice, and nothing else is assumed.</Note>
 

From 9569894533d7de60c69442bc7217ee8eb3b67578 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Thu, 13 Aug 2026 15:34:12 +0200
Subject: [PATCH 37/47] Generate derivation steps

---
 orbitmines.com/src/routes/Physics.tsx         | 1250 ++++++++++++++++-
 .../archive/2026.RayCalculiAndPhysics/law.tsx |  116 ++
 .../2026.RayCalculiAndPhysics/tests/turns.ts  |  144 ++
 3 files changed, 1484 insertions(+), 26 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/turns.ts

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index d93918e..389bc29 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -2,6 +2,8 @@ import Post, {
   Arc, BlueprintIcons16, BlueprintIcons20, BR, JetBrainsMono, PaperProps, Section,
   Title, renderable, useCounter,
   Reference,
+  Row,
+  Col,
 } from "../lib/post/Post";
 import { PHYSICS } from "./references";
 
@@ -9,8 +11,9 @@ import { bySide, Graph } from "./archive/2026.RayCalculiAndPhysics/discrete";
 import { Echoes } from "./archive/2026.RayCalculiAndPhysics/echoes";
 import { Beam, Sheet } from "./archive/2026.RayCalculiAndPhysics/figures";
 import {
-  B, Bar, Because, CLOCK, Eq, F, Frac, FULL, Hat, Head, K, Law, LAW,
-  MADE_FROM, MEETINGS, MET, METRIC, Paren, REACH, Rows, SPACE, Step, Sub, Sup, V,
+  B, Bar, Because, CLOCK, CONSTANTS, D, Eq, F, Frac, FULL, Hat, Head, IDENTICAL,
+  IGNORANCE, K, Law, LAW, MADE_FROM, MEETINGS, MET, METRIC, Paren, REACH, Rows,
+  SPACE, Step, Sub, Sup, TURNS, V,
 } from "./archive/2026.RayCalculiAndPhysics/law";
 import { lineGroups } from "./archive/2026.RayCalculiAndPhysics/lines";
 import { Model } from "./archive/2026.RayCalculiAndPhysics/model";
@@ -85,6 +88,19 @@ const named = (...names: string[]): Model[] =>
 const Physics = () => {
   const referenceCounter = useCounter();
 
+  /**
+   * One citation, so that a paper can be named the way a paper is named.
+   *
+   * `Reference`'s `simple` form sets `title (year)`, so the title carries the
+   * author and the journal and this carries the year — which is the shortest
+   * thing that is still a citation rather than a link with a word on it. The
+   * links go to the publisher of record or to the arXiv entry, never to a
+   * summary of one.
+   */
+  const Ref = ({ of, year, at }: { of: string, year?: string, at: string }) =>
+    <Reference is="reference" simple inline index={referenceCounter()}
+      reference={{ title: of, year, link: at }} />;
+
   const book: Omit<PaperProps, 'children'> = {
     book: true,
     ...PHYSICS.reference,
@@ -168,7 +184,7 @@ const Physics = () => {
 
         <BR/>
 
-        Since we're building on a lattice effectively then, there are some things we can and can't do. Before we dip into dive into the continuous we do need a little discreteness.
+        Since we're building on a lattice effectively then, there are some things we can and can't do. Before we dive into the continuous we do need a little discreteness.
 
         <BR/>
 
@@ -193,43 +209,857 @@ const Physics = () => {
 
         <BR/>
 
-        Next up we have dimensions, now the trouble with this, is that generally we could have a fraction in this number. So one would only be able to make a judgement on this number locally, or regionally. Instead these following variables will only be judged locally always (the current position). We denote that with a 'l.' in front of the variable. Unless otherwise mentioned the local variable has a default, which is the same variable name without the 'l.'.
+        Next up we have dimensions, now the trouble with this, is that generally we could have a fraction in this number. So one would only be able to make a judgement on this number locally, or regionally. Instead these following variables will only be judged locally always (the current position). We denote that with a 'l.' in front of the variable. Unless otherwise mentioned the local variable has a default, which is the same variable name without the 'l.'.
+
+        <Eq>
+          <F>l.</F><K><Bar>D</Bar></K> = number of dimensions
+          <span style={{ padding: '0 1.6em' }} />
+          <K><Bar>D</Bar></K> = 3
+        </Eq>
+
+        <span style={{textAlign: 'left', width: '100%'}}>You're allowed to change the <K><Bar>D</Bar></K> ofc. But unless otherwise specified variables have these default values.</span>
+
+        <BR/>
+
+        Then a related number to dimension, all possible paths out of a point (the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "degree", link: "https://en.wikipedia.org/wiki/Degree_(graph_theory)"}}/> assuming diagonals are included). 
+
+        <Eq>
+          <F>l.</F><K><Bar>DEG</Bar></K> = <>3<Sup><F>l.</F><K><Bar>D</Bar></K></Sup> - 1</>
+        </Eq>
+
+        <span style={{textAlign: 'left', width: '100%'}}>There's one important piece of gravity that we'll discover and that is in order to reach the desired 1/R<Sup><K><Bar>D</Bar></K> - 1</Sup> of the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "inverse-square law", link: "https://en.wikipedia.org/wiki/Inverse-square_law"}}/> (for 3D). It happens that as we'll discover in a moment, if we'd send out discrete pulses of our 'gravity-rays' (so the ones causing annihilation). That we can recover the intensity of gravity in a neat way based on the dimensionality of our space. This is our sheet. The sheet we pulse a beam towards. In order to cover our whole space, we'll be rotating this sheet in 1 more dimension than it's defined.</span>
+
+        <Sheet />
+
+        <Eq>
+          <F>l.</F><K><Bar>SHEET</Bar></K> = <K><Bar>DEG</Bar></K>(<D>max</D>(<F>l.</F><K><Bar>D</Bar></K> - 1, 1))
+        </Eq>
+
+        <Para>You'll see that we call the <K><Bar>DEG</Bar></K> variable with an argument. Whenever a variable just depends on a single parameter, we'll allow it to be called, since there's no ambiguity of what that would mean.</Para>
+
+        (It doesn't actually need to be a sheet, but that's the most convenient model, as long as the number of points keep rotating properly, you'll recover the continuous model)
+
+        <BR/>
+
+        Speaking of rotation, 
+
+        <BR/>
+
+        It turns out that this is all the machinary we need to derive gravitational laws that approximate <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "Newtonian gravity", link: "https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation"}}/> and <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "General relativity", link: "https://en.wikipedia.org/wiki/General_relativity"}}/> and go beyond them.
+
+        <BR/>
+
+        Let's dive into the continuous model to show you how.
+
+        <Section head="The Continuous Model">
+          So putting everything from the previous section together we get (assuming a discrete 3D space):
+
+          <Eq>
+            <K><Bar>c</Bar></K> = 1 <F><Bar>x</Bar>/<Bar>t</Bar></F>
+            <span style={{ padding: '0 1.4em' }} />
+            <K><Bar>D</Bar></K> = 3
+            <span style={{ padding: '0 1.4em' }} />
+            <K><Bar>SHEET</Bar></K> = 3<Sup><K><Bar>D</Bar></K> - 1</Sup> - 1 = 8
+            <span style={{ padding: '0 1.4em' }} />
+            <K><Bar>DEG</Bar></K> = 3<Sup><K><Bar>D</Bar></K></Sup> - 1 = 26
+          </Eq>
+          <Row>
+            <Col xs={6}><Models models={[PLAIN[5]]}/></Col>
+            <Col xs={6}><Models models={[PLAIN_BACK[5]]}/></Col>
+          </Row>
+
+          Ah there's one more small piece of 'syntactic sugar'. Since we're working with a continous model, we'll be referring to a node sitting at some point. Instead of having that point be for instance the cube x=0..1, y=0..1, z=0..1. We displace it by a half, so we can just use coordinates for a point; by referring to that node's center. Its radius would be a half, and to make that obvious we'll refer to that concept as following:
+
+          <Eq>
+            <D><Bar>½</Bar></D>
+          </Eq>
+
+          Alrighty, let's get started then.
+
+          <span style={{paddingBottom: '200px'}}></span>
+
+          <BR/>
+
+          TODO Rewrite everything past this point:
+
+          <BR/>
+
+          Whenever there's a derived equation, you can click on it to see how it was derived! Try it!
+
+          <BR/>
+
+          How we would get a model which knows where to move from local interactions I don't yet know (that'll be something for the future). But for now we can just calculate a trajectory based on the space.
+
+          <BR/>
+
+
+          <Head>what mass is: how often, not how much</Head>
+
+          <Para>
+            Here is the first place the model says something that isn't obvious. In this model <b>mass is not a property a thing has</b>. A body does not have a quantity of stuff in it that space somehow senses. A body <i>pulses</i> — it lets go of a sheet of charges — and mass is <i>how often it does that</i>.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            A heavier thing does not write more charge onto space in one go. It writes exactly as much, more often. So the natural variable is the period: <V>X</V> ticks between one pulse and the next, and <V>m</V> = 1/<V>X</V>.
+          </Para>
+
+          <Eq derive={CLOCK}
+            note="a heavier thing pulses more often, and nothing pulses more than once a tick">
+            <V>X</V> = 1/<V>m</V>
+            <span style={{ padding: '0 1.4em', color: FAINT }}>ticks between pulses</span>
+            <V>m</V> ≤ <K><Bar>c</Bar></K>
+            <span style={{ padding: '0 1.4em' }} />
+            <V>X</V>·<V>c</V> = <V>G</V> · <V>λ</V><Sub>Compton</Sub>
+          </Eq>
+
+          <Para>
+            Two things fall straight out of that, and I aimed at neither.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The first is that <b>there is a heaviest elementary thing</b>. Nothing in this universe does anything more than once a tick, so nothing pulses more than once a tick, so <V>m</V> ≤ 1 and there is a ceiling. In our units it is about 1.36 µg. Anything heavier is not <i>one</i> emitter — it is <i>many</i>, which is as close as this model gets to saying what matter is.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The second is stranger. Turn the period into a length by asking how far light goes in it, and you get <V>X</V>·<V>c</V> = <V>G</V>·ħ/<V>mc</V> exactly, at every mass — which is the <Ref of={'Compton, "A Quantum Theory of the Scattering of X-rays by Light Elements", Phys. Rev. 21:483'} year="1923" at="https://doi.org/10.1103/PhysRev.21.483" /> wavelength. Checked across twenty orders of magnitude — electron, proton, uranium atom, virus, grain of sand — the ratio comes out 0.062329 every time against a <V>G</V> of 0.062351. It is not a coincidence: <V>m</V><Sub>P</Sub><V>l</V><Sub>P</Sub> = ħ/<V>c</V>, so "period = 1/mass" in lattice units simply <i>is</i> the Compton relation, and <V>E</V> = ħω with it.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And at the ceiling, where the beat is one tick, that tick comes out at 5.391246·10<Sup>−44</Sup> s against a Planck time of 5.391246·10<Sup>−44</Sup> s. Ratio 1.000000000, with <V>G</V> cancelling out of it. <b>The lattice's tick is the Planck time</b>, by identity rather than by fit.
+          </Para>
+
+          <Head>one pulse, spread — which is where the inverse square is</Head>
+
+          <Para>
+            Now the piece the previous section promised. A source lets go of <K><Bar>SHEET</Bar></K> charges per pulse. That number does not change with distance — the charges just get further apart, because the shell they are riding on has grown. So the chance that any one cell out at radius <V>r</V> is holding one of them is a fixed count divided by a growing shell.
+          </Para>
+
+          <Eq derive={MEETINGS}>
+            shell(<V>r</V>) = 4<V>π</V>·max(<V>r</V>, <K><Bar>CORE</Bar></K>)<Sup><K><Bar>D</Bar></K> − 1</Sup> + <K><Bar>FLOOR</Bar></K>
+            <span style={{ padding: '0 1.4em' }} />
+            chance(<V>m</V>,<V>r</V>) =
+            <Frac over={<><V>m</V> · <K><Bar>SHEET</Bar></K></>} under={<>shell(<V>r</V>)</>} />
+          </Eq>
+
+          <Para>
+            <b>That is the whole of the inverse-square law and there is no distance law in it anywhere.</b> Nobody wrote down 1/<V>r</V><Sup>2</Sup>. What was written down is "a fixed number of charges" and "a shell in three dimensions has 4π<V>r</V><Sup>2</Sup> cells on it", and 1/<V>r</V><Sup>2</Sup> is what those two come to when you divide one by the other. Send the pulse out over a different shape and the exponent changes with nothing else touched — which is why the general form is 1/<V>r</V><Sup><K><Bar>D</Bar></K>−1</Sup> and why it is a statement about <i>dimension</i> rather than about gravity.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The two guards on it are both the same kind of honesty. The max says a shell is never smaller than the cell its source sits in, which is <K><Bar>CORE</Bar></K> from above. The <K><Bar>FLOOR</Bar></K> = 2 says that the innermost shell is not the continuum's 4π(½)<Sup>2</Sup> = 3.14 cells but the lattice's own: the surface of a cube at <V>d</V> steps is 24<V>d</V><Sup>2</Sup> + 2 cells, which at one step is exactly 26, exactly <K><Bar>DEG</Bar></K>. Without those two caps, chance at the core comes out at 8/4<V>π</V>(½)<Sup>2</Sup> = 2.546 — a probability, over one — and nobody had evaluated the floor to notice. With them it is 1.556, and read entirely off the cube rather than half off the continuum it would be 8/8 = 1 exactly, saturated and never exceeded, which is what a probability is allowed to do. <b>That last step is not taken here</b>, because 24<V>d</V><Sup>2</Sup> counts cells at Chebyshev distance where <K>chance</K> is asked with a Euclidean separation, and on a 26-connected lattice those differ by up to √3 depending on direction.
+          </Para>
+
+          <Head>and what does not get through</Head>
+
+          <Para>
+            The same number read the other way answers a question the discrete rules raise immediately: do two waves pass through each other, or not? The answer is <i>sometimes</i>, and how often is not a new rule — it is one minus the chance above.
+          </Para>
+
+          <Eq>
+            through(<V>m</V>,<V>r</V>) = max(1 − chance(<V>m</V>,<V>r</V>), 0)
+          </Eq>
+
+          <Para>
+            Close in the shell is crowded and nearly everything meets something, so nothing gets through — which is the wall you'd draw by hand. Far out the same shell has spread over 4π<V>r</V><Sup>2</Sup> cells and is mostly gaps, so nearly everything sails past. <b>The falloff and the transparency are one fact about the geometry, counted once.</b> Hold on to <K>through</K>; it comes back three times below, and the last time it gives us MOND.
+          </Para>
+
+          <Head>what two fields do where they meet</Head>
+
+          <Para>
+            Now put two bodies in the world. Body <V>a</V> is spraying charges everywhere and so is body <V>b</V>, and the only event in the whole model is <i>two of them landing in the same cell</i>.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            One thing here is easy to get wrong and I got it wrong for a while. <b>Meeting means being in the same place, not travelling towards each other.</b> On a line those are the same statement, which is why the discrete pictures in the previous section look the way they do. In three dimensions they are not: two shells sweeping through one another arrive at a shared cell from all angles at once, never as neighbours and never pointed at each other. So the chance of a meeting is simply the chance both are there — a product of two probabilities.
+          </Para>
+
+          <Eq derive={MEETINGS}>
+            <V>S</V><Sub>ab</Sub> &nbsp;=&nbsp; <K><Bar>BITE</Bar></K> · share · screen ·
+            <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> ·
+            <Paren><Frac over={<K><Bar>SHEET</Bar></K>} under={<>4<V>π</V></>} /></Paren><Sup>2</Sup>
+            · met(<V>R</V>)
+          </Eq>
+
+          <Para>
+            Three of those factors want a word each.
+          </Para>
+
+          <Rows of={[
+            [<>share</>,
+              <>How much of what meets is <i>opposite</i> rather than alike — so how much of
+                it annihilates. It is <b>a half</b>, and in the gravity arc that is a
+                stipulation. In the XOR arc it stops being one: it is the chance two charges
+                landing in one cell disagree, and for ordinary unbiased matter that chance is
+                a half. Hold that thought; it is where magnetism comes from.</>],
+            [<>screen</>,
+              <>What a <i>third</i> body standing in the way blocks, and it is
+                <K> through</K> again: <V>Π</V><Sub>c</Sub> through(<V>m</V><Sub>c</Sub>,
+                <V>d</V><Sub>c</Sub>) over each other body's nearest approach to the line
+                from <V>a</V> to <V>b</V>. <b>Three bodies in a row do not simply add.</b>
+                Newton has no such term, and neither does general relativity at this order,
+                so it is a genuine prediction rather than a correction — and a short-ranged
+                one, because <K>chance</K> is.</>],
+            [<><V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub></>,
+              <>Not stipulated either. Annihilation between two bodies goes as how much each
+                is putting out, and what each puts out goes as how often it pulses, which is
+                its mass. So the product of the masses is a product of two <i>rates</i>. This
+                is what fixes the configuration into the pull; without it every source emits
+                as hard as every other, and measured on six known three-body orbits no
+                coupling binds all six.</>],
+          ]} />
+
+          <Head>the line between them, integrated</Head>
+
+          <Para>
+            The awkward piece is met(<V>R</V>). We do not want the meeting rate at one point; we want it added up along the <i>line between the two bodies</i> — because that is the line an annihilation shortens. Two points become one, so what was behind each is joined onto what was behind the other, and the two bodies are left closer together than they were with nothing having moved.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>That is gravity, in one sentence.</b> Not a pull: a piece of bookkeeping, done often enough to notice.
+          </Para>
+
+          <Eq derive={MET}>
+            met(<V>R</V>) = ∫<Sub>0</Sub><Sup><V>R</V></Sup>
+            <Frac over={<>d<V>x</V></>}
+              under={<>max(<V>x</V>,<K><Bar>CORE</Bar></K>)<Sup>2</Sup> ·
+                max(<V>R</V>−<V>x</V>,<K><Bar>CORE</Bar></K>)<Sup>2</Sup></>} />
+          </Eq>
+
+          <Para>
+            And it has a closed form, which is the nicest surprise in the gravity arc. Cut the line in three — a core's worth at each end where a source's own field is capped and flat, and the open middle where nothing is capped — do the middle by partial fractions, and the two leftover pieces collapse against each other because they differ by a factor of (<V>R</V> − <K><Bar>CORE</Bar></K>) that cancels.
+          </Para>
+
+          <Eq derive={MET} note="one inverse square, times one bracket that goes to one">
+            met(<V>R</V>) &nbsp;=&nbsp;
+            <Frac over={<>4</>} under={<><K><Bar>CORE</Bar></K> <V>R</V><Sup>2</Sup></>} />
+            <Paren>
+              1 &nbsp;+&nbsp;
+              <Frac over={<K><Bar>CORE</Bar></K>} under={<V>R</V>} /> ln
+              <Frac over={<><V>R</V> − <K><Bar>CORE</Bar></K></>} under={<K><Bar>CORE</Bar></K>} />
+            </Paren>
+          </Eq>
+
+          <Para>
+            One inverse square, times one bracket that goes to one. The 1/<K><Bar>CORE</Bar></K> out front is the two ends — dense, because that is where each field is at its highest anywhere, but only half a step long. The logarithm is the middle — thin, but <V>R</V> long, and it accumulates equally per octave of distance because that term came from the <i>gradient</i> of each body's field across the other's near zone. Checked against brute-force numerical integration at every separation and core size tried, to eight significant figures.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The whole of this model's departure from Newton at a distance is that bracket, and its size is nothing but the ratio of a source's core to the separation. At <K><Bar>CORE</Bar></K> = half a lattice step and Mercury's separation the bracket is 1.08. At the grain a real lattice would have — where the Sun and Mercury are an astronomical number of steps apart — it is 1 + 10<Sup>−38</Sup>. <b>There is nothing there to tune.</b>
+          </Para>
+
+          <Head>what one meeting buys a path</Head>
+
+          <Para>
+            So far we have counted meetings. Now: what does a meeting <i>do</i>?
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Go back to (G/1). An annihilation removes the two points its charges were on and joins what was behind each onto what was behind the other. The place it happened is left with <b>more space folded into it</b> than its neighbours have. A path arriving there now has more ways of going the way the annihilation went than of going any other way — one annihilation makes it two to one, a second three to one, a third four to one — while every other way out of that point still weighs exactly what it always did, and there are <K><Bar>DEG</Bar></K> of those.
+          </Para>
+
+          <Eq derive={CONSTANTS} note="the only constant in the dynamics, and it is a ratio of two counts">
+            <Frac over={<>1 + <V>n</V></>} under={<>1, and there are <K><Bar>DEG</Bar></K> of them</>} />
+            <span style={{ padding: '0 1.4em', color: FAINT }}>⇒</span>
+            <K><Bar>BIAS</Bar></K> =
+            <Frac over={<K><Bar>c</Bar></K>} under={<K><Bar>DEG</Bar></K>} /> =
+            <Frac over={<>1</>} under={<>26</>} />
+          </Eq>
+
+          <Para>
+            Two things are worth stopping on. The lean is <b>linear in the count</b>, with no ceiling in it and nothing about how fast the thing is already going — so what accumulates is the count, and what drifts is a function of the count. <b>That is why gravity is an acceleration and not a speed.</b> Gravity is an acceleration because space remembers.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And it is <K><Bar>DEG</Bar></K> in that denominator and not <K><Bar>SHEET</Bar></K>, which this model had wrong for a long time. <K><Bar>SHEET</Bar></K> is how many charges a source <i>emits</i>; the question here is how many other directions the biased path <i>could have taken instead</i>, which is every way out of the point. Two different questions, one constant doing both jobs, and a factor of 3.25 hiding in it.
+          </Para>
+
+          <Head>and so, the law</Head>
+
+          <Para>
+            A body's count grows by <K><Bar>BIAS</Bar></K> times the meetings it took part in, divided by its own mass — because what bends it is the <i>fraction</i> of its paths that got biased, and its count of paths is its mass.
+          </Para>
+
+          <Eq derive={LAW}
+            note="the momentum a body gains is BIAS times the annihilations it took part in, and what one is worth depends on where it happened">
+            <Frac over={<>d</>} under={<>d<V>t</V></>} />
+            ( <V>γ</V> <V>m</V><Sub>a</Sub> <B>v</B><Sub>a</Sub> )
+            &nbsp;=&nbsp; <K><Bar>BIAS</Bar></K> · <span style={{ fontSize: '1.3em' }}>Σ</span>
+            <Sub>b ≠ a</Sub> &nbsp;<V>S</V><Sub>ab</Sub> <Hat>r</Hat><Sub>ab</Sub>
+            &nbsp;· carry
+          </Eq>
+
+          <Para>
+            <b>And there is the equivalence principle, for free.</b> Divide through by <V>m</V><Sub>a</Sub> and the mass cancels out of the statement entirely, leaving <V>a</V><Sub>a</Sub> ∝ <V>m</V><Sub>b</Sub>/<V>R</V><Sup>2</Sup>. A feather and a hammer fall together, not because anything was postulated, but because a heavier thing brought proportionally more paths to the meeting <i>and</i> has proportionally more paths to bend. It was never put in. This is the one place where I'd say the counting picture earns its keep on its own.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Substitute met and everything left standing is a count, which is the point of the exercise.
+          </Para>
+
+          <Eq derive={FULL}
+            note={<>the bracket is 1.08 at a core of half a lattice step and Mercury's
+              separation — and 1 + 10⁻³⁸ at the grain a real lattice would have</>}>
+            <Frac over={<>d<V>p</V></>} under={<>d<V>t</V></>} /> &nbsp;=&nbsp;
+            <V>G</V> ·
+            <Frac over={<><V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub></>}
+              under={<><V>R</V><Sup>2</Sup></>} />
+            <Paren>
+              1 &nbsp;+&nbsp; <Frac over={<K><Bar>CORE</Bar></K>} under={<V>R</V>} /> ln
+              <Frac over={<><V>R</V> − <K><Bar>CORE</Bar></K></>} under={<K><Bar>CORE</Bar></K>} />
+            </Paren>
+            <Hat>r</Hat>
+          </Eq>
+
+          <Eq derive={FULL} note="every symbol of it a count — 0.062351, in the lattice's own units">
+            <V>G</V> = <Frac
+              over={<><K><Bar>BITE</Bar></K> · share · <K><Bar>SHEET</Bar></K><Sup>2</Sup> · <K><Bar>c</Bar></K></>}
+              under={<>4<V>π</V><Sup>2</Sup> · <K><Bar>CORE</Bar></K> · <K><Bar>DEG</Bar></K></>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            0.062351
+          </Eq>
+
+          <Para>
+            <b>Newton, times a bracket that goes to one, with a constant that is not measured, chosen or fitted.</b> Every symbol in <V>G</V> is a count: how many charges a pulse carries, how many ways there are out of a point, how big a source's own cell is, and how much of what meets is opposite. Nothing in it came from an experiment, and there is nothing in it left to turn.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            One warning about notation, because the code and the prose have collided here before. The <K><Bar>CORE</Bar></K> in met(<V>R</V>) is <i>half a lattice step</i> — a length — and not the speed of light, which is <K><Bar>c</Bar></K> = one step a tick. They are written as the same letter in some places in the source and they are not the same quantity. Reading them as one is worth exactly a factor of two in <V>G</V>.
+          </Para>
+
+          <Head>and what a count is as a speed</Head>
+
+          <Para>
+            <K><Bar>BIAS</Bar></K> says how much a count leans a path. What it does not say is <i>per whose tick</i>, and there is only one honest answer: the counting happens on the body's own worldline, so <K><Bar>c</Bar></K>·<V>n</V>/<K><Bar>DEG</Bar></K> is cells per tick of <i>its</i> clock. That is a proper velocity, not a coordinate one, and turning it into what the picture shows is a line of arithmetic the model does not get to choose.
+          </Para>
+
+          <Eq derive={LAW} note="nothing is clamped — the ceiling is the one arithmetic already has">
+            <B>v</B> = <Frac
+              over={<><V>A</V> <B>u</B></>}
+              under={<><V>B</V> √(<V>A</V>(1 + |<B>u</B>|<Sup>2</Sup>/<V>B</V><K><Bar>c</Bar></K><Sup>2</Sup>))</>} />
+          </Eq>
+
+          <Para>
+            Flat — <V>A</V> = <V>B</V> = 1 — it is <B>u</B>/√(1 + |<B>u</B>|<Sup>2</Sup>) exactly, and differentiating <i>that</i> at <V>u</V> = 0 gives 1/<V>γ</V><Sup>3</Sup> along the way a thing is going and 1/<V>γ</V> across it. <b>Special relativity's own longitudinal and transverse response, out of a count of ways out of a point.</b> Nothing is clamped anywhere: a count of any size is allowed, and the picture simply cannot show more than a cell a tick of it.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The <V>γ</V> on the left of the law is worth <b>+1.66°</b> of Mercury's perihelion an orbit where 6π<V>GM</V>/<V>c</V><Sup>2</Sup><V>a</V>(1−<V>e</V><Sup>2</Sup>) is <b>+9.93°</b> — the right sign and <b>exactly a sixth</b> of the size, and a sixth to a part in a hundred on Venus, Earth and Mars too. That much is what the pull alone owns. The other five sixths are in the next equation, and they are the same annihilations counted again.
+          </Para>
+
+          <Head>the same count read as a size — which is a metric</Head>
+
+          <Para>
+            Everything up to here reads a meeting as a <i>direction</i>: which way the leaning went. But the ways out of a folded point no longer number <K><Bar>DEG</Bar></K> — they number <K><Bar>DEG</Bar></K> + <V>n</V>, and <b>a point with more ways out of it holds more space</b>. The lean is the first moment of the count. The total is the zeroth. Both are the same annihilations, read twice, and nobody had read the second one.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What makes it work is that <b>edges point both ways</b>. Those extra edges point <i>into</i> the node as well as out of it, so a charge nearby is (<K><Bar>DEG</Bar></K>+<V>n</V>)/<K><Bar>DEG</Bar></K> times likelier to arrive there. More arrivals, more annihilations, more folding, more arrivals. The increment is proportional to what is already there, and that is what makes it compound.
+          </Para>
+
+          <Eq derive={METRIC} note="an increment proportional to what is already there, which integrates to an exponential with nothing chosen">
+            d<V>u</V> = d<V>u</V><Sub>0</Sub>(1 + <V>u</V>)
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>A</V> = <V>e</V><Sup>−2<V>u</V></Sup>
+            <span style={{ padding: '0 1.2em' }} />
+            <V>B</V> = <V>e</V><Sup>+2<V>u</V></Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>so</span>
+            <V>A</V>·<V>B</V> = 1
+          </Eq>
+
+          <Eq derive={METRIC}
+            note="the same count read as a size rather than a direction — and it is the other five sixths">
+            d<V>s</V><Sup>2</Sup> = −<V>A</V> d<V>t</V><Sup>2</Sup> +
+            <V>B</V>(d<V>x</V><Sup>2</Sup> + d<V>y</V><Sup>2</Sup> + d<V>z</V><Sup>2</Sup>)
+            <span style={{ padding: '0 1.4em' }} />
+            <V>A</V>(<V>s</V>) =
+            <Paren><Frac over={<>1 − <V>s</V></>} under={<>1 + <V>s</V></>} /></Paren><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em' }} />
+            <V>B</V>(<V>s</V>) = (1 + <V>s</V>)<Sup>4</Sup>
+            <span style={{ padding: '0 1.2em' }} />
+            <V>s</V> = <V>u</V>/2
+          </Eq>
+
+          <Para>
+            <V>A</V> is how much slower a clock there runs; <V>B</V> is how many steps a drawn cell holds. They are written closed rather than as a series for a reason worth knowing: the coordinate speed of light is <V>c</V>√(<V>A</V>/<V>B</V>), and a truncated series for <V>A</V> comes back up through one at <V>u</V> = 1, which puts the ceiling <i>above</i> light. Closed, <V>A</V>/<V>B</V> is at most one for any <V>s</V> ≥ 0, so light stays the ceiling as a property of the functions and not as a clamp bolted on.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And the coefficient is not free. <V>A</V> and <V>B</V> carry the <i>same</i> <V>u</V> with the same coefficient, which is the statement that a point's lean and a point's thickness are one event seen twice. That fixes β = γ = 1, so every first-post-Newtonian test comes out identical to <Ref of={'Einstein, "Die Grundlage der allgemeinen Relativitätstheorie", Annalen der Physik 354:769'} year="1916" at="https://doi.org/10.1002/andp.19163540702" />'s: the perihelion advance in full, light's deflection in full, the <Ref of={'Shapiro, "Fourth Test of General Relativity", Phys. Rev. Lett. 13:789'} year="1964" at="https://doi.org/10.1103/PhysRevLett.13.789" /> delay. It is also the sharpest thing here to be wrong about, since <Ref of={'Bertotti, Iess & Tortora, "A test of general relativity using radio links with the Cassini spacecraft", Nature 425:374'} year="2003" at="https://doi.org/10.1038/nature01997" /> has γ<Sub>PPN</Sub> = 1 + (2.1 ± 2.3)·10<Sup>−5</Sup>.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Measured through the model's own dynamics rather than read off the metric, the five orbits come to <b>6.05, 6.08, 6.07, 6.11 and 6.22 sixths</b> of 6π<V>GM</V>/<V>c</V><Sup>2</Sup><V>a</V>(1−<V>e</V><Sup>2</Sup>), ordered by how deep the orbit sits and by nothing else, with the ellipse coming back at −0.00% on every one. And a ray traced through √(<V>B</V>/<V>A</V>) grazing the Sun bends by the whole 4<V>GM</V>/<V>bc</V><Sup>2</Sup> rather than half of it — the <Ref of={'Dyson, Eddington & Davidson, "A Determination of the Deflection of Light by the Sun\'s Gravitational Field", Phil. Trans. R. Soc. A 220:291'} year="1920" at="https://doi.org/10.1098/rsta.1920.0009" /> measurement, and the one number the pull alone got entirely wrong.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The last piece of the law is <i>carry</i> — what one meeting is worth <i>where</i> it happened, which is one wherever nothing is going on. It is not borrowed either: the rate at which a charge reverses thins as 1/(<K><Bar>DEG</Bar></K>+<V>n</V>), which is √<V>A</V> exactly, so <b>gravitational time dilation is the edge count thinning out the reversals</b> — and stationary phase on ω<V>τ</V> then reproduces the geodesic equation, matching Euler–Lagrange to 10<Sup>−7</Sup>.
+          </Para>
+
+          <Eq derive={METRIC} note="what one meeting is worth where it happened">
+            carry = −
+            <Frac over={<><V>A</V>′ + (<V>A</V>/<V>B</V>)′|<B>u</B>|<Sup>2</Sup>/<V>c</V><Sup>2</Sup></>}
+              under={<>2<V>H</V></>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>with</span>
+            <V>H</V> = √(<V>A</V>(1 + |<B>u</B>|<Sup>2</Sup>/<V>B c</V><Sup>2</Sup>))
+          </Eq>
+
+          <Head>where the space itself comes from</Head>
+
+          <Para>
+            <V>B</V> needs one thing the pull did not, and it is worth being explicit about. The pull only ever asked what a meeting does to a <i>lean</i>. <V>B</V> asks what a meeting does to the <i>amount</i> of space, and that is three rewrites and nothing else.
+          </Para>
+
+          <Eq derive={SPACE}
+            note="making a charge makes space; a meeting takes it back; a move carries it">
+            neutral &nbsp;→&nbsp; + &nbsp;−
+            <span style={{ padding: '0 1.4em', color: FAINT }}>+1</span>
+            + &nbsp;− &nbsp;→&nbsp; neutral
+            <span style={{ padding: '0 1.4em', color: FAINT }}>−1</span>
+            move
+            <span style={{ padding: '0 0.8em', color: FAINT }}>0</span>
+          </Eq>
+
+          <Para>
+            So a body of mass <V>m</V>, letting go of <V>m</V>·<K><Bar>SHEET</Bar></K> charges a tick and paying a neutral point for each, is a <b>point source of space</b> — at the body, not spread through its field. That distinction is the whole thing: a source spread as 1/<V>r</V><Sup>2</Sup> gives a logarithm, and a point gives a potential. The moves then carry the surplus away as fast as it is made, which is what makes the profile <i>static</i> rather than growing without bound, and a carried point source settles to a Green's function.
+          </Para>
+
+          <Eq derive={MADE_FROM}
+            note="a point source settles to a potential — if something carries the surplus away, and that is the whole difficulty">
+            <Frac over={<>∂<V>δ</V></>} under={<>∂<V>t</V></>} /> =
+            <V>D</V>∇<Sup>2</Sup><V>δ</V> + <V>S</V>·<V>δ</V><Sup>3</Sup>(<V>x</V>)
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>δ</V>(<V>r</V>) = <Frac over={<V>S</V>} under={<>4<V>π D r</V></>} /> = 3<V>u</V>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>u</V> = <Frac over={<V>Gm</V>} under={<><V>r c</V><Sup>2</Sup></>} />
+          </Eq>
+
+          <Para>
+            That is the metric's own potential out of a rate and a spread, and — this is what the folding could never say — it is linear in the <i>other</i> mass alone. It is a fact about a <b>place</b> rather than about a pair, so it can be asked anywhere, not only at a body.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Requiring it to come out at <V>B</V> = 1 + 2<V>u</V> fixes the creation rate and the transport outright, and both come out as pure counts with nothing drawn in them:
+          </Para>
+
+          <Eq derive={MADE_FROM} note="a pure count each, order one, and no grain in either">
+            <V>ε</V> = <Frac over={<>3 <K><Bar>BITE</Bar></K> <K><Bar>SHEET</Bar></K></>}
+              under={<><V>π</V> <K><Bar>DEG</Bar></K></>} /> = 0.2938
+            <span style={{ padding: '0 1.4em' }} />
+            <V>D</V> = <Frac over={<><V>π</V> <K><Bar>DEG</Bar></K> <K><Bar>c</Bar></K></>}
+              under={<>3 <K><Bar>BITE</Bar></K> <K><Bar>SHEET</Bar></K></>} /> =
+            <V>c</V>/<V>ε</V> = 3.4034
+          </Eq>
+
+          <Para>
+            <b>And I should say plainly that this is the shakiest step on the page.</b> Two things about it are not earned. The identification ∫<V>δ</V> = 3<V>u</V> is a <i>choice</i> — it says a volume excess is three times the linear one, which is true of a metric and is not forced by any lattice rule. And <V>D</V> is not free: for anything moving at <V>c</V> a diffusivity is <V>cλ</V>/3, so this demands a mean free path of about ten cells, and the only constant-density scatterer the model has is the vacuum below, whose length comes out at 10<Sup>60</Sup>. Fifty-nine orders apart.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What survives is a route with no scatterer in it at all: a created point that <i>sits</i> for a tick and then takes one of the <K><Bar>DEG</Bar></K> at random is a random walk, so <V>D</V> = ⟨ℓ<Sup>2</Sup>⟩/6 = 0.3462 is a fact about the lattice and the vacuum never enters. Measured on the lattice it gives the Green's function to 0.1% and it is static. It also gives gravity 9.83 times too strong, and the fix is <i>persistence</i> — with mean cosine <V>p</V> between steps, <V>D</V> scales by (1+<V>p</V>)/(1−<V>p</V>), so <V>p</V> = 0.815: keep your heading about 85% of the time, a run of 5.42 steps. <b>Which the lattice may simply do, and nothing here derives.</b> That is the one link the gravity arc owes.
+          </Para>
+
+          <Head>waves interfering — two of the same thing</Head>
+
+          <Para>
+            Now the thing you'd expect a wave model to say and that this one does say. <i>share</i> above was a half, and I called it a stipulation. It isn't one — it is what being made of things does.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Nothing elementary weighs more than about 1.36 µg, and the Sun is 1.2·10<Sup>57</Sup> nucleons. A sum of that many emitters with no reason to agree has a uniform phase, and the average of <i>opposed</i> over a uniform phase is exactly one half. <b>So share = ½ is derived for anything made of parts</b>, and everything in the panels is made of parts.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            But two of the <i>same</i> elementary thing do share a phase, because ω <i>is</i> the mass, so their rates are equal by construction and they hold a fixed relation for as long as they exist.
+          </Para>
+
+          <Eq derive={IDENTICAL} note="in step and close together, there is no gravity between them at all">
+            <V>ω</V> = <V>m</V>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>so one wavelength is</span>
+            2<V>π</V>/<V>m</V> = 2<V>πG</V><V>λ</V><Sub>C</Sub>
+            <span style={{ padding: '0 1.4em' }} />
+            <V>G</V><Sub>eff</Sub>/<V>G</V> = 2 · share ∈ [0, 2]
+          </Eq>
+
+          <Para>
+            Read the two limits off directly. <b>In step and closer than a Compton wavelength there is no gravity between them at all</b> — they put out the same sign at the same moment, so nothing cancels, so nothing is annihilated, so the interval between them does not shorten. Out of step, every meeting cancels and the pull is doubled. Measured on the coherence walk, <V>R</V>/<V>λ</V> = 0.02 gives 0.02 and 1.98; at 0.5 it is 0.59 and 1.41; and beyond one wavelength both settle to the ordinary law.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Inside <V>λ</V><Sub>C</Sub> that is not a correction to gravity. It is a different interaction, and one that already knows about phase — which arrived without anything quantum being put anywhere near it.
+          </Para>
+
+          <Head>screening, three times over</Head>
+
+          <Para>
+            <K>through</K> now does its real work, and it does it at three scales at once. All three are the same statement: <i>a charge that meets something on the way does not arrive</i>.
+          </Para>
+
+          <Rows of={[
+            [<>a third body</>,
+              <>The <K>screen</K> factor in <V>S</V><Sub>ab</Sub> above. Short-ranged,
+                because <K>chance</K> is, so it shows up in a close pass and nowhere else.</>],
+            [<>a body against itself</>,
+              <>A body's own charges annihilate against its own field on the way out, so only
+                a skin ever reaches the outside and <b>a body looks lighter than it is</b>.
+                The surface screening is exactly <K><Bar>SKIN</Bar></K> = √2/5, and the
+                aggregate is an <i>area</i> law rather than a volume one. Ordinary matter is
+                transparent — <V>R</V>/<V>λ</V> is 10<Sup>−8</Sup> for the Earth and
+                3·10<Sup>−5</Sup> for the Sun — so nothing anywhere the model was tested
+                moves.</>],
+            [<>everyone else's charges</>,
+              <>The ambient fog, below. This one has a range in it, and the range is where
+                gravity stops.</>],
+          ]} />
+
+          <Head>the vacuum, and how far gravity reaches</Head>
+
+          <Para>
+            Every source in the universe is putting charges everywhere, so any place at all holds a thin fog of everyone else's. Add up what a shell of the universe at <V>r</V> contributes and you get a surprise that is older than this model: a shell holds <V>ρ</V>·4π<V>r</V><Sup>2</Sup>d<V>r</V> of mass and puts <V>m</V><K><Bar>SHEET</Bar></K>/4π<V>r</V><Sup>2</Sup> on you, so the <V>r</V><Sup>2</Sup> cancels and <b>every shell counts the same</b>. That is <Ref of={'Olbers, "Über die Durchsichtigkeit des Weltraums", Astronomisches Jahrbuch für das Jahr 1826'} year="1823" at="https://articles.adsabs.harvard.edu/pdf/1826AJ......1..110O" />' paradox in a new costume, and the sum does not converge.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            It converges because it <i>screens itself</i>. Those distant charges were attenuated by the fog they had to cross to reach you, so the density and the range have to be solved together.
+          </Para>
+
+          <Eq derive={REACH} note="solve the two together and the integral is finite">
+            <V>Φ</V> = <V>ρ</V><K><Bar>SHEET</Bar></K><V>λ</V>
+            <span style={{ padding: '0 1.2em' }} />
+            <V>λ</V> = 1/<V>k</V><V>Φ</V>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>λ</V> = 1/√(<V>k</V>·<K><Bar>SHEET</Bar></K>·<V>ρ</V>)
+            <span style={{ padding: '0 1.2em', color: FAINT }}>with</span>
+            <V>k</V> = <K><Bar>BITE</Bar></K>·share
+          </Eq>
+
+          <Para>
+            And a body's own charges are attenuated by the same fog on their way to wherever they were going. The two attenuations multiply, wherever along the line the meeting happens, so the pull picks up an exponential that nothing in it was designed to have.
+          </Para>
+
+          <Eq derive={REACH} note="the pull is Yukawa, and nothing here was built to make it one">
+            <V>S</V>(<V>a</V>,<V>b</V>) ∝
+            <Frac over={<>e<Sup>−<V>R</V>/<V>λ</V></Sup></>}
+              under={<><V>R</V><Sup>2</Sup></>} />
+            <span style={{ padding: '0 1.6em' }} />
+            <Frac over={<V>λ</V>} under={<><V>R</V><Sub>h</Sub></>} /> =
+            √<Paren><Frac over={<>8<V>π G</V></>}
+              under={<>3 <K><Bar>BITE</Bar></K>·share·<K><Bar>SHEET</Bar></K></>} /></Paren> = 0.361
+          </Eq>
+
+          <Para>
+            <b>Gravity is <Ref of={'Yukawa, "On the Interaction of Elementary Particles. I", Proc. Phys.-Math. Soc. Japan 17:48'} year="1935" at="https://doi.org/10.11429/ppmsj1919.17.0_48" />, out of a model that has no field theory in it</b> — a range appears because the carriers get eaten, and that is all.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            I liked that number a great deal and then had to take most of it back, so it is worth walking through. Getting the density to cancel — "gravity reaches a third of the way to the horizon in <i>any</i> universe this model describes, because a denser one screens harder in exactly the proportion that it expands faster" — used <V>ρ</V> = 3<V>H</V><Sup>2</Sup>/8π<V>G</V>. <b>That is Friedmann, and the cosmology below has no Friedmann equation; it coasts.</b> What survives is <V>λ</V>/<V>R</V><Sub>h</Sub> = 0.361/√<V>Ω</V>, and this model has no dark matter and no dark energy, so the density doing the screening is the <i>baryon</i> one — <V>Ω</V> ≈ 0.049 from <Ref of={'Planck Collaboration, "Planck 2018 results. VI. Cosmological parameters", A&A 641:A6'} year="2020" at="https://doi.org/10.1051/0004-6361/201833910" />, hence 1.63, hence gravity reaching half again <i>past</i> the horizon. The prediction does not become wrong. It becomes unfalsifiable, which here is the worse of the two.
+          </Para>
+
+          <Head>where space is made — the frontier, and a Hubble law</Head>
+
+          <Para>
+            The rules fix a cosmology whether or not one was wanted, because matter makes space and meetings unmake it and the net is what escapes. Asked for the observed <V>H</V>, the version where space is made throughout the bulk fails seven separate ways, and the fatal one is that <b>the pairs which make the space <i>are</i> the fog that stops the gravity</b> — one <V>Φ</V>, two jobs, opposite values, thirty-five orders apart.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The way out is to notice that "space is made in the bulk" was an assumption nobody argued for. Put the creation only where there is <i>no space yet</i>. A cell on the <b>frontier</b> has nothing on one side, so a charge emitted outward meets nothing ever and never gives its point back — and that point is new space. A charge emitted inward meets the bulk and annihilates. The interior makes none at all, which dissolves five of the seven at once.
+          </Para>
+
+          <Eq derive={REACH} note="one pulse a cell a tick is the ceiling — so it is also the rate">
+            <K><Bar>ADVANCE</Bar></K> = <K><Bar>SHEET</Bar></K>/2 = 4
+            <span style={{ padding: '0 1.2em', color: FAINT }}>cells of budget for the 1 it needs</span>
+            <Frac over={<>d<V>R</V></>} under={<>d<V>t</V></>} /> = 1
+            <span style={{ padding: '0 0.6em', color: FAINT }}>cell/tick</span> = <V>c</V>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>R</V> = <V>ct</V>
+          </Eq>
+
+          <Para>
+            Then a Hubble law by pure kinematics, with no metric expansion in it anywhere. Matter that left the origin at <V>t</V> = 0 and free-streams sits at <V>x</V> = <V>vt</V>, so any two of them separate at <V>r</V>/<V>t</V> and <b>every</b> observer inside sees the same thing.
+          </Para>
+
+          <Eq note="no metric expansion, no stretched wavelengths, no tired light — ordinary Doppler">
+            <V>v</V> = <V>H r</V>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>with</span>
+            <V>H</V> = 1/<V>t</V>
+            <span style={{ padding: '0 1.4em' }} />
+            <V>t</V><Sub>0</Sub> = 1/<V>H</V><Sub>0</Sub>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>exactly, with nothing to fit</span>
+          </Eq>
+
+          <Para>
+            The age is then <i>forced</i> rather than fitted, which is the sort of thing a model with no freedom in it does: 14.51 Gyr at <V>H</V><Sub>0</Sub> = 67.4 and 13.39 Gyr at 73.0, against a measured 13.80 ± 0.02. <b>The Hubble tension brackets it</b> — the <Ref of={'Planck Collaboration, "Planck 2018 results. VI. Cosmological parameters", A&A 641:A6'} year="2020" at="https://doi.org/10.1051/0004-6361/201833910" /> value on one side and <Ref of={'Riess et al., "A Comprehensive Measurement of the Local Value of the Hubble Constant", ApJL 934:L7'} year="2022" at="https://doi.org/10.3847/2041-8213/ac5c5b" />'s on the other — and in its own units the universe is 8.49·10<Sup>60</Sup> ticks old and 8.49·10<Sup>60</Sup> cells in radius, the same number, which is what <V>R</V> = <V>ct</V> means.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>And then it fails the supernovae, which is the honest end of this part.</b> A coasting universe is <V>q</V><Sub>0</Sub> = 0 exactly, with no <V>Ω</V>, no <V>Λ</V> and no freedom anywhere; the measured value is −0.55 ± 0.05. Marginalising the absolute magnitude away — which is a fair defence, since only the shape counts — the residual against ΛCDM runs +0.072 mag at <V>z</V> = 0.02, through zero near 0.18, to −0.130 at <V>z</V> = 1: 0.061 mag rms and <i>monotonic</i>, where <Ref of={'Scolnic et al., "The Pantheon+ Analysis: The Full Data Set and Light-curve Release", ApJ 938:113'} year="2022" at="https://doi.org/10.3847/1538-4357/ac8b7a" /> bins carry 0.02–0.03. And the shape of that residual — nearby too bright, distant too faint — is precisely the one <Ref of={'Riess et al., "Observational Evidence from Supernovae for an Accelerating Universe and a Cosmological Constant", AJ 116:1009'} year="1998" at="https://doi.org/10.1086/300499" /> and <Ref of={'Perlmutter et al., "Measurements of Ω and Λ from 42 High-Redshift Supernovae", ApJ 517:565'} year="1999" at="https://doi.org/10.1086/307221" /> found and named acceleration.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            There is worse, and it is structural rather than numerical. A charge arriving at an occupied cell has exactly two outcomes and no third — annihilate, or reverse — and both are extinction. A step is one cell and a heading is one of <K><Bar>DEG</Bar></K>, so there is no soft forward channel anywhere in the rules: <b>the lattice can dim light and it cannot redden it</b>, and by the same missing channel it cannot move energy between frequencies either. <Ref of={'Fixsen et al., "The Cosmic Microwave Background Spectrum from the Full COBE FIRAS Data Set", ApJ 473:576'} year="1996" at="https://doi.org/10.1086/178173" /> has the microwave background as a blackbody to a part in 10<Sup>5</Sup>, and this model has no mechanism that would produce one <i>at any temperature</i>.
+          </Para>
+
+          <Head>the carriers slow where they are thin</Head>
+
+          <Para>
+            One last mechanism, and it is the one that touches a measurement hardest. There is a theorem in the way of the obvious approach, so it is worth stating first: action and reaction gives <V>m</V><Sub>a</Sub><V>h</V>(<V>m</V><Sub>b</Sub>) = <V>m</V><Sub>b</Sub><V>h</V>(<V>m</V><Sub>a</Sub>), and equivalence gives <V>F</V> = <V>m</V><Sub>a</Sub>·<V>h</V>(<V>m</V><Sub>b</Sub>); together they force <V>F</V> ∝ <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> exactly, with no freedom at all. <b>So no two-body force law can give √<V>M</V></b> — which is what the baryonic Tully–Fisher slope of 3.85 ± 0.09 measured by <Ref of={'Lelli, McGaugh, Schombert & Desmond, "The baryonic Tully-Fisher relation for different velocity definitions and implications for galaxy angular momentum", MNRAS 484:3267'} year="2019" at="https://doi.org/10.1093/mnras/stz205" /> demands. The non-linearity cannot go in the source. It has to go in the <i>transport</i>.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And there is already a rule for that. Speed here is a budget between moving and updating, so a carrier that has to spend ticks on itself drifts below <V>c</V> — and emitters within a common phase pay the update <i>once between them</i>, so a dense field is a fast one and a thin field is a slow one. No new rule.
+          </Para>
+
+          <Eq note="the drift, and flux conservation with it">
+            <V>v</V> = <V>c</V>·min(1, <V>n</V>/<V>n</V><Sub>c</Sub>)
+            <span style={{ padding: '0 1.6em', color: FAINT }}>,</span>
+            <V>Φ</V> = 4π<V>r</V><Sup>2</Sup>·<V>n</V>·<V>v</V> = constant
+          </Eq>
+
+          <Para>
+            Dense, and <V>v</V> = <V>c</V>, so <V>n</V> ∝ 1/<V>r</V><Sup>2</Sup>: Newton. Thin, and <V>v</V> ∝ <V>n</V>, so flux conservation goes <i>quadratic</i> and <V>n</V> ∝ √<V>Φ</V>/<V>r</V> — which is <b>both halves at once</b>, the 1/<V>r</V> law and, since <V>Φ</V> ∝ <V>M</V>, an effective source going as √<V>M</V>. Measured by integrating the transport: slope −2.0000 inside, −1.0000 outside, and the outer density against √<V>Φ</V> comes to 10.0000 for a hundredfold mass. <b>That is the non-linearity the theorem demanded, living in the one place the theorem allows it.</b>
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The turnover between the two is not borrowed either, which every earlier version of this quietly assumed. <K>through</K> again: a point already carrying a charge is <i>busy</i> — an arriving charge annihilates or reverses, and either way that point does not split this tick — so splitting is suppressed exactly where the carrier density is high, which by <V>g</V> ∝ <V>n</V> is where the field is strong. Occupancy θ = <V>g</V>/<V>a</V><Sub>0</Sub>, free fraction 1/(1+θ), and it closes on itself.
+          </Para>
+
+          <Eq note="occupancy θ = g/a₀, free fraction 1/(1+θ), and it closes">
+            <V>g</V> = <V>g</V><Sub>N</Sub>·(1 + <V>a</V><Sub>0</Sub>/<V>g</V>)
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>g</V> = <Frac over={<><V>g</V><Sub>N</Sub></>} under={<>2</>} /> + √(
+            <Frac over={<><V>g</V><Sub>N</Sub><Sup>2</Sup></>} under={<>4</>} /> +{' '}
+            <V>g</V><Sub>N</Sub><V>a</V><Sub>0</Sub>)
+          </Eq>
+
+          <Para>
+            <b>That is the "simple" interpolation function</b> — the one <Ref of={'Famaey & Binney, "Modified Newtonian dynamics in the Milky Way", MNRAS 363:603'} year="2005" at="https://doi.org/10.1111/j.1365-2966.2005.09474.x" /> pick by hand out of a family for <Ref of={'Milgrom, "A modification of the Newtonian dynamics as a possible alternative to the hidden mass hypothesis", ApJ 270:365'} year="1983" at="https://doi.org/10.1086/161130" />'s theory — and here it is derived rather than chosen. Over six decades <V>g</V>/<V>g</V><Sub>N</Sub> runs 31.7, 10.5, 3.70, 1.62, 1.10, 1.010, 1.0010 against a deep limit √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>) of 31.6, 10.0, 3.16 — agreeing where it should and parting where it should.
+          </Para>
+
+          <Head>and the scale is not fitted either</Head>
+
+          <Para>
+            What sets the threshold is the thing the model is <i>about</i>: space being made. Making space has a rate, that rate is <V>H</V>, an acceleration built from it is <V>cH</V>, and the frontier already forces <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> exactly — so <V>cH</V><Sub>0</Sub> is a count of ticks and not a constant anybody chose.
+          </Para>
+
+          <Eq note="the acceleration scale, with nothing fitted in it">
+            <V>a</V><Sub>0</Sub> = <Frac over={<><V>c</V> <V>H</V><Sub>0</Sub></>} under={<>2π</>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            1.096·10<Sup>−10</Sup> m/s²
+            <span style={{ padding: '0 1.2em', color: FAINT }}>vs</span>
+            1.200·10<Sup>−10</Sup> measured
+          </Eq>
+
+          <Para>
+            <b>Nine percent, with nothing fitted anywhere.</b> And it explains a coincidence that is an embarrassment everywhere else — why should a galaxy know the age of the universe? Here it is not being told the age; it is being told the rate at which space is made, which is the same number because the frontier makes it so. <b>The cosmology and the rotation curves become one fact.</b> Run on the Milky Way with that predicted <V>a</V><Sub>0</Sub> and nothing fitted at all, the ratio to the curve <Ref of={'Eilers, Hogg, Rix & Ness, "The Circular Velocity Curve of the Milky Way from 5 to 25 kpc", ApJ 871:120'} year="2019" at="https://doi.org/10.3847/1538-4357/aaf648" /> measure from Gaia runs 0.977 · 0.997 · 0.999 · 0.995 · 0.987 · 0.987 · 1.002 · 1.028 from 6 to 30 kpc — 1.1% rms, where Newton alone runs 0.83 down to 0.54.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And there is a debt in it that has to be said. There are <i>two</i> routes to <V>a</V><Sub>0</Sub> here and they do not agree — one counts meetings over a carrier's lifetime and gives 4π<V>G</V>/(<K><Bar>SHEET</Bar></K><V>t</V><Sub>0</Sub>), the other takes the rate space is made and gives <V>cH</V><Sub>0</Sub>/2π — and they differ by a pure count.
+          </Para>
+
+          <Eq note="a factor built from the number of exits from a cell and the size of a sheet, and nothing else">
+            <Frac over={<><V>c</V><V>H</V><Sub>0</Sub>/2π</>}
+              under={<>4π<V>G</V>/(<K><Bar>SHEET</Bar></K><V>t</V><Sub>0</Sub>)</>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            <Frac over={<K><Bar>DEG</Bar></K>} under={<>2 <K><Bar>SHEET</Bar></K></>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            13/8 = 1.6250
+          </Eq>
+
+          <Para>
+            So one of the two is miscounting by 13/8, and finding which turns a 9% agreement into a derivation or kills it outright. That is a much better place to be stuck than two rival numbers: the disagreement is not about physics, it is about which count is the right one, and it can be settled by reading a derivation rather than by measuring anything.
+          </Para>
+
+          <Head>the anisotropy, and a step in a rotation curve</Head>
+
+          <Para>
+            One prediction comes back out of the lattice that nothing else has a reason to make. If a carrier streaming along <V>ĝ</V> occupies the cell in that direction, the split cannot go that way — the pair is emitted with the field direction <i>removed</i>, so the space made around a mass is not a sphere. The obvious worry is that an anisotropy varying with radius would change the <i>shape</i> of a rotation curve and not just its scale.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            It does not, and the lattice is why. The 26 exits from a cell have only <b>three distinct direction cosines</b> — 1 for the six faces, 1/√2 for the twelve edges, 1/√3 for the eight corners — so the projection is a <i>step</i> function with four values: 0.4721, 0.4510, 0.4022, 0.3610. A galaxy spans <V>g</V>/<V>a</V><Sub>0</Sub> from 0.34 at 30 kpc to 4.84 at 2 kpc and never crosses a step. The expansion around it is genuinely not a sphere, but it is one of <i>four discrete shapes</i>, and a galaxy sits in one of them throughout.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>But a galaxy is not the whole of anything.</b> Far enough out the occupancy does cross a step, and when it does <V>a</V><Sub>0</Sub> jumps by a fixed ratio — which is a <b>discontinuity in a rotation curve at a radius the model computes from the baryons alone</b>. For the Milky Way that is 33 and 52 kpc; for a big spiral 58 and 90; for a dwarf 6 and 9 kpc, inside the stellar body where a curve is easiest to measure. Since <V>v</V> ∝ <V>a</V><Sub>0</Sub><Sup>¼</Sup>, the jumps are 1.1%, 2.8% and 2.7% — two to six km/s on a 200 km/s curve, but <i>sharp</i>, and with nothing to tune. MOND has no reason for a curve to be anything but smooth, and a dark-matter halo is smooth by construction.
+          </Para>
+
+          <Head>what a black hole is here</Head>
+
+          <Para>
+            <V>A</V> = <V>e</V><Sup>−2<V>u</V></Sup> never reaches nought, so <b>there are no horizons</b>. √<V>A</V> = 0 would need <V>n</V> = ∞ — a node with infinitely many ways out — and each annihilation adds one while a finite mass sends finitely many charges. At what general relativity calls the horizon the node has 6.4 extra ways out per <K><Bar>DEG</Bar></K>: a lot, and not infinity. Light leaves, redshifted by <V>e</V><Sup>2</Sup> = 7.4. Things get arbitrarily red and arbitrarily slow and never quite vanish.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What the exponential does have is a <b>throat</b>. Ask where the areal radius stops shrinking and it has a minimum, inside which the area grows again without bound — a narrow neck opening into something vast, at a ratio that is the same at every scale.
+          </Para>
+
+          <Eq derive={METRIC} note="the area does not shrink to nothing — it has a narrowest point, and inside it grows again">
+            areal(<V>r</V>) = <V>r</V>·<V>e</V><Sup><V>GM</V>/<V>rc</V><Sup>2</Sup></Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>minimal at</span>
+            <V>r</V> = <V>GM</V>/<V>c</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>r</V><Sub>areal</Sub> = <V>e</V>·<V>GM</V>/<V>c</V><Sup>2</Sup> =
+            1.3591 <V>R</V><Sub>s</Sub>
+          </Eq>
+
+          <Para>
+            And the photon sphere is where d/d<V>r</V>(<V>r</V><Sup>2</Sup><V>B</V>/<V>A</V>) = 0; with <V>B</V>/<V>A</V> = <V>e</V><Sup>4<V>u</V></Sup> that is 2<V>r</V> = 4<V>GM</V>, so the shadow's impact parameter <V>b</V> = <V>r</V>√(<V>B</V>/<V>A</V>) has a closed form that differs from <Ref of={'Schwarzschild, "Über das Gravitationsfeld eines Massenpunktes nach der Einsteinschen Theorie", Sitzungsber. Preuss. Akad. Wiss. 189'} year="1916" at="https://articles.adsabs.harvard.edu/pdf/1916SPAW.......189S" />'s by a fixed ratio at every mass.
+          </Para>
 
-        <Eq>
-          <K>l.<Bar>D</Bar></K> = number of dimensions
-          <span style={{ padding: '0 1.6em' }} />
-          <K><Bar>D</Bar></K> = 3
-        </Eq>
+          <Eq derive={METRIC} note="and this is the one number in the whole model that an instrument can settle now">
+            <V>b</V> = 2<V>e</V>·<V>GM</V>/<V>c</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>against</span>
+            3√3·<V>GM</V>/<V>c</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            1.0463
+          </Eq>
 
-        <span style={{textAlign: 'left', width: '100%'}}>You're allowed to change the <K><Bar>D</Bar></K> ofc. But unless otherwise specified variables have these default values.</span>
+          <Para>
+            <b>The shadow is 4.6% larger than general relativity's at the same mass.</b> Measure the mass from orbits and the shadow from imaging, and this predicts a constant mismatch between them — which sits inside the <Ref of={'Event Horizon Telescope Collaboration, "First M87 Event Horizon Telescope Results. I. The Shadow of the Supermassive Black Hole", ApJL 875:L1'} year="2019" at="https://doi.org/10.3847/2041-8213/ab0ec7" /> present ~10% systematic error and outside what it is aiming for. That makes it a near-term test rather than a philosophical one, and it is the only claim on this page an existing instrument can settle.
+          </Para>
 
-        <BR/>
+          <Head>and two things that fell out that nobody asked for</Head>
 
-        <span style={{textAlign: 'left', width: '100%'}}>There's one important piece of gravity that we'll discover and that is in order to reach the desired 1/R<Sup><K><Bar>D</Bar></K> - 1</Sup> of the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "inverse-square law", link: "https://en.wikipedia.org/wiki/Inverse-square_law"}}/>. It happens that as we'll discover in a moment, if we'd send out discrete pulses of our 'gravity-rays' (so the ones causing annihilation). That we can recover the intensity of gravity in a neat way based on the dimensionality of our space. This is our sheet. The sheet we pulse a beam towards. In order to cover our whole space, we'll be rotating this sheet in 1 more dimension than it's defined.</span>
+          <Para>
+            Two results arrived from the same identity — mass is a rate — and neither was aimed at. The first is <V>E</V> = ħω, which is the Compton relation above read forwards. The second is the matter wave, and it needed one more thing: a source pulses at its own rate and a place carries the phase the source had when the shell left, so a <i>moving</i> source has two retarded branches — blue ahead, red behind — and if you know how fast it is going but not <i>where</i>, you do not know which branch applies.
+          </Para>
 
-        <Sheet />
+          <Eq derive={IGNORANCE} note="weight the two branches by how likely you are to be on each side, and at a half it is de Broglie exactly">
+            <V>φ</V> = <V>ωγ</V>(<V>t</V> − <V>vx</V>/<V>c</V><Sup>2</Sup>)
+            <span style={{ padding: '0 1.2em', color: FAINT }}>at <V>p</V> = ½</span>
+            <V>λ</V> = <V>λ</V><Sub>C</Sub>/<V>γβ</V> = <V>h</V>/<V>p</V>
+          </Eq>
 
-        <Eq>
-          <K>l.<Bar>SHEET</Bar></K> = <>3<Sup><K>l.<Bar>D</Bar></K> - 1</Sup> - 1</>
-        </Eq>
+          <Para>
+            Measured to nine figures at every β and every <V>x</V>, and it is not a dial with <Ref of={'de Broglie, "Recherches sur la théorie des quanta", thesis, Ann. de Physique 10(3):22'} year="1924" at="https://doi.org/10.1051/anphys/192510030022" />'s answer somewhere on it: at <V>p</V> = 0.4 or 0.6 the wavelength is 20–40% off, and at <V>p</V> = (1−β)/2 the wavenumber is exactly zero and past that the wave runs backwards. One number, and it puts the phase equal to the relativistic free action.
+          </Para>
 
-        <BR/>
+          <BR/>
 
-        Then the related number, all possible paths out of a point (the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "degree", link: "https://en.wikipedia.org/wiki/Degree_(graph_theory)"}}/> assuming diagonals are included). 
+          <Para>
+            And counting the emitter's options rather than the charge's gives the rest. One action a tick — move, or update your own state — with the spare ticks spent on <i>direction</i> rather than on idling, is a local rule with one global tick whose transfer matrix gives cos<V>Ω</V> = cos<V>m</V>·cos<V>k</V>, hence <V>Ω</V><Sup>2</Sup> = <V>k</V><Sup>2</Sup> + <V>m</V><Sup>2</Sup> to six figures, time dilation, and the amplitude rule that <Ref of={'Feynman & Hibbs, "Quantum Mechanics and Path Integrals", problem 2-6'} year="1965" at="https://archive.org/details/quantummechanics0000feyn_d3y1" /> had to postulate — cos<Sup><V>N</V>−<V>R</V></Sup><V>m</V>·sin<Sup><V>R</V></Sup><V>m</V>, unitary for free. <b>The amplitude rule is the pulse rate.</b>
+          </Para>
 
-        <Eq>
-          <K>l.<Bar>DEG</Bar></K> = <>3<Sup><K>l.<Bar>D</Bar></K></Sup> - 1</>
-        </Eq>
+          <Head>the whole chain, in one place</Head>
 
-        It turns out that this is all the machinary we need to derive gravitational laws that approximate <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "Newtonian gravity", link: "https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation"}}/> and <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "General relativity", link: "https://en.wikipedia.org/wiki/General_relativity"}}/> and go beyond them.
+          <Rows of={[
+            [<>a pulse over a shell</>,
+              <>chance = <V>m</V><K><Bar>SHEET</Bar></K>/shell(<V>r</V>) — <b>the inverse
+                square</b>, as a fixed count over a growing shell, and 1/<V>r</V>
+                <Sup><K><Bar>D</Bar></K>−1</Sup> in general</>],
+            [<>two of them in a cell</>,
+              <><V>S</V><Sub>ab</Sub> = <K><Bar>BITE</Bar></K>·share·screen·<V>m</V><Sub>a</Sub>
+                <V>m</V><Sub>b</Sub>·EMIT<Sup>2</Sup>·met(<V>R</V>) — the meeting rate, and
+                a screening term Newton has no name for</>],
+            [<>along the line</>,
+              <>met(<V>R</V>) = 4/(<K><Bar>CORE</Bar></K><V>R</V><Sup>2</Sup>)·(1 +
+                (<K><Bar>CORE</Bar></K>/<V>R</V>)ln((<V>R</V>−<K><Bar>CORE</Bar></K>)/
+                <K><Bar>CORE</Bar></K>)) — <b>Newton, times a bracket that goes to one</b></>],
+            [<>read as a direction</>,
+              <><K><Bar>BIAS</Bar></K> = <K><Bar>c</Bar></K>/<K><Bar>DEG</Bar></K> ⇒ the law,
+                <b> the equivalence principle</b>, 1/<V>γ</V><Sup>3</Sup> and 1/<V>γ</V>, and
+                one sixth of Mercury</>],
+            [<>read as a size</>,
+              <><V>A</V> = <V>e</V><Sup>−2<V>u</V></Sup>, <V>B</V> = <V>e</V><Sup>+2<V>u</V></Sup>
+                ⇒ <b>a metric with β = γ = 1</b>, the geodesic equation, the other five
+                sixths, and the whole of light's deflection</>],
+            [<>and the constant</>,
+              <><V>G</V> = <K><Bar>BITE</Bar></K>·share·<K><Bar>SHEET</Bar></K><Sup>2</Sup>
+                <K><Bar>c</Bar></K>/(4π<Sup>2</Sup><K><Bar>CORE</Bar></K><K><Bar>DEG</Bar></K>)
+                = 0.062351 — <b>every symbol a count</b></>],
+            [<>the vacuum</>,
+              <><V>λ</V> = 1/√(<K><Bar>BITE</Bar></K>·share·<K><Bar>SHEET</Bar></K>·<V>ρ</V>)
+                ⇒ <b>Yukawa</b>, with <V>λ</V>/<V>R</V><Sub>h</Sub> = 0.361/√<V>Ω</V></>],
+            [<>the frontier</>,
+              <>d<V>R</V>/d<V>t</V> = <V>c</V> ⇒ <V>H</V> = 1/<V>t</V>, <b>the age forced to
+                1/<V>H</V><Sub>0</Sub></b>, and <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π</>],
+            [<>the transport</>,
+              <><V>v</V> = <V>c</V>·min(1, <V>n</V>/<V>n</V><Sub>c</Sub>) ⇒ 1/<V>r</V> and
+                √<V>M</V>, and <b>MOND's interpolation function, derived</b></>],
+            [<>and what is owed</>,
+              <>the transport constant behind <V>ε</V> (a carrier keeping its heading 85% of
+                the time), the identification ∫<V>δ</V> = 3<V>u</V>, and which of the two
+                <V> a</V><Sub>0</Sub> routes miscounts by 13/8</>],
+          ]} />
 
-        <BR/>
+          <Para>
+            That is the gravity model, whole. Everything in it is one rule about what happens when two rays land in the same cell, counted twice — once as a direction and once as a size — and every constant in it is a count off the lattice rather than a number read off an instrument.
+          </Para>
 
-        Let's dive into the continuous model to show you how.
+          <BR/>
 
-        <Section head="The Continuous Model">
-          Whenever there's a derived equation, you can click on it to see how it was derived! Try it!
+          <Para>
+            And it has no polarity in it anywhere. Every equation above would be word for word the same with the signs stripped out, which is worth knowing before the next arc puts them back: <b>the gravity here does not depend on the XOR</b>. What the XOR buys is magnetism, and what it costs is one factor that turns out not to be measurable. That is the next section.
+          </Para>
         </Section>
+        <Section head="Galaxy rotation curves">a</Section>
+        <Section head="Black Holes">a</Section>
+        <Section head="Expansion">a</Section>
         <Section head="The Discrete Model">
         </Section>
         <Section head="TODO">
@@ -868,6 +1698,374 @@ const Physics = () => {
         
         <Section head="XOR Continuous Model">
 
+          <Eq derive={TURNS} note="two on a line, and eight at every dimension of two or more">
+            <K>l.<Bar>CYCLE</Bar></K> = ways(min(<K>l.<Bar>D</Bar></K>, 2)) =
+            3<Sup>min(<K>l.<Bar>D</Bar></K>, 2)</Sup> − 1
+            <span style={{ padding: '0 1.4em' }} />
+            <K><Bar>SPIN</Bar></K> =
+            <Frac over={<>2<V>π</V></>} under={<K><Bar>CYCLE</Bar></K>} /> = 45°
+          </Eq>
+
+          <Para>
+            The gravity arc counts <i>one</i> thing about an emitter: how often it lets go. That is mass. This arc keeps the second thing, which is <b>which way round it is when it does</b> — and the whole of the difference between the two models is what you do with a sign.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            So the plan for this section is: first what changes in the rules, then <i>where</i> the two models diverge — which is local and is the interesting part — then why the global answer is nevertheless the same, and then magnetism, which is what the signs buy.
+          </Para>
+
+          <Head>a charge as a number</Head>
+
+          <Para>
+            Give each ray a polarity and write it as a number, because that is the form both readings share: +1, −1, or 0 for neutral space. Then the entire interaction law is one expression.
+          </Para>
+
+          <Eq note="the whole interaction law, and it has exactly two outcomes">
+            agreement(<V>a</V>,<V>b</V>) =
+            <Frac over={<><V>ab</V></>} under={<>|<V>a</V>||<V>b</V>| + <V>ε</V></>} />
+            <span style={{ padding: '0 1.2em' }} />
+            alike = max(agreement, 0)
+            <span style={{ padding: '0 1.2em' }} />
+            cancelling = max(−agreement, 0)
+          </Eq>
+
+          <Para>
+            Alike is +1 and neither can cancel the other and neither can pass through it, so each turns around — that is (G+M/3). Opposite is −1 and they annihilate, taking the space they were on with them — that is (G+M/1), and it is the only event in the model that changes how much space there is. <b>Nothing in between ever happens to a pair on the lattice</b>, because a lattice charge is ±1 and the product of two of those is ±1.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            In between is what a <i>field</i> does, and it is not a third outcome — it is what you get when the same rule is applied to a great many pairs at once and the answer is how many of them went each way. Which is exactly why the continuous model can hand this same expression a fractional value and mean something true by it: <b>a polarity is a field value rounded off to its sign</b>, and every law is written against the number so neither reading has to restate it.
+          </Para>
+
+          <Head>where the two models actually diverge — and it is local</Head>
+
+          <Para>
+            Here is the thing worth being careful about, because it is easy to read the two models as the same theory with a different label on the rays, and they are not.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Take two rays coming head on. <b>Without polarity there is only one thing that can happen:</b> they meet, they annihilate, and the space goes <i>there</i>, at that cell, on that tick. <b>With polarity there are two.</b> If they disagree, the same thing happens in the same place. If they agree, they <i>turn around</i> — nothing is destroyed at that cell at all — and each travels back the way it came until it runs into the next wave its own source put out behind it. That wave is the opposite sign, because the source alternates. So they annihilate <i>there</i>: half a wavelength back, several ticks later, on the source's side of where the meeting was.
+          </Para>
+
+          <Eq note="the same two rays, the same eventual annihilation — a different cell and a different tick">
+            <F>no polarity</F>&nbsp;&nbsp;
+            meet at <V>x</V> &nbsp;→&nbsp; annihilate at <V>x</V>, on tick <V>t</V>
+            <span style={{ padding: '0 1.4em' }} />
+            <F>XOR</F>&nbsp;&nbsp;
+            meet at <V>x</V> &nbsp;→&nbsp; turn &nbsp;→&nbsp;
+            annihilate at <V>x</V> ∓ <V>λ</V>/2, on tick <V>t</V> + <V>λ</V>/2<V>c</V>
+          </Eq>
+
+          <Para>
+            <b>That is a real difference and it is entirely local.</b> The map of where space is being destroyed is different between the two models — the XOR one puts its annihilations on the near side of the midline in bands, one per half-cycle, rather than all of them on the surface between the sources. It is the same difference that makes the aggregate panels in the previous section behave as they do: alternating polarities attract because the meetings land where they land, and matched polarities turn away because the meetings keep getting pushed back.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And then a second thing changes with it, in the opposite direction. Without a sign, there is nothing left to decide an outcome <i>but</i> the angle — so the angular gate comes back and a meeting only counts when the two are closing on each other, which bounds the folding to a lens between the bodies. With a sign, the sign decides it and being in the same cell is the whole of the condition, at any angle; what the angle sets is not <i>whether</i> but <i>how much</i>.
+          </Para>
+
+          <Eq note="what the angle is for, once polarity decides the outcome">
+            closing(<B>u</B>,<B>v</B>) = max(−<B>u</B>·<B>v</B>, 0)
+            <span style={{ padding: '0 1.2em' }} />
+            <K><Bar>HEAD_ON</Bar></K> = 1/√2
+            <span style={{ padding: '0 1.2em' }} />
+            splice(<B>u</B>,<B>v</B>) = |<B>û</B> − <B>v̂</B>| = 2 sin(<V>θ</V>/2)
+          </Eq>
+
+          <Para>
+            splice is how much a meeting <i>shortens</i>: two cells for two rays head on, nothing at all for two going the same way. Which is the honest reading of what an annihilation does to a distance, and it needs the angle whether or not there are signs.
+          </Para>
+
+          <Head>and why the global answer is the same anyway</Head>
+
+          <Para>
+            Two rules changed and they pull opposite ways, and when you write them into <V>S</V><Sub>ab</Sub> they land on the same factor.
+          </Para>
+
+          <Rows of={[
+            [<><i>share</i>: ½ → 1</>,
+              <>Without polarity <b>every</b> meeting annihilates, where before only the
+                opposite half did. So the share doubles.</>],
+            [<>the angular gate</>,
+              <>Comes back, since there is nothing else left to decide an outcome. So the
+                folding is bounded to a lens again.</>],
+          ]} />
+
+          <Eq note="G doubles — and that is the whole of it">
+            <V>G</V> = <Frac
+              over={<><K><Bar>BITE</Bar></K>·<i>share</i>·<K><Bar>SHEET</Bar></K><Sup>2</Sup>·<K><Bar>c</Bar></K></>}
+              under={<>4<V>π</V><Sup>2</Sup>·<K><Bar>CORE</Bar></K>·<K><Bar>DEG</Bar></K></>} />
+            <span style={{ padding: '0 1.4em' }} />
+            0.062351 → 0.124703
+          </Eq>
+
+          <Para>
+            <b>And the factor of two is not observable.</b> Every mass in the model is carried in units of <V>G</V>, so a body of physical mass <V>M</V> holds <V>M</V>/<V>G</V> and the dynamics compute <V>G</V>·(<V>M</V>/<V>G</V>). The constant is gone before it is used — <b>a change of the mass unit, not of a prediction</b>. Measured on the line integral: exactly two at every separation, with <V>S</V>·<V>R</V><Sup>2</Sup> flat in both.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <K><Bar>SHEET</Bar></K>, <K><Bar>DEG</Bar></K>, <K><Bar>BITE</Bar></K>, <K><Bar>BIAS</Bar></K>, <K><Bar>CORE</Bar></K>, <V>ε</V>, <V>D</V>, the reach and the tick do not move at all. And neither does anything predicted: Mercury's sixth, the other five sixths, light's deflection, <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π, the Milky Way to 1.1%, the transport turnover, the interpolation function, the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>. <b>All identical, to every digit quoted</b> — because every one of them is computed from something that never mentions a sign.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            So the honest statement of the divergence is: <b>the two models put their annihilations in different places and get the same pull out of them.</b> Locally different, globally identical. Which makes the XOR a free parameter on the gravitational side — turning it on costs nothing and buys magnetism, turning it off costs magnetism and buys nothing — and that is a better position than the page was in before the question was asked, because it means the magnetic half cannot break the gravitational one. There is no shared number for it to get wrong.
+          </Para>
+
+          <Head>the sign law was already inside G</Head>
+
+          <Para>
+            Except for one, and this is the part I did not expect. <V>G</V>'s derivation carries a factor it has never had to justify: <i>half of them opposite</i>. That half is the chance that two charges landing in the same cell have opposite sign — and it is not a constant. It is a fact about the matter involved. Half is what you get when both bodies are unbiased. Ordinary matter is unbiased. <b>That is the whole reason it ever looked like a number.</b>
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Put the bias back. If a fraction (1+<V>P</V>)/2 of a body's charges are positive at a place, then of the meetings between <V>a</V>'s and <V>b</V>'s:
+          </Para>
+
+          <Eq note="opposite annihilates, alike turns — and there is nothing else two charges can do">
+            annihilating(<V>P</V><Sub>a</Sub>,<V>P</V><Sub>b</Sub>) =
+            <Frac over={<>1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub></>} under={<>2</>} />
+            <span style={{ padding: '0 1.4em' }} />
+            turning(<V>P</V><Sub>a</Sub>,<V>P</V><Sub>b</Sub>) =
+            <Frac over={<>1 + <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub></>} under={<>2</>} />
+          </Eq>
+
+          <Eq note="like biases attract less, opposite attract more — and at P = 0 it is Newton exactly">
+            <V>F</V> = <Frac
+              over={<><V>G</V> <V>m</V><Sub>a</Sub> <V>m</V><Sub>b</Sub></>}
+              under={<><V>R</V><Sup>2</Sup></>} />
+            <span style={{ padding: '0 0.5em' }} />
+            (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)
+          </Eq>
+
+          <Para>
+            Read off the split. Unbiased against unbiased is one half and one half, which <i>is</i> the ½ in <V>G</V>, so Newton is the <V>P</V> = 0 case and not a separate claim. Biased against unbiased is also one half — a bias does nothing to something with no bias of its own, which comes out of the arithmetic rather than being put in by hand. Same bias gives nought; opposite bias gives twice. <b>Opposites attract and sameness repels, derived</b> — which is where this whole idea started, and which is the sign law <Ref of={'Coulomb, "Premier mémoire sur l\'électricité et le magnétisme", Histoire de l\'Académie Royale des Sciences 569'} year="1785" at="https://gallica.bnf.fr/ark:/12148/bpt6k3570k/f662" /> wrote down as an observation.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which is worth stopping on: <b>the gravitational constant carries a factor of one half because ordinary matter is unbiased.</b> If matter had a net bias, <V>G</V> would be a different number. The half was already there and unexplained; this is what it was — and it needs no reading whatever of what the bias <i>is</i>.
+          </Para>
+
+          <Head>one emission, three moments of it</Head>
+
+          <Para>
+            Gravity used the zeroth moment of the emission and threw the rest away. Keep them and the same emission answers three different questions.
+          </Para>
+
+          <Eq note="the count is mass, the signed sum is a net, the signed first moment is a bias">
+            <V>m</V> = ⟨1⟩<span style={{ padding: '0 1.6em' }} />
+            <V>q</V> = ⟨<V>s</V>⟩<span style={{ padding: '0 1.6em' }} />
+            <V>µ</V> = ⟨<V>s</V> <B>d̂</B>⟩
+          </Eq>
+
+          <Para>
+            And that is why the two behave so differently, which is not a coincidence. <b>A count always adds</b>, so gravity has one sign and cannot be screened by cancellation. <b>A signed sum cancels</b>, so a bias comes in two kinds and ordinary matter has none of it while still having all of its mass.
+          </Para>
+
+          <Head>what a source is doing at a given moment</Head>
+
+          <Para>
+            A source has exactly two switches and they are independent: whether it has <i>sides</i> (an axis) and whether it <i>comes round</i> (turns, or flips). Crossing them gives four distinguishable emissions, and the whole of what a source is doing at a tick is three lines.
+          </Para>
+
+          <Eq note="where its north points, and what it emits that way">
+            rate(<V>s</V>) ∈ [0, 1]
+            <span style={{ padding: '0 1.2em', color: FAINT }}>turns per <K><Bar>CYCLE</Bar></K> ticks</span>
+            <V>β</V>(<V>s</V>,<V>t</V>) = phase +
+            <Frac over={<><V>t</V>·rate</>} under={<K><Bar>CYCLE</Bar></K>} />
+          </Eq>
+
+          <Eq note="a spiral and a ring are the same function with and without an angle in it">
+            <V>F</V>(<B>d</B>) = sided ? <B>d</B>·<B>n̂</B>(<V>β</V>) : cos(2<V>π</V><V>β</V>)
+          </Eq>
+
+          <Para>
+            <i>Sided</i> is the only thing separating the two kinds of source, and it is not a parameter so much as a question about the source. With sides, what it emits depends on the direction — the field carries a θ in it, its zero set is θ = 2π<V>β</V> + const, and that is an Archimedean spiral. Without, direction drops out altogether, the zero set is a set of <i>instants</i> rather than places, and what travels out is rings.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And whatever the four turn out to be, <b>none of them can be a sided source with a net</b>: there is no way to be sided without having two sides. Checked over twenty thousand axes the net emission is exactly nought every time, because the lattice's exits come in ± pairs so a direction and its opposite always get opposite signs. That is ∇·<B>B</B> = 0 and the absence of monopoles — the symmetry <Ref of={'Maxwell, "A Dynamical Theory of the Electromagnetic Field", Phil. Trans. R. Soc. Lond. 155:459'} year="1865" at="https://doi.org/10.1098/rstl.1865.0008" /> had to write in as an observation, and which this model cannot avoid.
+          </Para>
+
+          <Head>a magnet is a lopsided default, not a stopped one</Head>
+
+          <Para>
+            The constraint that decides this whole section is that <b>a magnet still has to pulse its weight</b>. The two clocks are independent — <K><Bar>beat</Bar></K> = 1/<V>m</V> is how often it lets go, rate is how fast its axis comes round — so magnetising a thing cannot change what it weighs, and an emitter never has to stop. Both go on at once, and the magnet is the amount by which the alternation fails to come out even.
+          </Para>
+
+          <Eq note="a lopsided default, not a stopped one — and dwell is a count of ticks, so P is quantised">
+            <K><Bar>dwell</Bar></K> = <V>k</V>/<K><Bar>CYCLE</Bar></K>
+            <span style={{ padding: '0 1.2em' }} />
+            <V>P</V> = 2·<K><Bar>dwell</Bar></K> − 1
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>P</V> ∈ {'{'}0, ¼, ½, ¾, 1{'}'}
+          </Eq>
+
+          <Para>
+            A source turning at full rate is at <K><Bar>dwell</Bar></K> = ½ and has no magnet in it: its axis passes through all <K><Bar>CYCLE</Bar></K> directions, a fixed direction sees + + + 0 − − − 0, and the mean is nought. Turning it slower does not help — the same states in the same order, held longer each — which is worth being explicit about, because slowing <i>looks</i> like it should magnetise and does not. It changes the wavelength of what comes out and not the mean.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And <K><Bar>dwell</Bar></K> is a count of ticks, so the smallest magnetisation a single emitter can carry is 2/<K><Bar>CYCLE</Bar></K> = <b>a quarter</b>. Magnetisation comes in units, with nothing free in it. Against that, a saturated neodymium magnet measures <V>P</V> = 1.51·10<Sup>−5</Sup> in bulk: <b>99.9985% of what it emits cancels</b>, and what a magnet <i>is</i> is the fifteen parts per million that failed to.
+          </Para>
+
+          <Head>and where the bias lives decides everything</Head>
+
+          <Para>
+            There are two places the bias could sit and only one of them is a magnet. Put it on a <i>direction</i> — one emitter, + out of its north half and − out of its south, from a single place — and it fails: pole to pole gives <b>exactly nothing</b>, by an exact cancellation, and the fall-off is 1/<V>R</V><Sup>2</Sup> where two magnets are 1/<V>R</V><Sup>4</Sup>. Giving the emitter a ring does not rescue it, at any phase.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Put it on a <i>place</i> and everything works. A bar magnet is then a lump biased + at one end and − at the other — net zero because the two ends cancel, <b>separated in space rather than in direction</b> — which is what magnetostatics has always called the pole model. Nothing else changes: the same <K>chance</K>, the same co-location rule, the same (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)/2 XOR whose unbiased case is the half inside <V>G</V>. And the field is integrated from the model's own signed emission rather than from a textbook formula.
+          </Para>
+
+          <Eq note="the field of a bar, summed over its two pole faces — and that sum IS a dipole">
+            <B>B</B>(<V>r</V>) = <span style={{ fontSize: '1.3em' }}>Σ</span><Sub>faces</Sub>
+            <Frac over={<>sign · <K><Bar>SHEET</Bar></K></>}
+              under={<>4<V>π r</V><Sup>2</Sup></>} />
+            <span style={{ padding: '0 1.4em' }} />
+            ⟨annihilation excess⟩ ∝ 3cos<Sup>2</Sup><V>θ</V> − 1
+            <span style={{ padding: '0 1.2em' }} />
+            <V>F</V> ∝ 1/<V>R</V><Sup>4</Sup>
+          </Eq>
+
+          <Para>
+            Measured over the whole of space by integrating the annihilation excess: <b>3cos²<V>θ</V> − 1 to three decimals</b> at every angle including both sign changes, <b>slope −2.00</b> on gravity's own 1/<V>R</V><Sup>2</Sup> so the force between two of them is 1/<V>R</V><Sup>4</Sup>, and all five orientations right — N–S facing, N–N facing, side by side either way, and one across the other giving nought to 10<Sup>−19</Sup>. That is magnetostatics, out of the same machinery that gave the rotation curve, with <b>nothing added to it</b>.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            It also says why <b>cutting a magnet gives two magnets</b> rather than two monopoles: the sign belongs to a region's boundary, so a new cut makes a new pair of faces. And ∇·<B>B</B> = 0 survives for the same reason — a body's two poles are the same emitters counted at both ends, so they are equal and opposite by construction.
+          </Para>
+
+          <Head>the size, which is the one thing owed</Head>
+
+          <Para>
+            The mechanism is settled and the <i>size</i> is not. First, it cannot come from the mass stream: if the biased pulses were a subset of the mass pulses the whole effect would be the (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>) factor, which runs 0 to 2, <b>so the most magnetism could ever be is one times gravity</b> — and two touching N52 cubes pull 2.2·10<Sup>12</Sup> times their own gravity. Settled, and cleanly: magnetism is its own layer with its own budget.
+          </Para>
+
+          <Eq note="one emitter's moment, the scaling in the constituent, and the conversion the layer costs">
+            <K><Bar>MAGNETON</Bar></K> =
+            <Frac over={<><K><Bar>CYCLE</Bar></K>·<V>G</V></>} under={<>2<V>π</V></>} /> = 0.0794 <V>µ</V><Sub>B</Sub>
+            <span style={{ padding: '0 1.2em' }} />
+            <V>µ</V><Sub>max</Sub>/<V>M</V> ∝ 1/<V>m</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em' }} />
+            <V>m</V><Sub>eff</Sub> = <V>q</V>√(<V>µ</V><Sub>0</Sub>/4<V>πG</V>) = 38.7 kg per A·m
+          </Eq>
+
+          <Para>
+            One emitter's ring has radius (<K><Bar>CYCLE</Bar></K>·<V>G</V>/2<V>π</V>)·<V>λ̄</V><Sub>C</Sub>, and <V>λ̄</V><Sub>C</Sub> goes as 1/<V>m</V>, so a <i>heavier</i> emitter is a <i>smaller</i> loop and per kilogram the moment goes as 1/<V>m</V><Sup>2</Sup> in whatever the body is made of. <b>The lightest constituent wins by the square</b> — which is the fact <V>µ</V><Sub>B</Sub>/<V>µ</V><Sub>N</Sub> = 1836 records, so the model derives that magnetism is electronic rather than assuming it.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And the conversion has no material in it, which is what makes it a bill rather than a fit: a 1 cm N52 cube must emit as if it weighed <b>four and a half tonnes</b>, six hundred thousand times its own mass. The ratio is not constant across magnets — it runs 6·10<Sup>3</Sup> to 6·10<Sup>5</Sup>, going as <V>M</V>/<V>ρL</V>, because <b>a pole is a surface and mass is a volume</b>. Divide the geometry out and what is left <i>is</i> constant: 4.5·10<Sup>7</Sup> kg/m² of pole face for saturated N52, one number reproducing all six geometries with no residual. <b>That number is the whole of what this arc owes</b>, and it is the same shape <V>a</V><Sub>0</Sub> was before <V>cH</V><Sub>0</Sub>/2π — a coupling waiting for a count.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Because there is one ceiling, the budget is <i>shared</i>: pulses spent being a magnet are not being mass, so <b>magnetising a thing makes it lighter</b>, by exactly the fraction diverted. The cheap version of that is already dead — if the diverted fraction were the bulk bias itself, 1.5·10<Sup>−5</Sup>, a kilogram bar would lose 10 mg on being saturated, five orders above what a comparator would miss. So the magnetic layer's pulses are worth at least 10<Sup>14</Sup> gravitational ones, and that floor comes from a weighing rather than from a choice.
+          </Para>
+
+          <Head>and the three things this arc gets wrong</Head>
+
+          <Rows of={[
+            [<><V>g</V> = 1</>,
+              <>An emitter going round a loop at <K><Bar>c</Bar></K> has <V>µ</V> =
+                <V>qcr</V>/2 and <V>L</V> = <V>mcr</V>, so <V>µ</V>/<V>L</V> = <V>q</V>/2
+                <V>m</V> with the radius cancelling — the classical ratio. The electron's is
+                2.0023 to fourteen figures{' '}
+                <Ref of={'Hanneke, Fogwell & Gabrielse, "New Measurement of the Electron Magnetic Moment and the Fine Structure Constant", Phys. Rev. Lett. 100:120801'} year="2008" at="https://doi.org/10.1103/PhysRevLett.100.120801" />.
+                This one survives every choice, which makes it the sharpest.</>],
+            [<>the easy axis</>,
+              <>A held emitter puts + into every exit whose projection on its axis is
+                positive, and there are only <K><Bar>DEG</Bar></K> = 26 exits, so that split
+                is a <i>count</i>: 9 + / 8 equator / 9 − on a face or edge axis, 10 / 6 / 10
+                on a corner. So the model predicts ⟨111⟩ is the easy axis <b>by 11.1% in
+                every cubic material</b>. Right for nickel, wrong for iron, and flat where
+                measurement runs from 2.6% to 32%. A real prediction, in the right decade,
+                refuted in detail.</>],
+            [<><V>P</V> is not charge</>,
+              <>Emission rate goes as mass, so if the bias were electric charge a proton
+                would carry <b>1836 times</b> an electron's. Measurement has the two equal to
+                one part in 10<Sup>21</Sup>{' '}
+                <Ref of={'Baumann, Gähler, Kalus & Mampe, "Experimental limit for the charge of the free neutron", Phys. Rev. D 37:3107'} year="1988" at="https://doi.org/10.1103/PhysRevD.37.3107" />.
+                Whatever <V>P</V> is, it is not <V>q</V>, and everything here is read as
+                magnetism.</>],
+          ]} />
+
+          <Head>and the one number the whole thing owes</Head>
+
+          <Para>
+            Every force in this model is second order in the emission — nothing happens to a charge that does not <i>meet</i> another charge — so the electric force is capped at the size of gravity, and measurement puts it 4.166·10<Sup>42</Sup> above. What is worth saying is that <b>the hierarchy itself is not the mystery</b>.
+          </Para>
+
+          <Eq note="if the coupling were a count of order one where gravity is a product of two rates">
+            <Frac over={<V>α</V>} under={<>(<V>m</V><Sub>e</Sub>/<V>m</V><Sub>P</Sub>)<Sup>2</Sup></>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            4.166·10<Sup>42</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            <V>F</V><Sub>e</Sub>/<V>F</V><Sub>g</Sub>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>measured</span>
+          </Eq>
+
+          <Para>
+            The gap is the mass in Planck units squared, which is the measured ratio to five figures because that is what those symbols mean. <b>The bill is exactly one number, <V>α</V></b>, and nothing here derives it. Of 117,649 lattice monomials searched, 51 land within half a percent of 137.036 — so a hit would not be evidence, and none is claimed.
+          </Para>
+
+          <Head>the divergence, in one place</Head>
+
+          <Rows of={[
+            [<>what changes locally</>,
+              <>Alike charges <i>turn</i> instead of annihilating, so their annihilation
+                happens half a wavelength back and several ticks later, against the
+                following wave rather than against each other. <b>The map of where space is
+                destroyed is different.</b></>],
+            [<>what changes globally</>,
+              <><i>share</i> ½ → 1 and the angular gate returns, so <V>G</V> doubles — and
+                masses are carried in units of <V>G</V>, so <b>nothing measurable moves at
+                all</b>.</>],
+            [<>what the signs buy</>,
+              <>The sign law (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>), which explains
+                the ½ that was already sitting unexplained inside <V>G</V>. Magnetisation
+                quantised in quarters. ∇·<B>B</B> = 0 and no monopoles. The dipole
+                3cos²<V>θ</V> − 1 and the 1/<V>R</V><Sup>4</Sup> force. That cutting a magnet
+                halves it. That the lightest constituent wins by the square.</>],
+            [<>what they cost</>,
+              <>One coupling — 4.5·10<Sup>7</Sup> kg/m² of pole face — measured rather than
+                counted. And three refutations: <V>g</V> = 1, the flat 11.1% anisotropy, and
+                that the bias cannot be electric charge.</>],
+            [<>what is not started</>,
+              <>The electric half, entirely: charge, <V>ε</V><Sub>0</Sub>, <V>α</V>, Faraday,
+                Ampère–Maxwell, the Lorentz force. Those need a model of matter <i>and</i> a
+                first-order channel, and neither exists — a force here is a <i>meeting</i>,
+                which is second order. That one fact is the whole of the missing column.</>],
+          ]} />
+
         </Section>
         <Section head="XOR Discrete Model">
         </Section>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 0ee972c..cf4e584 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -70,6 +70,10 @@ export const F = ({ children }: { children: ReactNode }) => (
   <span style={{ color: FAINT, fontStyle: 'normal' }}>{children}</span>
 );
 
+export const D = ({ children }: { children: ReactNode }) => (
+  <span style={{ color: DERIVED, fontStyle: 'normal' }}>{children}</span>
+);
+
 /** A vector. Upright and bold, the way a vector is set. */
 export const B = ({ children }: { children: ReactNode }) => (
   <span style={{ fontWeight: 700, fontStyle: 'normal' }}>{children}</span>
@@ -1604,6 +1608,118 @@ export const CONSTANTS: Derivation = {
   </>,
 };
 
+export const TURNS: Derivation = {
+  label: 'CYCLE',
+  title: <>how long a turn takes, at any dimension</>,
+  body: <>
+    <Because>DEG and SHEET grow with the dimension, so why does this one not</Because>
+    <Step eq={<>
+      <K>DEG</K> = 3<Sup><V>d</V></Sup> − 1
+      <span style={{ padding: '0 1em' }} />
+      <K>SHEET</K> = 3<Sup><V>d</V>−1</Sup> − 1
+      <span style={{ padding: '0 1em' }} />
+      <K>CYCLE</K> = ?
+    </>}>
+      All three are the same formula — how many ways out of a point lie in a
+      slice, which is 3<Sup><V>k</V></Sup> − 1 when the slice has <V>k</V>{' '}
+      dimensions, because a direction lying in it is nought in every coordinate
+      outside and free in the <V>k</V> inside. So the whole question is{' '}
+      <b style={{ color: INK }}>how many dimensions the slice a turn sweeps
+        has</b>, and nothing else.
+    </Step>
+
+    <Because>what actually turns is one vector</Because>
+    <Step eq={<>sheet ⟷ <B>n̂</B></>}>
+      A sheet is a hyperplane and a hyperplane is fixed by its normal, so the
+      only thing a turn moves is the axis <B>n̂</B>. This is worth stating
+      because from <V>d</V> = 4 up{' '}
+      <b style={{ color: INK }}>a rotation need not act in a single plane</b> —
+      but the extra components act on directions perpendicular to the one the
+      axis travels in and leave the sheet exactly where it was, so they are not
+      part of the turn. Nothing observable distinguishes them.
+    </Step>
+
+    <Because>and one vector coming round sweeps a plane</Because>
+    <Step eq={<>
+      <V>P</V> = span{'{'}<B>n̂</B>, <B>R n̂</B>{'}'}
+      <span style={{ padding: '0 1.2em', color: FAINT }}>dim</span>
+      <V>P</V> = 2
+    </>}>
+      The orbit of the axis is a great circle, and a great circle lies in a
+      two-plane whether that plane sits in three dimensions or in three hundred.{' '}
+      <b style={{ color: INK }}>That is where the dimension leaves</b>, and it
+      leaves for a reason rather than by arithmetic accident: the thing being
+      counted is two-dimensional.
+    </Step>
+
+    <Because>unless the space has no plane in it</Because>
+    <Step eq={<>dim slice = min(<V>d</V>, 2)</>}>
+      A line has no two-plane to turn in, so there is no rotation to count and
+      what is left is the two states a line has — which is a{' '}
+      <i>flip</i> rather than a turn, and is the other kind of source{' '}
+      <i>physics.ts</i> already carries. So the slice is as close to a plane as
+      the space allows, and that is the min.
+    </Step>
+
+    <Because>and eight is the most any plane holds, not just the axis-aligned ones</Because>
+    <Step eq={<>
+      <V>Λ</V> = <V>P</V> ∩ ℤ<Sup><V>d</V></Sup>
+      <span style={{ padding: '0 1em' }} />
+      <V>C</V> = <V>P</V> ∩ [−1,1]<Sup><V>d</V></Sup>
+      <span style={{ padding: '0 1em' }} />
+      <V>S</V> ∩ <V>P</V> = (<V>Λ</V> ∩ <V>C</V>) ∖ {'{'}0{'}'}
+    </>}>
+      Cut both the lattice and the cube with the plane: a rank-two lattice, and
+      a symmetric convex polygon.{' '}
+      <b style={{ color: INK }}>Every non-zero point of <V>Λ</V> ∩ <V>C</V> is
+        on the boundary of <V>C</V></b> — its coordinates are integers in
+      [−1,1], so they are −1, 0 or 1, and being non-zero one of them is ±1,
+      which is the cube's own face. So the origin is the only lattice point
+      strictly inside.
+    </Step>
+
+    <Step eq={<>
+      square 8
+      <span style={{ padding: '0 1em', color: FAINT }}>hexagon 6</span>
+      <span style={{ padding: '0 0em', color: FAINT }}>diamond 4</span>
+    </>}>
+      A centrally symmetric convex lattice polygon with exactly one interior
+      lattice point is one of <b style={{ color: INK }}>three</b>, up to a change
+      of basis — and they carry 8, 6 and 4 points on the boundary. So there is{' '}
+      <b style={{ color: INK }}>no fourth answer available at any dimension</b>:
+      a larger <V>d</V> buys more planes, not bigger ones. The coordinate planes
+      are the square everywhere, and the square is the only one of the three
+      whose points are evenly spaced, which is what makes <K>SPIN</K> a constant
+      angle rather than an average of unequal ones.
+    </Step>
+
+    <Because>measured, since a classification is easy to misremember</Because>
+    <Step eq={<span style={{ fontFamily: 'ui-monospace, Menlo, monospace', fontSize: '0.8em' }}>
+      d=2..6&nbsp;&nbsp;max 8&nbsp;&nbsp;sizes {'{'}4,6,8{'}'}&nbsp;&nbsp;45,051 planes at d=6
+    </span>}>
+      Every two-plane spanned by a pair of directions, enumerated and
+      deduplicated by its Plücker coordinates. The maximum is 8 at every
+      dimension, the sizes that occur are 4, 6 and 8 and nothing else at every
+      dimension, and the coordinate plane holds 8 at every dimension. See{' '}
+      <i>tests/turns.ts</i>.
+    </Step>
+
+    <Because>so</Because>
+    <Step eq={<>
+      <K>CYCLE</K> = 3<Sup>min(<V>d</V>, 2)</Sup> − 1
+      <span style={{ padding: '0 1.2em', color: FAINT }}>= 2, 8, 8, 8, …</span>
+    </>}>
+      Two on a line and{' '}
+      <b style={{ color: INK }}>eight at every dimension of two or more</b>,
+      with <K>SPIN</K> = 2π/<K>CYCLE</K> = 45°. There is nothing between two
+      neighbouring directions for the axis to move through, so an eighth of a
+      turn is the finest re-pointing the lattice has — anything quicker is not a
+      faster rotation but a coarser one — and eight of those steps is back where
+      it started.
+    </Step>
+  </>,
+};
+
 export const FULL: Derivation = {
   label: 'the law in full',
   title: 'the law in full',
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/turns.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/turns.ts
new file mode 100644
index 0000000..a33ceeb
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/turns.ts
@@ -0,0 +1,144 @@
+/**
+ * WHY A TURN IS EIGHT TICKS, AND WHY THAT NUMBER DOES NOT GROW WITH THE
+ * DIMENSION — which was asserted and is now measured.
+ *
+ * `CYCLE` = 8 sits in `lattice.ts` as the length of `turnRing`, and `turnRing`
+ * gets it by walking the circle in eighths — so the eight is written into the
+ * loop. The comment there justifies it as "there are eight directions to a
+ * plane", which is true in three dimensions and was never checked anywhere
+ * else. `DEG` and `SHEET` both GROW with the dimension (3^d − 1 and 3^(d−1) −
+ * 1), so a third count that does not grow is exactly the kind of thing this
+ * file has been wrong about before — `SHEET` stood in for `DEG` in `BIAS` and
+ * understated it by 3.25.
+ *
+ * THE REDUCTION, which is where the dimension actually leaves. A turn moves
+ * ONE vector: the sheet is a hyperplane and a hyperplane is fixed by its
+ * normal, so what comes round is the axis n̂ and nothing else. Any further
+ * rotation component acts on directions orthogonal to the plane the axis
+ * travels in and leaves the sheet exactly where it was, so it is not part of
+ * the turn. (This matters from d = 4 up, where a rotation need not be simple.)
+ * So the orbit of the axis is a great circle — a 2-PLANE — whatever d is, and
+ * the question is:
+ *
+ *     how many of the lattice's directions lie in a 2-plane?
+ *
+ * THE ANSWER IS A TWO-DIMENSIONAL QUESTION, and that is the whole reason it
+ * does not scale. Write S = {−1,0,1}^d \ {0}, and P a plane. Then
+ *
+ *     Λ = P ∩ Z^d      is a rank-2 lattice
+ *     C = P ∩ [−1,1]^d is a symmetric convex polygon
+ *     S ∩ P            = (Λ ∩ C) \ {0}
+ *
+ * and EVERY NON-ZERO POINT OF Λ ∩ C LIES ON ∂C — because its coordinates are
+ * integers in [−1,1], so they are in {−1,0,1}, and being non-zero one of them
+ * is ±1, which is the cube's own boundary. So the origin is the only lattice
+ * point strictly inside C, and the count is the number of lattice points on
+ * the boundary of a centrally symmetric convex lattice polygon with one
+ * interior point. There are only three of those up to unimodular equivalence:
+ *
+ *     the square    conv{±(1,0), ±(0,1), ±(1,1), ±(1,−1)}      8 on the boundary
+ *     the hexagon   conv{±(1,0), ±(0,1), ±(1,1)}               6
+ *     the diamond   conv{±(1,0), ±(0,1)}                       4
+ *
+ * — so the count is 8, 6 or 4, and never anything else, IN EVERY DIMENSION.
+ * The ambient dimension chooses WHICH of the three plane you are looking at.
+ * It cannot make a fourth.
+ *
+ * The coordinate planes are the square, in every dimension, and the square is
+ * the only one of the three whose points are equally spaced — which is what
+ * makes `SPIN` = 2π/8 = 45° a constant angle rather than an average of
+ * unequal ones.
+ *
+ * WHAT IS MEASURED HERE. Every 2-plane spanned by a pair of directions, for
+ * d = 2 … 6, counted exhaustively. Planes are deduplicated by their Plücker
+ * coordinates so each is counted once, and directions are counted as rays so
+ * that a direction and its opposite are two.
+ *
+ * Expected: max 8 at every d, histogram over {4, 6, 8} only, and the maximum
+ * attained by the coordinate planes.
+ *
+ *     npx ts-node --compiler-options '{"module":"commonjs"}' \
+ *       src/routes/archive/2026.RayCalculiAndPhysics/tests/turns.ts
+ */
+
+const gcd = (a: number, b: number): number => (b ? gcd(b, a % b) : Math.abs(a));
+
+/** Every way out of a point in d dimensions: 3^d − 1 of them. */
+const directions = (d: number): number[][] => {
+  const out: number[][] = [];
+
+  (function build(prefix: number[]) {
+    if (prefix.length === d) {
+      if (prefix.some(v => v !== 0)) out.push(prefix);
+      return;
+    }
+    for (const v of [-1, 0, 1]) build([...prefix, v]);
+  })([]);
+
+  return out;
+};
+
+/** The ray a direction names, so that (2,2,0) and (1,1,0) are one thing. */
+const ray = (v: number[]): string => {
+  const g = v.reduce((a, x) => gcd(a, x), 0) || 1;
+  return v.map(x => x / g).join(",");
+};
+
+/**
+ * The plane a pair spans, named by its Plücker coordinates — normalised by
+ * their gcd and by the sign of the first non-zero, so that P and −P are one
+ * plane and any two pairs spanning it agree on the name.
+ */
+const planeOf = (u: number[], v: number[], d: number): string | null => {
+  const p: number[] = [];
+
+  for (let i = 0; i < d; i++)
+    for (let j = i + 1; j < d; j++) p.push(u[i] * v[j] - u[j] * v[i]);
+
+  const g = p.reduce((a, x) => gcd(a, x), 0);
+  if (!g) return null;                                  // parallel: not a plane
+
+  const q = p.map(x => x / g);
+  const lead = q.find(x => x !== 0) as number;
+
+  return (lead < 0 ? q.map(x => -x) : q).join(",");
+};
+
+for (let d = 2; d <= 6; d++) {
+  const S = directions(d);
+  const planes = new Map<string, Set<string>>();
+
+  for (let a = 0; a < S.length; a++)
+    for (let b = a + 1; b < S.length; b++) {
+      const key = planeOf(S[a], S[b], d);
+      if (key === null) continue;
+
+      let held = planes.get(key);
+      if (!held) planes.set(key, held = new Set());
+
+      held.add(ray(S[a]));
+      held.add(ray(S[b]));
+    }
+
+  const histogram = new Map<number, number>();
+  for (const held of planes.values())
+    histogram.set(held.size, (histogram.get(held.size) ?? 0) + 1);
+
+  const sizes = [...histogram.keys()].sort((x, y) => x - y);
+  const most = Math.max(...sizes);
+
+  // The plane of the first two axes, which is a coordinate plane at every d.
+  const axes = planeOf(
+    Array.from({ length: d }, (_, i) => (i === 0 ? 1 : 0)),
+    Array.from({ length: d }, (_, i) => (i === 1 ? 1 : 0)),
+    d,
+  ) as string;
+
+  console.log(
+    `d=${d}  |S|=${String(S.length).padStart(3)}  ` +
+    `DEG=${3 ** d - 1}  SHEET=${3 ** (d - 1) - 1}  ` +
+    `planes=${String(planes.size).padStart(5)}  ` +
+    `max=${most}  sizes={${sizes.join(", ")}}  ` +
+    `coordinate plane holds ${planes.get(axes)!.size}`,
+  );
+}

From 5adb4c02fb8443187e443118a945f14fbd5e748a Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Thu, 13 Aug 2026 23:58:30 +0200
Subject: [PATCH 38/47] Thinking inverse square law

---
 orbitmines.com/src/routes/Physics.tsx         |  308 +++--
 .../2026.RayCalculiAndPhysics/gravity.ts      |   31 +-
 .../archive/2026.RayCalculiAndPhysics/law.tsx |  376 +++++-
 .../2026.RayCalculiAndPhysics/wander.tsx      | 1006 +++++++++++++++++
 4 files changed, 1622 insertions(+), 99 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index 389bc29..a1d5926 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -11,11 +11,14 @@ import { bySide, Graph } from "./archive/2026.RayCalculiAndPhysics/discrete";
 import { Echoes } from "./archive/2026.RayCalculiAndPhysics/echoes";
 import { Beam, Sheet } from "./archive/2026.RayCalculiAndPhysics/figures";
 import {
-  B, Bar, Because, CLOCK, CONSTANTS, D, Eq, F, Frac, FULL, Hat, Head, IDENTICAL,
-  IGNORANCE, K, Law, LAW, MADE_FROM, MEETINGS, MET, METRIC, Paren, REACH, Rows,
+  B, Bar, Because, CEILING, CLOCK, CONSTANTS, D, Eq, F, Frac, FULL, Hat, Head,
+  IDENTICAL,
+  IGNORANCE, K, Law, LAW, MADE_FROM, MEETINGS, MET, METRIC, Paren, R, REACH, Rows,
   SPACE, Step, Sub, Sup, TURNS, V,
 } from "./archive/2026.RayCalculiAndPhysics/law";
+import { gravitational, massUnit } from "./archive/2026.RayCalculiAndPhysics/gravity";
 import { lineGroups } from "./archive/2026.RayCalculiAndPhysics/lines";
+import { Wander, WanderBlind, WanderForward, WanderPaths, WanderVeins } from "./archive/2026.RayCalculiAndPhysics/wander";
 import { Model } from "./archive/2026.RayCalculiAndPhysics/model";
 import { asGroup, MODELS, weighed } from "./archive/2026.RayCalculiAndPhysics/models";
 import { PACE, Polarity } from "./archive/2026.RayCalculiAndPhysics/physics";
@@ -43,6 +46,23 @@ const FAINT = '#6c7080';
 const Para = ({ children }: { children: React.ReactNode }) =>
   <span style={{ textAlign: 'left', width: '100%' }}>{children}</span>;
 
+/**
+ * A node's own radius, which is the one length in the model that is not a
+ * distance between two things.
+ *
+ * A node is a CELL, not a point — the cube x,y,z in [0,1] — which is a nuisance
+ * the moment the model goes continuous, because then every coordinate names an
+ * interval and nothing sits AT a place. Displacing the lattice by half a step
+ * and naming a node by its CENTRE fixes that: coordinates become points again.
+ * What it costs is that a node then has a radius, and the radius is a half.
+ *
+ * Drawn in the DERIVED colour rather than the counted one because it is not put
+ * in. Given one step a tick, a cell is one step across, so its radius is a half
+ * and there was never a choice about it. `gravity.ts` calls it `CORE`, which is
+ * `HALF` in `field.ts`, and both are this.
+ */
+const HALF = <D><Bar>½</Bar></D>;
+
 /** Pick arrangements out of `models.ts` by name, in the order asked for. */
 const named = (...names: string[]): Model[] =>
   names.map(n => MODELS.find(m => m.name === n)).filter(Boolean) as Model[];
@@ -100,6 +120,9 @@ const Physics = () => {
   const Ref = ({ of, year, at }: { of: string, year?: string, at: string }) =>
     <Reference is="reference" simple inline index={referenceCounter()}
       reference={{ title: of, year, link: at }} />;
+  const Footnote = ({ of, year, at }: { of: string, year?: string, at: string }) =>
+    <Reference is="footnote" simple inline index={referenceCounter()}
+      reference={{ title: of, year, link: at }} />;
 
   const book: Omit<PaperProps, 'children'> = {
     book: true,
@@ -241,7 +264,15 @@ const Physics = () => {
 
         <BR/>
 
-        Speaking of rotation, 
+        <Head>Movement</Head>
+
+        There's a real assumption to made here at the beginning. Which is how does one from a perspective of discreteness, recover rays propagating in a circle. That's making the assumption you'd want it to propegate in a circle in the first place - whether that's the actual accurate model. Also to consider would be that a large surface of stuff sending out rays could more accurately describe a circle, than say a single point with a local neighbourhood. This is essentially a statement of discrete movement, how should that happen? Where on the aggregate we might see a sphere, a cube, a (curved) diamond-shape. All are these are technically possibilities. We could imagine a world where discretized effects matter here for the spread of those rays.
+
+        <BR/>
+
+        <Para>Let's for a moment assume we wouldn't be able to completely reproduce a circle from a single point with a discrete <K><Bar>SHEET</Bar></K>. What would that look like? One view would be: There's a propegation direction, but the ray sometimes wanders from diagonal to non-diagonal and back to a diagonal: attempting some forward-preference. This 'wandering' would result in cones in each direction, with relative deadzones on the boundaries of them.</Para> 
+
+        <WanderVeins />
 
         <BR/>
 
@@ -274,67 +305,71 @@ const Physics = () => {
             <D><Bar>½</Bar></D>
           </Eq>
 
-          Alrighty, let's get started then.
+          Alrighty,
 
-          <span style={{paddingBottom: '200px'}}></span>
+          <Head>The inverse square law</Head>
 
-          <BR/>
+          <Head>Mass</Head>
 
-          TODO Rewrite everything past this point:
+          If 'gravity-rays' are what cause attraction in this model. How would we intuitively encode what it means to have mass. The answer is: The heavier you are, the more gravity you expect around that thing. So the heavier something is the more of these rays it shoots out.
 
-          <BR/>
+          <Eq>
+            <i><Bar>m</Bar></i> = <F>% <Bar>t</Bar>
+            <span style={{ padding: '0 1.4em' }} />
+            0 ≤ <V><Bar>m</Bar></V> ≤ <K><Bar>c</Bar></K></F>
+            <span style={{ padding: '0 1.4em' }} />
+            <i><Bar>m</Bar></i>.period = <Frac over={<>1</>} under={<i><Bar>m</Bar></i>} /> <F><Bar>t</Bar></F>
+          </Eq>
 
-          Whenever there's a derived equation, you can click on it to see how it was derived! Try it!
+          We define a number between 0 and 1 of what percentage of time is spent pulsing. This is its 'discrete mass'. There's of course no need for this to be a perfect period, as long as the average corresponds to a particular number, the mass will be on aggregate a particular value.
 
           <BR/>
 
-          How we would get a model which knows where to move from local interactions I don't yet know (that'll be something for the future). But for now we can just calculate a trajectory based on the space.
+          <Para>
+            The obvious first thing to note being that this predicts a heaviest elementary object, if one would assume a static <F>l.</F><K><Bar>DEG</Bar></K>. Essentially saying, if the local spatial density (<F>l.</F><K><Bar>DEG</Bar></K>) is given, there's a heaviest elementary object which can occupy that space. Namely <i><Bar>m</Bar></i> = 1 (pulse every tick).
+          </Para>
 
           <BR/>
 
+          <Para>At <i><Bar>m</Bar></i> = 1 we get a gravitational constant</Para>
 
-          <Head>what mass is: how often, not how much</Head>
-
-          <Para>
-            Here is the first place the model says something that isn't obvious. In this model <b>mass is not a property a thing has</b>. A body does not have a quantity of stuff in it that space somehow senses. A body <i>pulses</i> — it lets go of a sheet of charges — and mass is <i>how often it does that</i>.
-          </Para>
+          <Eq derive={CEILING}>
+            <i><K><Bar>G</Bar></K></i> = <Frac
+              over={<><K><Bar>SHEET</Bar></K><Sup>2</Sup> · <K><Bar>c</Bar></K></>}
+              under={<>4<V>π</V><Sup>2</Sup> · {HALF} · <K><Bar>DEG</Bar></K></>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            {gravitational(1).toFixed(6)}..
+          </Eq>
 
-          <BR/>
+          Whenever there's a derived equation, you can click on it to see how it was derived! Try it!
 
           <Para>
-            A heavier thing does not write more charge onto space in one go. It writes exactly as much, more often. So the natural variable is the period: <V>X</V> ticks between one pulse and the next, and <V>m</V> = 1/<V>X</V>.
+            The second thing, not used for the rest of this model: Turn the period into a length of how far light travels within that timeframe, and you get something proportional to the <Ref of={'reduced Compton wavelength'} at="https://en.wikipedia.org/wiki/Compton_wavelength#Reduced_Compton_wavelength" /> <Footnote of={'Compton, "A Quantum Theory of the Scattering of X-rays by Light Elements", Phys. Rev. 21:483'} year="1923" at="https://doi.org/10.1103/PhysRev.21.483" />. (<i><K><Bar>G</Bar></K></i> here being the gravitational constant of the model)
           </Para>
 
-          <Eq derive={CLOCK}
-            note="a heavier thing pulses more often, and nothing pulses more than once a tick">
-            <V>X</V> = 1/<V>m</V>
-            <span style={{ padding: '0 1.4em', color: FAINT }}>ticks between pulses</span>
-            <V>m</V> ≤ <K><Bar>c</Bar></K>
+          <Eq derive={CLOCK}>
+            <i><Bar>m</Bar></i>.period · <K>c</K> = <i><K><Bar>G</Bar></K></i> · <D><i>λ</i><Sub>Compton</Sub></D>
             <span style={{ padding: '0 1.4em' }} />
-            <V>X</V>·<V>c</V> = <V>G</V> · <V>λ</V><Sub>Compton</Sub>
+            <D><i>λ</i><Sub>Compton</Sub></D> = <Frac over={<>ħ</>} under={<><i>Mc</i></>} />
           </Eq>
-
-          <Para>
-            Two things fall straight out of that, and I aimed at neither.
-          </Para>
+          {/* <V>E</V> = ħω */}
+         
+          <span style={{paddingBottom: '200px'}}></span>
 
           <BR/>
 
-          <Para>
-            The first is that <b>there is a heaviest elementary thing</b>. Nothing in this universe does anything more than once a tick, so nothing pulses more than once a tick, so <V>m</V> ≤ 1 and there is a ceiling. In our units it is about 1.36 µg. Anything heavier is not <i>one</i> emitter — it is <i>many</i>, which is as close as this model gets to saying what matter is.
-          </Para>
+          TODO Rewrite everything past this point:
+
+    
 
           <BR/>
 
-          <Para>
-            The second is stranger. Turn the period into a length by asking how far light goes in it, and you get <V>X</V>·<V>c</V> = <V>G</V>·ħ/<V>mc</V> exactly, at every mass — which is the <Ref of={'Compton, "A Quantum Theory of the Scattering of X-rays by Light Elements", Phys. Rev. 21:483'} year="1923" at="https://doi.org/10.1103/PhysRev.21.483" /> wavelength. Checked across twenty orders of magnitude — electron, proton, uranium atom, virus, grain of sand — the ratio comes out 0.062329 every time against a <V>G</V> of 0.062351. It is not a coincidence: <V>m</V><Sub>P</Sub><V>l</V><Sub>P</Sub> = ħ/<V>c</V>, so "period = 1/mass" in lattice units simply <i>is</i> the Compton relation, and <V>E</V> = ħω with it.
-          </Para>
 
           <BR/>
 
-          <Para>
-            And at the ceiling, where the beat is one tick, that tick comes out at 5.391246·10<Sup>−44</Sup> s against a Planck time of 5.391246·10<Sup>−44</Sup> s. Ratio 1.000000000, with <V>G</V> cancelling out of it. <b>The lattice's tick is the Planck time</b>, by identity rather than by fit.
-          </Para>
+          How we would get a model which knows where to move from local interactions I don't yet know (that'll be something for the future). But for now we can just calculate a trajectory based on the space.
+
+          <BR/>
 
           <Head>one pulse, spread — which is where the inverse square is</Head>
 
@@ -343,7 +378,7 @@ const Physics = () => {
           </Para>
 
           <Eq derive={MEETINGS}>
-            shell(<V>r</V>) = 4<V>π</V>·max(<V>r</V>, <K><Bar>CORE</Bar></K>)<Sup><K><Bar>D</Bar></K> − 1</Sup> + <K><Bar>FLOOR</Bar></K>
+            shell(<V>r</V>) = 4<V>π</V>·max(<V>r</V>, {HALF})<Sup><K><Bar>D</Bar></K> − 1</Sup> + <K><Bar>FLOOR</Bar></K>
             <span style={{ padding: '0 1.4em' }} />
             chance(<V>m</V>,<V>r</V>) =
             <Frac over={<><V>m</V> · <K><Bar>SHEET</Bar></K></>} under={<>shell(<V>r</V>)</>} />
@@ -356,7 +391,7 @@ const Physics = () => {
           <BR/>
 
           <Para>
-            The two guards on it are both the same kind of honesty. The max says a shell is never smaller than the cell its source sits in, which is <K><Bar>CORE</Bar></K> from above. The <K><Bar>FLOOR</Bar></K> = 2 says that the innermost shell is not the continuum's 4π(½)<Sup>2</Sup> = 3.14 cells but the lattice's own: the surface of a cube at <V>d</V> steps is 24<V>d</V><Sup>2</Sup> + 2 cells, which at one step is exactly 26, exactly <K><Bar>DEG</Bar></K>. Without those two caps, chance at the core comes out at 8/4<V>π</V>(½)<Sup>2</Sup> = 2.546 — a probability, over one — and nobody had evaluated the floor to notice. With them it is 1.556, and read entirely off the cube rather than half off the continuum it would be 8/8 = 1 exactly, saturated and never exceeded, which is what a probability is allowed to do. <b>That last step is not taken here</b>, because 24<V>d</V><Sup>2</Sup> counts cells at Chebyshev distance where <K>chance</K> is asked with a Euclidean separation, and on a 26-connected lattice those differ by up to √3 depending on direction.
+            The two guards on it are both the same kind of honesty. The max says a shell is never smaller than the cell its source sits in, which is {HALF} from above. The <K><Bar>FLOOR</Bar></K> = 2 says that the innermost shell is not the continuum's 4<V>π</V>{HALF}<Sup>2</Sup> = 3.14 cells but the lattice's own: the surface of a cube at <V>d</V> steps is 24<V>d</V><Sup>2</Sup> + 2 cells, which at one step is exactly 26, exactly <K><Bar>DEG</Bar></K>. Without those two caps, chance at the core comes out at 8/4<V>π</V>{HALF}<Sup>2</Sup> = 2.546 — a probability, over one — and nobody had evaluated the floor to notice. With them it is 1.556, and read entirely off the cube rather than half off the continuum it would be 8/8 = 1 exactly, saturated and never exceeded, which is what a probability is allowed to do. <b>That last step is not taken here</b>, because 24<V>d</V><Sup>2</Sup> counts cells at Chebyshev distance where <K>chance</K> is asked with a Euclidean separation, and on a 26-connected lattice those differ by up to √3 depending on direction.
           </Para>
 
           <Head>and what does not get through</Head>
@@ -435,32 +470,32 @@ const Physics = () => {
           <Eq derive={MET}>
             met(<V>R</V>) = ∫<Sub>0</Sub><Sup><V>R</V></Sup>
             <Frac over={<>d<V>x</V></>}
-              under={<>max(<V>x</V>,<K><Bar>CORE</Bar></K>)<Sup>2</Sup> ·
-                max(<V>R</V>−<V>x</V>,<K><Bar>CORE</Bar></K>)<Sup>2</Sup></>} />
+              under={<>max(<V>x</V>,{HALF})<Sup>2</Sup> ·
+                max(<V>R</V>−<V>x</V>,{HALF})<Sup>2</Sup></>} />
           </Eq>
 
           <Para>
-            And it has a closed form, which is the nicest surprise in the gravity arc. Cut the line in three — a core's worth at each end where a source's own field is capped and flat, and the open middle where nothing is capped — do the middle by partial fractions, and the two leftover pieces collapse against each other because they differ by a factor of (<V>R</V> − <K><Bar>CORE</Bar></K>) that cancels.
+            And it has a closed form, which is the nicest surprise in the gravity arc. Cut the line in three — a core's worth at each end where a source's own field is capped and flat, and the open middle where nothing is capped — do the middle by partial fractions, and the two leftover pieces collapse against each other because they differ by a factor of (<V>R</V> − {HALF}) that cancels.
           </Para>
 
           <Eq derive={MET} note="one inverse square, times one bracket that goes to one">
             met(<V>R</V>) &nbsp;=&nbsp;
-            <Frac over={<>4</>} under={<><K><Bar>CORE</Bar></K> <V>R</V><Sup>2</Sup></>} />
+            <Frac over={<>4</>} under={<>{HALF} <V>R</V><Sup>2</Sup></>} />
             <Paren>
               1 &nbsp;+&nbsp;
-              <Frac over={<K><Bar>CORE</Bar></K>} under={<V>R</V>} /> ln
-              <Frac over={<><V>R</V> − <K><Bar>CORE</Bar></K></>} under={<K><Bar>CORE</Bar></K>} />
+              <Frac over={HALF} under={<V>R</V>} /> ln
+              <Frac over={<><V>R</V> − {HALF}</>} under={HALF} />
             </Paren>
           </Eq>
 
           <Para>
-            One inverse square, times one bracket that goes to one. The 1/<K><Bar>CORE</Bar></K> out front is the two ends — dense, because that is where each field is at its highest anywhere, but only half a step long. The logarithm is the middle — thin, but <V>R</V> long, and it accumulates equally per octave of distance because that term came from the <i>gradient</i> of each body's field across the other's near zone. Checked against brute-force numerical integration at every separation and core size tried, to eight significant figures.
+            One inverse square, times one bracket that goes to one. The 1/{HALF} out front is the two ends — dense, because that is where each field is at its highest anywhere, but only half a step long. The logarithm is the middle — thin, but <V>R</V> long, and it accumulates equally per octave of distance because that term came from the <i>gradient</i> of each body's field across the other's near zone. Checked against brute-force numerical integration at every separation and core size tried, to eight significant figures.
           </Para>
 
           <BR/>
 
           <Para>
-            The whole of this model's departure from Newton at a distance is that bracket, and its size is nothing but the ratio of a source's core to the separation. At <K><Bar>CORE</Bar></K> = half a lattice step and Mercury's separation the bracket is 1.08. At the grain a real lattice would have — where the Sun and Mercury are an astronomical number of steps apart — it is 1 + 10<Sup>−38</Sup>. <b>There is nothing there to tune.</b>
+            The whole of this model's departure from Newton at a distance is that bracket, and its size is nothing but the ratio of a source's core to the separation. At {HALF} = half a lattice step and Mercury's separation the bracket is 1.08. At the grain a real lattice would have — where the Sun and Mercury are an astronomical number of steps apart — it is 1 + 10<Sup>−38</Sup>. <b>There is nothing there to tune.</b>
           </Para>
 
           <Head>what one meeting buys a path</Head>
@@ -522,32 +557,24 @@ const Physics = () => {
             note={<>the bracket is 1.08 at a core of half a lattice step and Mercury's
               separation — and 1 + 10⁻³⁸ at the grain a real lattice would have</>}>
             <Frac over={<>d<V>p</V></>} under={<>d<V>t</V></>} /> &nbsp;=&nbsp;
-            <V>G</V> ·
+            <i><K><Bar>G</Bar></K></i> ·
             <Frac over={<><V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub></>}
               under={<><V>R</V><Sup>2</Sup></>} />
             <Paren>
-              1 &nbsp;+&nbsp; <Frac over={<K><Bar>CORE</Bar></K>} under={<V>R</V>} /> ln
-              <Frac over={<><V>R</V> − <K><Bar>CORE</Bar></K></>} under={<K><Bar>CORE</Bar></K>} />
+              1 &nbsp;+&nbsp; <Frac over={HALF} under={<V>R</V>} /> ln
+              <Frac over={<><V>R</V> − {HALF}</>} under={HALF} />
             </Paren>
             <Hat>r</Hat>
           </Eq>
 
-          <Eq derive={FULL} note="every symbol of it a count — 0.062351, in the lattice's own units">
-            <V>G</V> = <Frac
-              over={<><K><Bar>BITE</Bar></K> · share · <K><Bar>SHEET</Bar></K><Sup>2</Sup> · <K><Bar>c</Bar></K></>}
-              under={<>4<V>π</V><Sup>2</Sup> · <K><Bar>CORE</Bar></K> · <K><Bar>DEG</Bar></K></>} />
-            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
-            0.062351
-          </Eq>
-
           <Para>
-            <b>Newton, times a bracket that goes to one, with a constant that is not measured, chosen or fitted.</b> Every symbol in <V>G</V> is a count: how many charges a pulse carries, how many ways there are out of a point, how big a source's own cell is, and how much of what meets is opposite. Nothing in it came from an experiment, and there is nothing in it left to turn.
+            <b>Newton, times a bracket that goes to one</b> — and the constant in front is the <i><K><Bar>G</Bar></K></i> from the top of this section, which is where it came from. Every symbol in it is a count: how many charges a pulse carries, how many ways there are out of a point, how big a source's own cell is, and how much of what meets is opposite. Nothing in it came from an experiment, and there is nothing in it left to turn.
           </Para>
 
           <BR/>
 
           <Para>
-            One warning about notation, because the code and the prose have collided here before. The <K><Bar>CORE</Bar></K> in met(<V>R</V>) is <i>half a lattice step</i> — a length — and not the speed of light, which is <K><Bar>c</Bar></K> = one step a tick. They are written as the same letter in some places in the source and they are not the same quantity. Reading them as one is worth exactly a factor of two in <V>G</V>.
+            One warning about notation, because the code and the prose have collided here before. The {HALF} in met(<V>R</V>) is <i>half a lattice step</i> — a length — and not the speed of light, which is <K><Bar>c</Bar></K> = one step a tick. They are written as the same letter in some places in the source and they are not the same quantity. Reading them as one is worth exactly a factor of two in <V>G</V>.
           </Para>
 
           <Head>and what a count is as a speed</Head>
@@ -1017,9 +1044,9 @@ const Physics = () => {
                 <V>m</V><Sub>b</Sub>·EMIT<Sup>2</Sup>·met(<V>R</V>) — the meeting rate, and
                 a screening term Newton has no name for</>],
             [<>along the line</>,
-              <>met(<V>R</V>) = 4/(<K><Bar>CORE</Bar></K><V>R</V><Sup>2</Sup>)·(1 +
-                (<K><Bar>CORE</Bar></K>/<V>R</V>)ln((<V>R</V>−<K><Bar>CORE</Bar></K>)/
-                <K><Bar>CORE</Bar></K>)) — <b>Newton, times a bracket that goes to one</b></>],
+              <>met(<V>R</V>) = 4/({HALF}<V>R</V><Sup>2</Sup>)·(1 +
+                ({HALF}/<V>R</V>)ln((<V>R</V>−{HALF})/
+                {HALF})) — <b>Newton, times a bracket that goes to one</b></>],
             [<>read as a direction</>,
               <><K><Bar>BIAS</Bar></K> = <K><Bar>c</Bar></K>/<K><Bar>DEG</Bar></K> ⇒ the law,
                 <b> the equivalence principle</b>, 1/<V>γ</V><Sup>3</Sup> and 1/<V>γ</V>, and
@@ -1030,8 +1057,8 @@ const Physics = () => {
                 sixths, and the whole of light's deflection</>],
             [<>and the constant</>,
               <><V>G</V> = <K><Bar>BITE</Bar></K>·share·<K><Bar>SHEET</Bar></K><Sup>2</Sup>
-                <K><Bar>c</Bar></K>/(4π<Sup>2</Sup><K><Bar>CORE</Bar></K><K><Bar>DEG</Bar></K>)
-                = 0.062351 — <b>every symbol a count</b></>],
+                <K><Bar>c</Bar></K>/(4π<Sup>2</Sup>{HALF}<K><Bar>DEG</Bar></K>)
+                = {gravitational().toFixed(6)} — <b>every symbol a count</b></>],
             [<>the vacuum</>,
               <><V>λ</V> = 1/√(<K><Bar>BITE</Bar></K>·share·<K><Bar>SHEET</Bar></K>·<V>ρ</V>)
                 ⇒ <b>Yukawa</b>, with <V>λ</V>/<V>R</V><Sub>h</Sub> = 0.361/√<V>Ω</V></>],
@@ -1632,11 +1659,127 @@ const Physics = () => {
           <Models models={MODELS} />
         </Section>
         <Section head="TODO3">
+
+          <Para>
+            <b>Does a square pulse ever become a round one?</b> A charge moves one cell a tick and a cell has 26 ways out, so after <V>t</V> ticks a pulse is at <i>Chebyshev</i> distance <V>t</V> — a cube shell. The faces have covered <V>t</V>, the edges √2<V>t</V>, the corners √3<V>t</V>. The closed form meanwhile divides by 4π<V>r</V><Sup>2</Sup>. Those are different shapes, and <b>scaling a cube gives a cube</b>: corner over face is 1.7321 at <V>t</V> = 10 and at <V>t</V> = 10<Sup>38</Sup> alike.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <K>wander</K> is the rule the model already has for it — a ray takes one of the ways its direction is <i>made of</i> instead of the direction itself, so a diagonal sometimes steps along an axis and is slowed in Euclidean terms. With one <V>w</V> for every class that takes the spread from 73% to 3.5%. <b>And the 3.5% is not irreducible.</b> A direction with <V>n</V> non-zero components has mean speed (1 − <V>w</V>(<V>n</V>−1)/<V>n</V>)·√<V>n</V>, and setting that to one solves in closed form:
+          </Para>
+
+          <Eq note="at which the mean speed is 1.000000000 in all 26 directions">
+            <V>w</V>(<V>n</V>) = <Frac over={<>√<V>n</V></>} under={<>√<V>n</V> + 1</>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            0.5858 <F>(edge)</F>
+            <span style={{ padding: '0 0.8em' }} />
+            0.6340 <F>(corner)</F>
+          </Eq>
+
+          <Wander />
+
+          <Para>
+            Three things were measured and they do not all agree. The front's <b>radius</b> is fixed — every ray lands on the sphere of radius <V>t</V> exactly. The shell's <b>density</b> is fixed, and this is the one the physics needs: plain propagation puts 0.853553 of the closed form's <K><Bar>SHEET</Bar></K>/4π<V>r</V><Sup>2</Sup> through a shell, so <i><K><Bar>G</Bar></K></i> would be out by <b>0.7286</b>; wandered — or with steps costing their own length — it is 1.000000 exactly. The falloff <i>exponent</i> is −2 in all three, so the inverse square was never at risk.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The front's <b>directions</b> are not fixed, and get worse with distance. A wandering beam's angular width goes as 1/√<V>t</V>, so the beams <i>collimate</i>: 11.1° at <V>t</V> = 10 and 0.70° at 2560, and 26 cones of that width cover 2.4·10<Sup>−6</Sup> of the sky by <V>t</V> = 10<Sup>6</Sup>. <b>And no averaging saves it</b>, because the lattice is translation-invariant: every emitter at every site has the same 26 exits, so averaging over positions, orientations, phases or 10<Sup>39</Sup> constituents never makes a twenty-seventh direction.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which leaves a split worth being exact about. What the closed form needs from the lattice is a <i>number</i> — how much of a source is at a place — and wandering delivers that number exactly. What it does not deliver is the <i>picture</i>: the flux sits on 26 needles rather than smeared over the shell, so <K>chance</K> is right on average and wrong at any particular point. <b>Every prediction in this booklet is computed from the average, and none from a particular point</b> — which is why nothing above moves, and also why this should be read as an open problem rather than a repair.
+          </Para>
+
+          <Head>and whether a circle was ever the right thing to want</Head>
+
+          <Para>
+            Everything above quietly assumes the answer is a circle and then asks how a lattice could manage one. <b>That assumption is doing real work and it has not been argued for.</b> What discreteness actually offers is a choice of aggregate shape — a sphere, a cube, a curved diamond — and each of them is a different answer to one question: <i>what is a heading?</i> The rule picks the shape, and the shape is not handed down from anywhere.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            So here is every path a ray could take, as a field, under four answers to that question. Alpha is the probability that a path ends in a cell, gamma-corrected so the thin parts show rather than clipping to black — and nothing is sampled: with free headings the two coordinates are <i>independent binomials</i>, so the field is exact.
+          </Para>
+
+          <WanderPaths />
+
+          <Para>
+            <b>Read the veins.</b> One held heading gives eight rays and an aggregate square — there is no envelope, only spokes. The current <K>wander</K> broadens the diagonals and <i>cannot</i> broaden the axes, since a face step has no constituents to wander into, so the spokes fatten unevenly and there are still eight. Free headings close the ring — and it comes out <b>sharp on the axes and blurred on the diagonals</b>, because the radial spread is √((1 − Σ<V>u</V><Sub>i</Sub><Sup>4</Sup>)<V>t</V>) and Σ<V>u</V><Sub>i</Sub><Sup>4</Sup> is exactly 1 along an axis. Measured on the field at <V>t</V> = 24: radial sd 1.16 on the axis, 2.21 at 22.5°, 3.02 on the diagonal.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And the fourth panel is the other route, which is worth taking seriously on its own: <b>a large surface of emitters fills a shell better than a point with a neighbourhood does</b>, because the veins widen by the body's own size rather than by any rule about stepping. Measured, that works — and it works out to about <b>2.5 body radii and no further</b>, with the curves for bodies of radius 1, 4 and 16 lying on top of each other. So extendedness buys a proportionally bigger circle, never a longer-lasting one.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            We could imagine a world where the discreteness genuinely mattered for the spread of those rays — where the blur is the physics rather than a repair. But then it has to be a wander that <i>does not discriminate</i>, since the one above is picky: it mixes a heading with its <i>own</i> constituents, so a face step never wanders and a corner step wanders most, and that pickiness is doing all the work. Take it away — with probability <V>w</V> take a uniformly random lattice step, caring neither what your heading is nor which way you go — and the means come out at (1 − <V>w</V>)·<B>d</B>, because the 26 come in ± pairs and average to nothing.
+          </Para>
+
+          <WanderBlind />
+
+          <Para>
+            <b>So every speed is scaled by the same (1 − <V>w</V>) and the ratio never moves</b>: face (1−<V>w</V>), diagonal (1−<V>w</V>)√2, corner (1−<V>w</V>)√3, at every <V>w</V>. The square stays a square. What <V>w</V> buys is blur, and blur only <i>hides</i> it, and only near in — the corner excess grows as 0.414(1−<V>w</V>)<V>t</V> while the blur grows as √(var·<V>t</V>), so the square comes back at <V>t</V> ≈ 29 ticks for <V>w</V> = 0.5, 222 for 0.8, and 3547 for 0.95. At <V>w</V> = 1 it is gone, and so is propagation: the mean speed is nought and nothing goes anywhere at all.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which suggests the rule that neither of the two above is: <b>you may deviate, but only into a direction you are already going in.</b> Take the candidates to be every lattice direction with a <i>positive projection</i> on the heading — and note first that the cone's size is <b>9 for a face or an edge and 10 for a corner</b>, which are exactly the counts <K>biased</K> uses for the ⟨111⟩ easy axis, reached here from a completely different question.
+          </Para>
+
+          <WanderForward />
+
+          <Para>
+            The cone's mean step has a closed form and it is the whole mechanism: <b>1 for a face, 2√2/3 for an edge, √3/2 for a corner</b>. So a face's mean is <i>exactly its own heading</i> and its speed is 1 at every <V>w</V>, while the diagonals get pulled in — √2(1 − <V>w</V>/3) and √3(1 − <V>w</V>/2). <b>Wandering forward shortens the diagonals and leaves the axes alone</b>, which is precisely the correction wanted, and nothing had to be singled out by hand to get it: the asymmetry falls out of the cone counts.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            One <V>w</V> takes the spread to <b>1.57%</b>, against 3.5% for the constituent rule and 73% for none — and two zero it exactly, at <V>w</V> = 3(1 − 1/√2) = 0.8787 for an edge and 2(1 − 1/√3) = 0.8453 for a corner. Which is the first version of this that reads as a rule rather than a repair, and the first place <V>w</V> has had any reason to be one number rather than another.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And the distribution itself, swept through <V>w</V> — not one pulse at one age, which is only a shell, but <b>steady state</b>: a source pulses every tick, so charges of every age are in flight at once and the picture fills. Each cell is drawn against the mean at <i>its own radius</i>, so the 1/<V>r</V> falloff divides out and what is left is purely angular — where the field is thick and where it is thin. In the plane a forward cone always has <i>three</i> members, so the walk is a <b>trinomial</b> and every path is enumerated with its exact weight rather than sampled.
+          </Para>
+
+          <WanderVeins />
+
+          <Para>
+            <b>The veins have a reason.</b> A face heading's cone is {'{'}(1,0), (1,1), (1,−1){'}'} and every one of those has <V>x</V> = 1 — so <V>x</V> advances by exactly one a tick <i>whatever path is taken</i>, and the density piles up along the axis as a ridge that cannot spread radially at all. A diagonal's cone is {'{'}(1,0), (1,1), (0,1){'}'}, which fixes nothing, so it opens into a wedge. <b>Ridges along the eight headings, thin wedges between them</b> — a fact about which directions share a component, not about any parameter.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Turning <V>w</V> up fills the wedges and cannot flatten the ridges. The contrast printed under each panel is the thickest place at a radius over the mean at that radius: <b>7.7× at <V>w</V> = 0.3, and still 3.3× at the <V>w</V> that puts the ring on the circle</b>. So even where the front is a perfect circle, the field inside it is nowhere near smooth — which is the honest picture of what <K>chance</K>'s 1/<V>r</V><Sup>2</Sup> is an average over.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which is the honest state of it. <b>A circle is not recovered; it is chosen, by choosing what a heading is.</b> The lattice will as happily give a square, and a world where the discreteness of the spread genuinely mattered is not obviously ours to rule out — the residual here is a rank-four fingerprint worth 37 µm over a Hubble time, which is small but is not nothing, and is the one thing this whole route predicts that assuming a sphere never could.
+          </Para>
+
           <Law/>
         </Section>
       </Section>
 
       <Section head="XOR: Gravity + Magnetism">
+
         Instead of having our rays be neutral, we can introduce a polarity to them: positive/negative. When we do that gravity + magnetism comes down to three rules:
         <BR/>
         (G+M/1) Annihilation: When two opposite polarities meet, they annihilate, leaving a single neutral spatial point behind.
@@ -1695,6 +1838,15 @@ const Physics = () => {
             ticks: 22, height: 140,
           },
         }))}/>
+
+        <Section head="Gravity vs XOR">
+          - the heaviest elementary thing goes from ≈1.36 µg to ≈2.71 µg
+          - a body of given physical mass pulses half as often
+
+          <Eq>
+            <K><Bar>G</Bar></K><Sup><R>XOR</R></Sup> = <Frac over={1} under={2} /><K><Bar>G</Bar></K>
+          </Eq>
+        </Section>
         
         <Section head="XOR Continuous Model">
 
@@ -1800,21 +1952,33 @@ const Physics = () => {
           ]} />
 
           <Eq note="G doubles — and that is the whole of it">
-            <V>G</V> = <Frac
+            <i><K><Bar>G</Bar></K></i> = <Frac
               over={<><K><Bar>BITE</Bar></K>·<i>share</i>·<K><Bar>SHEET</Bar></K><Sup>2</Sup>·<K><Bar>c</Bar></K></>}
-              under={<>4<V>π</V><Sup>2</Sup>·<K><Bar>CORE</Bar></K>·<K><Bar>DEG</Bar></K></>} />
+              under={<>4<V>π</V><Sup>2</Sup>·{HALF}·<K><Bar>DEG</Bar></K></>} />
             <span style={{ padding: '0 1.4em' }} />
-            0.062351 → 0.124703
+            {gravitational(0.5).toFixed(6)} → {gravitational(1).toFixed(6)}
           </Eq>
 
           <Para>
-            <b>And the factor of two is not observable.</b> Every mass in the model is carried in units of <V>G</V>, so a body of physical mass <V>M</V> holds <V>M</V>/<V>G</V> and the dynamics compute <V>G</V>·(<V>M</V>/<V>G</V>). The constant is gone before it is used — <b>a change of the mass unit, not of a prediction</b>. Measured on the line integral: exactly two at every separation, with <V>S</V>·<V>R</V><Sup>2</Sup> flat in both.
+            <b>And the factor of two is not observable in an orbit.</b> Every mass in the model is carried in units of <i><K><Bar>G</Bar></K></i>, so a body of physical mass <V>M</V> holds <V>M</V>/<i><K><Bar>G</Bar></K></i> and the dynamics compute <i><K><Bar>G</Bar></K></i>·(<V>M</V>/<i><K><Bar>G</Bar></K></i>). The constant is gone before it is used — <b>a change of the mass unit, not of a trajectory</b>. Measured on the line integral: exactly two at every separation, with <V>S</V>·<V>R</V><Sup>2</Sup> flat in both.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>But "not of a prediction" would be too strong, and the exception is the mass unit itself.</b> It is not free to stay put — <V>µ</V> = <i><K><Bar>G</Bar></K></i>·<V>m</V><Sub>P</Sub>, so doubling one doubles the other. The heaviest elementary thing goes from <b>{(massUnit(0.5) * 1e9).toFixed(3)} µg to {(massUnit(1) * 1e9).toFixed(3)} µg</b>, and a body of given physical mass pulses <b>half as often</b>: an electron every 1.61·10<Sup>−22</Sup> s against 8.03·10<Sup>−23</Sup>. Which is the right direction rather than a fault — with no polarity every meeting annihilates instead of half of them, so each emission is twice as effective and half as much of it is needed for the same pull. Nothing measures that ceiling, so it refutes neither version; but it is a statement about the world, and it moves.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The tick and the step do <i>not</i> go with it, which is worth checking rather than assuming. At the ceiling the period is <i><K><Bar>G</Bar></K></i>ħ/(<V>µc</V><Sup>2</Sup>) = ħ/(<V>m</V><Sub>P</Sub><V>c</V><Sup>2</Sup>) — the <i><K><Bar>G</Bar></K></i> cancels — so both stay exactly Planck at either share. And so does the Compton line, whose constant tracks <i><K><Bar>G</Bar></K></i> because <V>µ</V> does: measured, <V>k</V>/<i><K><Bar>G</Bar></K></i> = 1.000000000 at both.
           </Para>
 
           <BR/>
 
           <Para>
-            <K><Bar>SHEET</Bar></K>, <K><Bar>DEG</Bar></K>, <K><Bar>BITE</Bar></K>, <K><Bar>BIAS</Bar></K>, <K><Bar>CORE</Bar></K>, <V>ε</V>, <V>D</V>, the reach and the tick do not move at all. And neither does anything predicted: Mercury's sixth, the other five sixths, light's deflection, <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π, the Milky Way to 1.1%, the transport turnover, the interpolation function, the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>. <b>All identical, to every digit quoted</b> — because every one of them is computed from something that never mentions a sign.
+            <K><Bar>SHEET</Bar></K>, <K><Bar>DEG</Bar></K>, <K><Bar>BITE</Bar></K>, <K><Bar>BIAS</Bar></K>, {HALF}, <V>ε</V>, <V>D</V>, the reach, the step and the tick do not move at all. And neither does anything <i>measured</i>: Mercury's sixth, the other five sixths, light's deflection, <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π, the Milky Way to 1.1%, the transport turnover, the interpolation function, the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>. <b>All identical, to every digit quoted</b> — because every one of them is computed from something that never mentions a sign.
           </Para>
 
           <BR/>
@@ -2320,17 +2484,17 @@ const Physics = () => {
               over={<><K>BITE</K>·<i>share</i>·<K>SHEET</K><Sup>2</Sup></>}
               under={<>4<V>π</V><Sup>2</Sup>·<K>CORE</K>·<K>DEG</K></>} />
             <span style={{ padding: '0 1.4em' }} />
-            0.062351 → 0.124703
+            {gravitational(0.5).toFixed(6)} → {gravitational(1).toFixed(6)}
           </Eq>
 
           <Para>
-            And the factor of two is not observable. Every mass in the model is carried in units of <K>GRAVITY</K>, so a body of physical mass <V>M</V> holds <V>M</V>/<K>G</K> and the dynamics compute <K>G</K>·(<V>M</V>/<K>G</K>). The constant is gone before it is used — <b>a change of the mass unit, not of a prediction</b>. Measured on the line integral: exactly two at every separation, with <V>S</V>·<V>R</V><Sup>2</Sup> flat in both.
+            And the factor of two is not observable in an orbit. Every mass in the model is carried in units of <K>GRAVITY</K>, so a body of physical mass <V>M</V> holds <V>M</V>/<K>G</K> and the dynamics compute <K>G</K>·(<V>M</V>/<K>G</K>). The constant is gone before it is used — <b>a change of the mass unit, not of a trajectory</b>. Measured on the line integral: exactly two at every separation, with <V>S</V>·<V>R</V><Sup>2</Sup> flat in both. The one thing it does carry with it is the mass unit itself: <V>µ</V> = <K>G</K>·<V>m</V><Sub>P</Sub>, so the heaviest elementary thing goes from {(massUnit(0.5) * 1e9).toFixed(3)} µg to {(massUnit(1) * 1e9).toFixed(3)} µg and every emitter pulses half as often. The step and the tick do not go with it — the <K>G</K> cancels out of both.
           </Para>
 
           <BR/>
 
           <Para>
-            <K>SHEET</K>, <K>DEG</K>, <K>BITE</K>, <K>BIAS</K>, <K>MADE</K>, <K>SPREAD</K>, <K>REACHES</K> and the tick do not move at all. And neither does anything predicted: Mercury's sixth, the other five sixths, light's deflection, <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π, the Milky Way to 1.1%, the transport turnover, the interpolation function, the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>. <b>All identical, to every digit quoted</b> — because every one of them is computed from something that never mentions a sign.
+            <K>SHEET</K>, <K>DEG</K>, <K>BITE</K>, <K>BIAS</K>, <K>MADE</K>, <K>SPREAD</K>, <K>REACHES</K>, the step and the tick do not move at all. And neither does anything <i>measured</i>: Mercury's sixth, the other five sixths, light's deflection, <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π, the Milky Way to 1.1%, the transport turnover, the interpolation function, the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>. <b>All identical, to every digit quoted</b> — because every one of them is computed from something that never mentions a sign.
           </Para>
 
           <BR/>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
index bd3ff32..3668001 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/gravity.ts
@@ -1402,8 +1402,24 @@ export const annihilation = (
  * FRACTION of your paths that got biased, and a heavier thing brought
  * proportionally more paths to the meeting.
  */
-export const G_LATTICE =
-  BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
+/**
+ * WITH `share` LEFT IN THE OPEN, because it is the one symbol in here that is
+ * not a count of the lattice — it is a fact about the matter involved.
+ *
+ * Half is the chance two charges landing in the same cell have OPPOSITE sign,
+ * which is what unbiased matter gives (see `annihilating` in `magnet.ts`), and
+ * it is why the constant used to be written with an `8π²` — the half folded
+ * into it and stopped being visible. Taking the polarity away entirely makes
+ * every meeting annihilate rather than half of them, so `share` goes to one and
+ * the constant DOUBLES. That is a change of the mass unit rather than of a
+ * trajectory (`MU = G·m_Planck` scales with it, so every mass carried as
+ * `M/G` is untouched), and the article prints both values off this function
+ * rather than transcribing them.
+ */
+export const gravitational = (share = 0.5) =>
+  BITE * share * SHEET * SHEET * LIGHT / (4 * Math.PI * Math.PI * CORE * DEG);
+
+export const G_LATTICE = gravitational();
 
 /**
  * And the same constant in the units a panel is drawn in, which is the only
@@ -2443,6 +2459,17 @@ const L_PLANCK = 1.616255e-35, T_PLANCK = 5.391247e-44, M_PLANCK = 2.176434e-8;
 const MPC = 3.0856775814913673e22, GYR = 3.1557e16, C_SI = 2.99792458e8;
 const MU_SI = G_LATTICE * M_PLANCK;
 
+/**
+ * The lattice's mass unit in kilograms — the heaviest thing that can pulse on
+ * its own, since `m ≤ 1` is one pulse a tick.
+ *
+ * Exported so the article can print it rather than transcribe it, and taking
+ * `share` for the same reason `gravitational` does: it is the ONE quantity the
+ * no-polarity variant actually moves. The step and the tick do not go with it —
+ * `G` cancels out of both — so this is the whole of what that choice costs.
+ */
+export const massUnit = (share = 0.5) => gravitational(share) * M_PLANCK;
+
 /**
  * THE FRONTIER COSMOLOGY, AS ARITHMETIC — because it had none, and that was
  * the thing wrong with it.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index cf4e584..4d55624 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -1,6 +1,6 @@
 import { Children, Fragment, isValidElement, ReactNode, useEffect, useRef, useState } from "react";
 
-import { GRAIN } from "./gravity";
+import { GRAIN, gravitational, massUnit } from "./gravity";
 import { Echoes } from "./echoes";
 import {
   Apart, Discs, HighRedshift, HighZCurves, HighZDiscs, Rotation, Split,
@@ -66,6 +66,10 @@ export const K = ({ children }: { children: ReactNode }) => (
   <span style={{ color: NAMED, fontStyle: 'normal' }}>{children}</span>
 );
 
+export const R = ({ children }: { children: ReactNode }) => (
+  <span style={{ color: 'indianred', fontStyle: 'normal' }}>{children}</span>
+);
+
 export const F = ({ children }: { children: ReactNode }) => (
   <span style={{ color: FAINT, fontStyle: 'normal' }}>{children}</span>
 );
@@ -1076,38 +1080,355 @@ half out   1.98   1.88   1.76   1.41   1.00   1.00`}
   </>,
 };
 
+export const CEILING: Derivation = {
+  label: 'G as a mass',
+  title: <>the constant, read as a mass in Planck masses</>,
+  body: <>
+    <Because>where each symbol comes from — one body first</Because>
+    <Step eq={<>
+      chance(<V>m</V>,<V>r</V>) =
+      <Frac over={<><V>m</V> · <K>SHEET</K></>} under={<>shell(<V>r</V>)</>} />
+    </>}>
+      A source lets go of <K>SHEET</K> charges a pulse and they spread over the
+      shell they have grown to, so the chance a given cell is holding one is that
+      count over how much shell there is. <b style={{ color: INK }}>One factor of{' '}
+        <K>SHEET</K>, per body.</b> The inverse square is already here and
+      nobody wrote it down: a shell in three dimensions goes as <V>r</V><Sup>2</Sup>.
+    </Step>
+
+    <Because>and a meeting needs BOTH of them in the same cell — which is where the square is</Because>
+    <Step eq={<>
+      chance(<V>m</V><Sub>a</Sub>, <V>x</V>) ·
+      chance(<V>m</V><Sub>b</Sub>, <V>R</V>−<V>x</V>)
+    </>}>
+      <b style={{ color: INK }}><K>SHEET</K><Sup>2</Sup> is one factor from each
+        body, not a sheet squared.</b> The two carry different masses and sit at
+      different radii, which is the whole tell — a square coming from the sheet’s
+      own shape would carry one mass at one place. It is also where{' '}
+      <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> comes from: drop either factor and
+      the law stops being about two bodies.
+    </Step>
+
+    <Because>summed along the line between them, which is the line an annihilation shortens</Because>
+    <Step eq={<>
+      met(<V>R</V>) =
+      <Frac over={<>4</>} under={<><K>CORE</K> <V>R</V><Sup>2</Sup></>} />
+      <Paren>1 + <Frac over={<K>CORE</K>} under={<V>R</V>} /> ln
+        <Frac over={<><V>R</V>−<K>CORE</K></>} under={<K>CORE</K>} /></Paren>
+    </>}>
+      Two inverse squares multiplied and added up along the line collapse back to{' '}
+      <i>one</i> inverse square, times a bracket that goes to one. The 1/<K>CORE</K>{' '}
+      is the two dense ends. Worked out under <i>met(R)</i>.
+    </Step>
+
+    <Because>and what one meeting is worth to a path</Because>
+    <Step eq={<><K>BIAS</K> = <Frac over={<K>LIGHT</K>} under={<K>DEG</K>} /></>}>
+      One annihilation leaves one extra way out of that point, against the{' '}
+      <K>DEG</K> ways that were already there. Multiply the meeting rate by it
+      and collect: the (4<V>π</V>)<Sup>2</Sup> from the two shells, with met’s 4
+      divided back out, is the 4<V>π</V><Sup>2</Sup>.
+    </Step>
+
+    <Because>so the formula is counted — and now the second question</Because>
+    <Step eq={<>
+      <K>G</K> =
+      <Frac over={<><K>BITE</K> · <i>share</i> · <K>SHEET</K><Sup>2</Sup> · <K>c</K></>}
+        under={<>4<V>π</V><Sup>2</Sup> · <K>CORE</K> · <K>DEG</K></>} />
+    </>}>
+      Every symbol a count, and none of it fitted. The rest of this panel is the
+      other question:{' '}
+      <b style={{ color: INK }}>why the ceiling <V><Bar>m</Bar></V> = 1 hands you
+        that same number.</b>
+    </Step>
+
+    <Because>what the ceiling is, in kilograms</Because>
+    <Step eq={<>
+      <V><Bar>m</Bar></V> = 1
+      <span style={{ padding: '0 0.8em', color: FAINT }}>⇒</span>
+      <V>µ</V> = {(massUnit(1) * 1e9).toFixed(3)} µg
+    </>}>
+      One pulse a tick is the most anything can do, so there is a heaviest thing
+      that can pulse on its own, and it has a definite weight. Call it <V>µ</V>.
+      That is the lattice’s own mass unit — arrived at from the tick rule, with
+      no object anywhere in it.
+    </Step>
+
+    <Because>to say what µ IS you need a yardstick with no object in it either</Because>
+    <Step eq={<>
+      <V>m</V><Sub>P</Sub> = √(ħ<V>c</V>/<V>G</V>) =
+      {(2.176434e-8 * 1e9).toFixed(2)} µg
+    </>}>
+      Comparing <V>µ</V> to an electron would give a number that says nothing —
+      it would be a fact about which particles happen to exist. The Planck mass
+      is the only mass that can be built out of <V>c</V>, ħ and <V>G</V> alone,
+      so it is the one yardstick with nothing contingent in it. It is also{' '}
+      <b style={{ color: INK }}>where a mass’s two lengths cross</b>: its
+      quantum length ħ/<V>Mc</V> shrinks as <V>M</V> grows and its gravitational
+      length <V>GM</V>/<V>c</V><Sup>2</Sup> grows, and they meet there.
+    </Step>
+
+    <Because>and in Planck’s units the gravitational constant is one</Because>
+    <Step eq={<><K>G</K> = 1
+      <span style={{ padding: '0 0.8em', color: FAINT }}>in</span>
+      (<V>l</V><Sub>P</Sub>, <V>t</V><Sub>P</Sub>, <V>m</V><Sub>P</Sub>)</>}>
+      That is what Planck units <i>are</i> — the system built so that{' '}
+      <V>c</V> = ħ = <V>G</V> = 1. So any number other than one that <V>G</V>{' '}
+      takes is a statement about how the units being used differ from those.
+    </Step>
+
+    <Because>and the lattice already shares two of the three</Because>
+    <Step eq={<>
+      step = <V>l</V><Sub>P</Sub>
+      <span style={{ padding: '0 1em' }} />
+      tick = <V>t</V><Sub>P</Sub>
+      <span style={{ padding: '0 1em' }} />
+      [<V>G</V>] = length³/(time²·mass)
+    </>}>
+      With the length and the time already Planck’s,{' '}
+      <b style={{ color: INK }}>the only thing left that can move <V>G</V>’s
+        number is the mass unit</b> — and since mass sits alone in the
+      denominator of <V>G</V>’s units, it moves it in direct proportion. There is
+      nothing else in the expression for it to be about.
+    </Step>
+
+    <Because>so</Because>
+    <Step eq={<>
+      <K>G</K> = <V>µ</V>/<V>m</V><Sub>P</Sub> =
+      {gravitational(1).toFixed(6)}
+    </>}>
+      <b style={{ color: INK }}>The gravitational constant here is not a
+        strength. It is the heaviest elementary thing, weighed in Planck
+        masses.</b> Exactly, with nothing to compute:{' '}
+      {(massUnit(1) * 1e9).toFixed(3)} µg against{' '}
+      {(2.176434e-8 * 1e9).toFixed(2)} µg. And read the other way,{' '}
+      1/<K>G</K> = {(1 / gravitational(1)).toFixed(3)} is how many times lighter
+      than nature’s own mass the lattice’s own mass is.
+    </Step>
+
+    <Because>which is why it is not one, and that is the whole of what it says</Because>
+    <Step>
+      Two definitions of a mass, neither of which mentions any object. Nature’s
+      is where a mass’s quantum length and its gravitational length cross. The
+      lattice’s is the heaviest thing that can pulse once a tick.{' '}
+      <b style={{ color: INK }}><K>G</K> ≠ 1 is the statement that those two do
+        not agree</b>, and its value is the amount by which they miss.
+    </Step>
+
+    <Because>with the polarity put back, both halve together</Because>
+    <Step eq={<>
+      <K>G</K>: {gravitational(1).toFixed(6)} → {gravitational(0.5).toFixed(6)}
+      <span style={{ padding: '0 1em' }} />
+      <V>µ</V>: {(massUnit(1) * 1e9).toFixed(3)} → {(massUnit(0.5) * 1e9).toFixed(3)} µg
+    </>}>
+      This arc has no signs in it, so every meeting annihilates and{' '}
+      <i>share</i> = 1. Once polarity arrives only half of them do, ordinary
+      matter being unbiased, and the constant halves. <V>µ</V> halves with it,
+      because <V>µ</V> = <K>G</K>·<V>m</V><Sub>P</Sub> — so the ratio above is
+      untouched and so is every orbit, since masses are carried in units of{' '}
+      <K>G</K>. <b style={{ color: INK }}>What changes is the mass unit and
+        nothing else.</b>
+    </Step>
+
+    <Because>and one number here is a trap</Because>
+    <Step eq={<>
+      1/<K>G</K> = {(1 / gravitational(1)).toFixed(4)}
+      <span style={{ padding: '0 1em', color: FAINT }}>against</span>
+      <K>SHEET</K> = 8
+    </>}>
+      <b style={{ color: BORROWED }}>Those are not the same number and should
+        not be read as one.</b> They agree to{' '}
+      {(100 * Math.abs(1 / gravitational(1) - 8) / 8).toFixed(2)}%, which is
+      close enough to invite a story and far enough to be nothing —{' '}
+      1/<K>G</K> carries a 4<V>π</V><Sup>2</Sup> and a <K>DEG</K> that no count
+      of <K>SHEET</K> cancels. This file warns against exactly this kind of near
+      miss elsewhere, and the warning applies to itself.
+    </Step>
+  </>,
+};
+
 export const CLOCK: Derivation = {
   label: 'mass as a period',
   title: <>once a tick is the ceiling</>,
   body: <>
-    <Because>mass is how often, so turn it round</Because>
-    <Step eq={<><V>X</V> = 1/<V>m</V> ticks between pulses,&nbsp;&nbsp;<V>m</V> ≤ 1</>}>
-      A heavier thing pulses more often, and nothing pulses more than once a
-      tick. So mass is a <i>period</i>, and there is a largest elementary
-      mass: the lattice mass unit is <V>G</V>·<V>m</V><Sub>Planck</Sub> ≈
-      1.36 µg. Anything heavier has to be many emitters — which is what matter
-      is.
+    <Because>what the lattice says, which so far is only a rewriting</Because>
+    <Step eq={<>
+      0 ≤ <V><Bar>m</Bar></V> ≤ <K><Bar>c</Bar></K>
+      <span style={{ padding: '0 1em' }} />
+      <V><Bar>m</Bar></V>.period = 1/<V><Bar>m</Bar></V>
+      <span style={{ padding: '0 0.8em', color: FAINT }}>ticks</span>
+    </>}>
+      Mass here is what <i>fraction of the ticks</i> a thing spends pulsing, so
+      the ceiling needs no argument beyond what a fraction is: you cannot spend
+      more than all of them. Turned round it is a period — something of mass{' '}
+      <V><Bar>m</Bar></V> pulses once every 1/<V><Bar>m</Bar></V> ticks — and the
+      ceiling is one pulse a tick, the same one-thing-a-tick that makes{' '}
+      <K><Bar>c</Bar></K> one step a tick. So{' '}
+      <b style={{ color: INK }}>there is a heaviest elementary thing</b>:
+      anything above it is not one emitter but many.
+    </Step>
+
+    <Because>turn that period into a length, which is the only move made here</Because>
+    <Step eq={<>
+      <V><Bar>m</Bar></V>.period · <K><Bar>c</Bar></K> = 1/<V><Bar>m</Bar></V>
+      <span style={{ padding: '0 0.8em', color: FAINT }}>steps</span>
+    </>}>
+      How far does light get between one pulse and the next? A step a tick, so{' '}
+      1/<V><Bar>m</Bar></V> steps — the spacing between the shells a source has
+      in flight. <b style={{ color: INK }}>Nothing has been claimed yet</b>: this
+      is the definition of mass with a <K><Bar>c</Bar></K> beside it, true by
+      arithmetic. But it does say that{' '}
+      <b style={{ color: INK }}>every mass has a length attached to it</b>, and
+      that doubling the mass halves the length — exactly, not roughly. That is
+      the kind of claim that can be wrong.
+    </Step>
+
+    <Because>and one thing in physics already has that shape</Because>
+    <Step eq={<>
+      <D><V>λ</V><Sub>Compton</Sub></D> =
+      <Frac over={<>ħ</>} under={<><V>Mc</V></>} />
+    </>}>
+      The <i>reduced</i> Compton wavelength, and where it comes from has nothing
+      to do with lattices. Put <V>E</V> = <V>Mc</V><Sup>2</Sup> — a mass is an
+      amount of energy — together with <V>E</V> = ħ<V>ω</V> — an amount of
+      energy is a rate of turning. Every mass therefore has a frequency, and
+      light travelling for one of its periods covers ħ/<V>Mc</V>. Heavier is
+      shorter, in exact inverse proportion, same as the pulse spacing.{' '}
+      <b style={{ color: BORROWED }}>Mind which one:</b> the unreduced{' '}
+      <V>h</V>/<V>Mc</V> is 2π bigger, and the constant below is for the reduced.
+    </Step>
+
+    <Because>two lengths that both go as 1/M are proportional, so the whole question is the constant</Because>
+    <Step eq={<>
+      <V><Bar>m</Bar></V>.period · <K><Bar>c</Bar></K> = <V>k</V> ·
+      <D><V>λ</V><Sub>Compton</Sub></D>
+      <span style={{ padding: '0 1em', color: FAINT }}><V>k</V> dimensionless</span>
+    </>}>
+      Not approximately and not over some range —{' '}
+      <i>exactly, at every mass</i>, because both sides are a something over the
+      mass and the mass divides out between them. One pure number left to find.
+    </Step>
+
+    <Because>and the way to find it is to ask it at the ceiling, where both sides are easy</Because>
+    <Step eq={<>
+      <V><Bar>m</Bar></V> = 1
+      <span style={{ padding: '0 0.8em', color: FAINT }}>⇒ pulse spacing =</span>
+      1 step
+    </>}>
+      The ratio is the same at every mass, so it may as well be read off the one
+      mass where nothing has to be computed. At the ceiling a thing pulses every
+      tick and light goes a step a tick, so{' '}
+      <b style={{ color: INK }}>its pulse spacing is exactly one step</b>. All
+      that is left is: how long is <i>its</i> Compton wavelength, in steps?
+    </Step>
+
+    <Because>which needs one fact about the Planck mass, and it is a definition rather than a coincidence</Because>
+    <Step eq={<>
+      ħ/(<V>m</V><Sub>P</Sub><V>c</V>) = <V>l</V><Sub>P</Sub>
+      <span style={{ padding: '0 1em', color: FAINT }}>= 1 step</span>
+    </>}>
+      <b style={{ color: INK }}>The Planck mass is defined as the mass whose
+        reduced Compton wavelength is the Planck length.</b> And the lattice’s
+      step <i>is</i> the Planck length. So the Planck mass is the mass whose
+      Compton wavelength is exactly one step — which turns the question into a
+      comparison of two masses rather than of two lengths.
+    </Step>
+
+    <Because>so the constant is just how much lighter the ceiling is than that</Because>
+    <Step eq={<>
+      <V>µ</V> = <V>k</V>·<V>m</V><Sub>P</Sub>
+      <span style={{ padding: '0 1em', color: FAINT }}>⇒ its wavelength is</span>
+      1/<V>k</V> steps
+    </>}>
+      A Compton wavelength goes as 1/<V>M</V>, so something <i>k</i> times
+      lighter than the Planck mass has a wavelength 1/<i>k</i> times longer. Set
+      that against the one step of pulse spacing and the ratio is <i>k</i> —
+      which was what we were solving for, so it closes on itself and says the
+      constant is <b style={{ color: INK }}>the ceiling mass in Planck
+        masses</b>.
+    </Step>
+
+    <Because>and that ratio is the gravitational constant, for a reason about units</Because>
+    <Step eq={<>
+      <K>G</K> = 1
+      <span style={{ padding: '0 0.6em', color: FAINT }}>in Planck units, so</span>
+      <K>G</K><Sub>lattice</Sub> = <V>µ</V>/<V>m</V><Sub>P</Sub>
+    </>}>
+      Planck’s units are the ones built out of <V>c</V>, ħ and <V>G</V>
+      themselves, with no object anywhere in them, and in them <V>G</V> is
+      exactly one. The lattice already shares two of the three — its step is{' '}
+      <V>l</V><Sub>P</Sub> and its tick is <V>t</V><Sub>P</Sub> — and <V>G</V>{' '}
+      has units of length³/(time²·mass), so with the length and the time already
+      Planck’s,{' '}
+      <b style={{ color: INK }}>the only thing left that can move <V>G</V>’s
+        number is the mass unit</b>, and it moves it in direct proportion.
+      Hence <V>k</V> = <K>G</K> exactly, with nothing to compute.
     </Step>
 
-    <Because>turn the period into a length</Because>
+    <Because>so</Because>
     <Step eq={<>
-      <V>X</V>·<V>c</V> = <V>G</V> ·
-      <Frac over={<>ħ</>} under={<><V>mc</V></>} /> = <V>G</V> · <V>λ</V><Sub>Compton</Sub>
+      <V><Bar>m</Bar></V>.period · <K><Bar>c</Bar></K> = <K>G</K> ·
+      <D><V>λ</V><Sub>Compton</Sub></D>
+      <span style={{ padding: '0 1em', color: FAINT }}>
+        <K>G</K> = {gravitational().toFixed(6)}
+      </span>
     </>}>
-      Exactly, at every mass. Measured across twenty orders — electron, proton,
-      uranium atom, virus, grain of sand — the ratio is 0.062329 every time,
-      against <V>G</V> = 0.062351.
+      Read as a picture: <b style={{ color: INK }}>1/<K>G</K> ≈ 16 is how many
+        pulses the heaviest emitter fits inside its own Compton
+        wavelength</b> — one step between pulses, sixteen steps of wavelength.
+      And it holds at every mass for free, because halving the mass doubles the
+      spacing and doubles the wavelength together. Checked at four masses over
+      twenty-five orders — electron, proton, iron atom, a milligram grain — the
+      ratio is {gravitational().toFixed(9)} at every one, to nine figures.
+    </Step>
+
+    <Because>which says what G is here, and it is not a strength</Because>
+    <Step eq={<>
+      <V>µ</V> = <K>G</K>·<V>m</V><Sub>P</Sub> ≈ <V>m</V><Sub>P</Sub>/16
+    </>}>
+      <b style={{ color: INK }}><K>G</K> ≠ 1 is the statement that the lattice’s
+        natural mass is not nature’s natural mass.</b> Two definitions of a mass
+      with no object in either: nature’s is where a mass’s quantum length ħ/<V>Mc</V>{' '}
+      and its gravitational length <V>GM</V>/<V>c</V><Sup>2</Sup> cross; the
+      lattice’s is the heaviest thing that can pulse once a tick. They disagree
+      by sixteen, and <K>G</K> is the disagreement.
+    </Step>
+
+    <Because>what is derived here and what is one calibration — said plainly</Because>
+    <Step eq={<>
+      tick = <V>k</V>·<V>t</V><Sub>P</Sub>
+      <span style={{ padding: '0 0.8em', color: FAINT }}>⇒ the constant is</span>
+      <V>k</V><Sup>2</Sup>·<K>G</K>
+    </>}>
+      The lattice has three units — a step, a tick and a mass — and two things
+      already relate them: <K><Bar>c</Bar></K> = one step a tick, and the counted{' '}
+      <K>G</K>. That leaves exactly <i>one</i> scale free. Leave it free and
+      watch: with the tick at <V>k</V> Planck times the step is <V>k</V>{' '}
+      <V>l</V><Sub>P</Sub> and the mass unit is <V>k</V><K>G</K><V>m</V><Sub>P</Sub>,
+      so the constant above comes out at <V>k</V><Sup>2</Sup><K>G</K> — and
+      demanding it be <K>G</K> is exactly <V>k</V> = 1.{' '}
+      <b style={{ color: INK }}>So “the tick is the Planck time” and “the pulse
+        spacing is <K>G</K> Compton wavelengths” are one statement, not two
+        agreeing ones.</b> One condition, one free scale, spent.
+    </Step>
+
+    <Step>
+      <b style={{ color: INK }}>The shape is derived and the value is one
+        calibration</b>, and they should not be quoted as two results. What the
+      twenty-five orders check is the shape — that the ratio does not drift with
+      mass — and nothing was free to arrange that. What would turn the value into
+      a prediction is anything that weighs the ceiling on its own terms.{' '}
+      <b style={{ color: BORROWED }}>Nothing does.</b>
     </Step>
 
-    <Because>and it is not a coincidence</Because>
+    <Because>and which way round it goes, which is the surprise</Because>
     <Step>
-      <V>m</V><Sub>P</Sub>·<V>l</V><Sub>P</Sub> = ħ/<V>c</V>, so “period = 1/mass”
-      in the lattice’s own units <i>is</i> the Compton relation.{' '}
       <b style={{ color: INK }}>The identity was put here to make the
-        equivalence principle fall out of counting, and it turns out to have
-        been a quantum statement the whole time.</b> The lattice is not a
-      classical model waiting to have quantum mechanics added — <V>E</V> = ħω
-      is a consequence of what it already means by mass.
+        equivalence principle fall out of counting</b> — a heavier thing brings
+      proportionally more paths to a meeting, so the mass divides back out and
+      everything falls the same way — <b style={{ color: INK }}>and it turns out
+        to have been a quantum statement the whole time.</b> The lattice is not a
+      classical model waiting to have quantum mechanics added: mass being a rate{' '}
+      <i>is</i> <V>E</V> = ħ<V>ω</V>, and it was there from the first line.
     </Step>
   </>,
 };
@@ -1731,7 +2052,11 @@ export const FULL: Derivation = {
       EMIT<Sup>2</Sup> · met(<V>R</V>)
     </>}>
       Momentum gained is <K>BIAS</K> times the meetings, and the meetings are
-      the two densities integrated along the line.
+      the two densities integrated along the line.{' '}
+      <b style={{ color: INK }}>EMIT is squared because a meeting needs one
+        charge from each body</b> — <K>SHEET</K> once for <V>a</V> and once for{' '}
+      <V>b</V>, which is the same pairing that puts{' '}
+      <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> there. It is not a sheet squared.
     </Step>
 
     <Because>substitute met, with share = ½ and BITE = 1</Because>
@@ -6073,7 +6398,7 @@ export const WithoutPolarity = () => (
         over={<><K>BITE</K>·<i>share</i>·<K>SHEET</K><Sup>2</Sup></>}
         under={<>4<V>π</V><Sup>2</Sup>·<K>CORE</K>·<K>DEG</K></>} />
       <span style={{ padding: '0 1.4em' }} />
-      0.062351 → 0.124703
+      {gravitational(0.5).toFixed(6)} → {gravitational(1).toFixed(6)}
     </Eq>
 
     <Note>
@@ -6110,8 +6435,9 @@ export const WithoutPolarity = () => (
           place with no angle to gate.</>],
       [<span style={{ color: BORROWED }}>and the rest</span>,
         <><i>reach</i>’s λ is shorter by √2, worth 1.9·10<Sup>−10</Sup> →
-          3.8·10<Sup>−10</Sup> on the pull at 30 kpc. <K>MU</K> doubles to
-          2.71 µg. The Compton ratio becomes 0.124703 and stays exact. All three
+          3.8·10<Sup>−10</Sup> on the pull at 30 kpc. <K>MU</K> doubles to{' '}
+          {(massUnit(1) * 1e9).toFixed(2)} µg. The Compton ratio becomes{' '}
+          {gravitational(1).toFixed(6)} and stays exact. All three
           are statements about units or about nothing anyone will weigh.</>],
     ]} />
 
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
new file mode 100644
index 0000000..7586a7d
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
@@ -0,0 +1,1006 @@
+/**
+ * DOES A SQUARE PULSE EVER BECOME A ROUND ONE — drawn, because the answer is
+ * half yes and a table hides which half.
+ *
+ * THE OBJECTION. A charge moves one cell a tick and a cell has 26 ways out of
+ * it, so after `t` ticks a pulse is at CHEBYSHEV distance t — which is a CUBE
+ * shell, not a sphere. The face rays have covered Euclidean t, the edge rays
+ * √2 t, the corner rays √3 t. The closed form meanwhile divides by `4πr²`.
+ * Those are different shapes, and scaling a cube gives a cube: the ratio
+ * corner/face is 1.7321 at t = 10 and at t = 10³⁸ alike. Nothing about being
+ * far away rounds it off.
+ *
+ * WHAT `wander` DOES ABOUT IT. `physics.ts` already carries the rule — a ray
+ * takes one of the ways its direction is MADE OF instead of the direction
+ * itself, so a (1,1,1) sometimes steps (1,0,0). That slows the diagonals in
+ * Euclidean terms, which is exactly the right medicine, and with one `w` for
+ * every class it takes the spread from 73% to 3.5%.
+ *
+ * AND THE 3.5% IS NOT IRREDUCIBLE, which is the finding here. A direction with
+ * `n` non-zero components has mean speed `(1 − w(n−1)/n)·√n`, and setting that
+ * to one solves in closed form:
+ *
+ *     w(n) = √n / (√n + 1)        0.5858 for an edge, 0.6340 for a corner
+ *
+ * — at which the mean speed is 1.000000000 in ALL 26 directions. The 3.5% was
+ * the cost of insisting on a single `w`, not a fact about the lattice.
+ *
+ * SO WHAT SURVIVES AND WHAT DOES NOT. Three things were measured, and they do
+ * not agree with each other:
+ *
+ *   the front's RADIUS      fixed. Every ray lands on the sphere of radius t,
+ *                           exactly, and the drawn front is a circle.
+ *   the shell's DENSITY     fixed, and this is the one that matters for the
+ *                           physics: plain propagation puts 0.853553 of the
+ *                           closed form's `SHEET/4πr²` through a shell, so `G`
+ *                           would be out by 0.7286. Wandered — or with steps
+ *                           costing their own length — it is 1.000000 exactly.
+ *   the front's DIRECTIONS  NOT fixed, and it gets worse with distance. A
+ *                           wandering beam's angular width goes as 1/√t, so
+ *                           the beams COLLIMATE: 11.1° at t = 10, 0.70° at
+ *                           t = 2560, and 26 cones of that width cover
+ *                           2.4·10⁻⁶ of the sky by t = 10⁶.
+ *
+ * And no averaging saves the last one, because the lattice is translation
+ * invariant: every emitter at every site has the same 26 exits, so averaging
+ * over positions, orientations, phases or 10³⁹ constituents never makes a
+ * twenty-seventh direction.
+ *
+ * WHICH LEAVES A SPLIT WORTH BEING PRECISE ABOUT. What the closed form needs
+ * from the lattice is a NUMBER — how much of a source is at a place — and
+ * wandering delivers that number exactly. What it does not deliver is the
+ * PICTURE: the flux is on 26 needles rather than smeared over the shell, so
+ * `chance` is right on average and wrong at any particular point. Every
+ * prediction in the article is computed from the average. None of them is
+ * computed from a particular point.
+ *
+ * Numbers here are computed in this file, exactly where exact is possible: the
+ * per-heading end distribution is a multinomial over (full steps, constituent
+ * steps) and is enumerated rather than sampled.
+ */
+
+import { CanvasView, Surface } from "./canvas";
+
+const INK = "#c8cbd4", FAINT = "#5a5f6e", GRID = "rgba(255,255,255,0.055)";
+const MODEL = "#4aa8eb", DATA = "#eb964a", SEEN = "#eef0f5";
+const GOOD = "#8bd48b", BAD = "#e0685f";
+const BACK = "#08090d";
+
+/** The wander that makes a direction's mean speed exactly one. */
+export const wanderFor = (n: number) => Math.sqrt(n) / (Math.sqrt(n) + 1);
+
+/** The eight ways out of a point that lie in one plane — a sheet's worth. */
+const SHEET_2D: [number, number][] = [
+  [1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1],
+];
+
+const lfac = (() => {
+  const t = [0];
+  for (let i = 1; i < 512; i++) t.push(t[i - 1] + Math.log(i));
+  return (n: number) => t[n];
+})();
+
+type Cloud = { x: number; y: number; p: number }[];
+
+/**
+ * Where one heading's charges are after `t` ticks — exactly, by enumerating
+ * the multinomial rather than by walking anything.
+ *
+ * A heading with `n` active axes takes the full step with probability 1 − w
+ * and one of its `n` constituents with probability w/n. After `t` ticks the
+ * displacement on active axis `i` is `k + m_i`, where `(k, m₁…mₙ)` is
+ * multinomial — so the whole distribution is a sum over `k` and the `mᵢ`.
+ */
+const cloudOf = (d: [number, number], t: number, mode: Mode): Cloud => {
+  const n = (d[0] ? 1 : 0) + (d[1] ? 1 : 0);
+
+  if (mode !== "wander" || n === 1) {
+    // Plain: one cell a tick, so a diagonal covers √2 per tick. Normalised:
+    // the step is scaled to unit Euclidean length. Either way, one point.
+    const s = mode === "normalised" ? 1 / Math.hypot(...d) : 1;
+    return [{ x: d[0] * t * s, y: d[1] * t * s, p: 1 }];
+  }
+
+  const w = wanderFor(n), out: Cloud = [];
+
+  for (let k = 0; k <= t; k++)
+    for (let m1 = 0; m1 <= t - k; m1++) {
+      const m2 = t - k - m1;
+      const lp = lfac(t) - lfac(k) - lfac(m1) - lfac(m2)
+        + k * Math.log(1 - w) + (m1 + m2) * Math.log(w / 2);
+      const p = Math.exp(lp);
+
+      if (p > 1e-9) out.push({ x: d[0] * (k + m1), y: d[1] * (k + m2), p });
+    }
+
+  return out;
+};
+
+type Mode = "plain" | "wander" | "normalised";
+
+const TITLE: Record<Mode, string> = {
+  plain: "one cell a tick",
+  wander: "wandered, w = √n/(√n+1)",
+  normalised: "steps cost their length",
+};
+
+const BLURB: Record<Mode, string> = {
+  plain: "the front is a SQUARE — diagonals overshoot by √2",
+  wander: "the front is a CIRCLE — but lumpy, and the lumps sharpen",
+  normalised: "a circle, and no width at all",
+};
+
+// ---------------------------------------------------------------------------
+
+const pattern = (t: number) => (s: Surface) => {
+  const { ctx, width, height } = s;
+
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK;
+  ctx.fillRect(0, 0, width, height);
+
+  const modes: Mode[] = ["plain", "wander", "normalised"];
+  const cw = width / 3, pad = 14;
+  const R = Math.min(cw / 2 - pad, (height - 54) / 2);
+  const scale = R / (t * Math.SQRT2);           // so the square's corners fit
+
+  modes.forEach((mode, col) => {
+    const cx = cw * (col + 0.5), cy = 22 + R;
+
+    ctx.save();
+    ctx.beginPath();
+    ctx.rect(cw * col, 0, cw, height);
+    ctx.clip();
+
+    // what the closed form assumes: the circle of radius t
+    ctx.strokeStyle = DATA;
+    ctx.globalAlpha = 0.5;
+    ctx.setLineDash([3, 3]);
+    ctx.beginPath();
+    ctx.arc(cx, cy, t * scale, 0, Math.PI * 2);
+    ctx.stroke();
+    ctx.setLineDash([]);
+
+    // what one cell a tick actually reaches: the square
+    ctx.strokeStyle = GRID;
+    ctx.globalAlpha = 1;
+    ctx.strokeRect(cx - t * scale, cy - t * scale, 2 * t * scale, 2 * t * scale);
+
+    // the charges
+    let peak = 0;
+    const clouds = SHEET_2D.map(d => cloudOf(d, t, mode));
+    for (const c of clouds) for (const q of c) peak = Math.max(peak, q.p);
+
+    for (const c of clouds)
+      for (const q of c) {
+        const a = Math.min(1, Math.pow(q.p / peak, 0.42));
+        ctx.fillStyle = MODEL;
+        ctx.globalAlpha = 0.14 + 0.86 * a;
+        const r = mode === "wander" ? 1.7 : 2.6;
+        ctx.beginPath();
+        ctx.arc(cx + q.x * scale, cy - q.y * scale, r, 0, Math.PI * 2);
+        ctx.fill();
+      }
+
+    ctx.globalAlpha = 1;
+    ctx.fillStyle = SEEN;
+    ctx.beginPath();
+    ctx.arc(cx, cy, 2, 0, Math.PI * 2);
+    ctx.fill();
+
+    ctx.fillStyle = INK;
+    ctx.font = "12px ui-sans-serif, system-ui, sans-serif";
+    ctx.textAlign = "center";
+    ctx.fillText(TITLE[mode], cx, 14);
+
+    ctx.fillStyle = FAINT;
+    ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText(BLURB[mode], cx, height - 20);
+
+    ctx.restore();
+  });
+
+  ctx.fillStyle = FAINT;
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  ctx.textAlign = "left";
+  ctx.fillText(
+    `one pulse, ${t} ticks — dashed: the circle of radius t the closed form divides by`,
+    10, height - 6,
+  );
+};
+
+// ---------------------------------------------------------------------------
+
+/** Angular width of a wandering beam, against distance. Log–log. */
+const collimation = (s: Surface) => {
+  const { ctx, width, height } = s;
+
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK;
+  ctx.fillRect(0, 0, width, height);
+
+  const x0 = 52, x1 = width - 16, y0 = 18, y1 = height - 32;
+
+  // exact angular sd of the edge beam, from the enumerated cloud
+  const pts = [16, 32, 64, 128, 256, 512].map(t => {
+    const c = cloudOf([1, 1], t, "wander");
+    let m = 0, v = 0;
+    for (const q of c) m += q.p * Math.atan2(q.y, q.x);
+    for (const q of c) v += q.p * Math.pow(Math.atan2(q.y, q.x) - m, 2);
+    return { t, deg: Math.sqrt(v) * 180 / Math.PI };
+  });
+
+  const LX = (t: number) => x0 + (Math.log(t) - Math.log(12)) / (Math.log(700) - Math.log(12)) * (x1 - x0);
+  const LY = (d: number) => y1 - (Math.log(d) - Math.log(0.7)) / (Math.log(14) - Math.log(0.7)) * (y1 - y0);
+
+  ctx.strokeStyle = GRID;
+  ctx.beginPath();
+  ctx.moveTo(x0, y0); ctx.lineTo(x0, y1); ctx.lineTo(x1, y1);
+  ctx.stroke();
+
+  ctx.strokeStyle = MODEL;
+  ctx.lineWidth = 1.6;
+  ctx.beginPath();
+  pts.forEach((p, i) => (i ? ctx.lineTo(LX(p.t), LY(p.deg)) : ctx.moveTo(LX(p.t), LY(p.deg))));
+  ctx.stroke();
+
+  ctx.fillStyle = MODEL;
+  for (const p of pts) {
+    ctx.beginPath();
+    ctx.arc(LX(p.t), LY(p.deg), 2.6, 0, Math.PI * 2);
+    ctx.fill();
+  }
+
+  // the face beams, which never wander at all
+  ctx.strokeStyle = GOOD;
+  ctx.setLineDash([4, 3]);
+  ctx.beginPath();
+  ctx.moveTo(x0, y1 - 2); ctx.lineTo(x1, y1 - 2);
+  ctx.stroke();
+  ctx.setLineDash([]);
+
+  ctx.fillStyle = FAINT;
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  ctx.textAlign = "left";
+  ctx.fillText("angular width (deg)", 6, 12);
+  ctx.fillText("ticks", x1 - 26, y1 + 14);
+  ctx.fillText("face beams — no constituents, so no wander, width exactly 0", x0 + 6, y1 - 6);
+
+  for (const p of pts) {
+    ctx.fillStyle = INK;
+    ctx.textAlign = "center";
+    ctx.fillText(p.deg.toFixed(2) + "°", LX(p.t), LY(p.deg) - 8);
+    ctx.fillStyle = FAINT;
+    ctx.fillText(String(p.t), LX(p.t), y1 + 14);
+  }
+
+  ctx.fillStyle = BAD;
+  ctx.textAlign = "right";
+  ctx.fillText("halves every 4× — the beams sharpen as 1/√t, they never fill the sphere", x1, y0 + 4);
+};
+
+// ---------------------------------------------------------------------------
+
+/** What each geometry puts through a shell, against what the closed form wants. */
+const coefficient = (s: Surface) => {
+  const { ctx, width, height } = s;
+
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK;
+  ctx.fillRect(0, 0, width, height);
+
+  // a unit-thickness shell holds 1/v charges per ray, v the Euclidean speed
+  const speed = (d: [number, number], mode: Mode) => {
+    const n = (d[0] ? 1 : 0) + (d[1] ? 1 : 0);
+    if (mode === "plain") return Math.hypot(...d);
+    if (mode === "normalised") return 1;
+    return (1 - wanderFor(n) * (n - 1) / n) * Math.sqrt(n);
+  };
+
+  const rows: [Mode, number][] = (["plain", "wander", "normalised"] as Mode[])
+    .map(m => [m, SHEET_2D.reduce((a, d) => a + 1 / speed(d, m), 0) / 8]);
+
+  ctx.font = "12px ui-sans-serif, system-ui, sans-serif";
+  ctx.textAlign = "left";
+  ctx.fillStyle = FAINT;
+  ctx.fillText("through a shell, ÷ the closed form's SHEET/4πr²", 14, 18);
+  ctx.fillText("and so G, which goes as the square", 300, 18);
+
+  rows.forEach(([mode, ratio], i) => {
+    const y = 44 + i * 26;
+    const ok = Math.abs(ratio - 1) < 1e-9;
+
+    ctx.fillStyle = INK;
+    ctx.textAlign = "left";
+    ctx.fillText(TITLE[mode], 14, y);
+
+    ctx.fillStyle = ok ? GOOD : BAD;
+    ctx.textAlign = "right";
+    ctx.fillText(ratio.toFixed(6), 290, y);
+    ctx.fillText((ratio * ratio).toFixed(6), 420, y);
+  });
+
+  ctx.fillStyle = FAINT;
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  ctx.textAlign = "left";
+  ctx.fillText(
+    "plain propagation is 27% light on G. Both fixes are exact — and the exponent is −2 in all three.",
+    14, height - 10,
+  );
+};
+
+// ---------------------------------------------------------------------------
+
+const Panel = ({ paint, height, note }: {
+  paint: (s: Surface) => void; height: number; note: string;
+}) =>
+  <div style={{ marginBottom: "1.1rem" }}>
+    <div style={{
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+      color: FAINT, marginBottom: 6,
+    }}>{note}</div>
+    <div style={{ height, background: BACK }}>
+      <CanvasView deps={[note]} paint={() => ({ frame: paint })} />
+    </div>
+  </div>;
+
+// ---------------------------------------------------------------------------
+// EVERY CLAIM IN `Law`, PUT THROUGH EACH GEOMETRY
+//
+// The reason this fits on two panels rather than needing the whole suite
+// re-run is structural, and worth stating once: `models.ts` carries every mass
+// as `M/GRAVITY`, so the dynamics compute `G·(M/G)` and the constant is gone
+// before it is used. Everything astronomical is then computed from a MEASURED
+// `GM`. So the geometry can only reach a prediction through `G` itself — and
+// only nine quantities carry `G` anywhere they can be seen.
+
+/** How much of the closed form's SHEET/4πr² each route actually delivers. */
+const FSPEED = (w: number, cls: "face" | "edge" | "corner") =>
+  cls === "face" ? 1
+    : cls === "edge" ? Math.SQRT2 * (1 - w / 3)
+      : Math.sqrt(3) * (1 - w / 2);
+
+/**
+ * The shell density each route delivers, as a fraction of the closed form's
+ * SHEET/4πr².
+ *
+ * The emission sheet is a COORDINATE PLANE, so it holds four face-type and
+ * four edge-type directions and no corner-type ones at all — a corner does not
+ * lie in a coordinate plane. Which is why forward-only wander needs only ONE w
+ * to land exactly: 3(1 − 1/√2) zeroes the face and the edge together, and the
+ * corner's own value never enters the emission.
+ */
+const kForward = (w: number) =>
+  (4 / FSPEED(w, "face") + 4 / FSPEED(w, "edge")) / 8;
+
+export const ROUTES: [string, number][] = [
+  ["as published", 1],
+  ["square, Euclid", (4 + 4 / Math.SQRT2) / 8],
+  ["forward, w = 1", kForward(1)],
+  ["forward, w = 0.8787", kForward(3 * (1 - Math.SQRT1_2))],
+];
+
+const SH = 8, DG = 26, BT = 1, CO = 0.5, SHARE = 0.5, CY = 8;
+const BASE = BT * SHARE * SH * SH / (4 * Math.PI * Math.PI * CO * DG);
+const M_PLANCK = 2.176434e-8;
+
+const derived = (k: number) => {
+  const G = BASE * k * k, eps = 12 * Math.PI * G / SH;
+  const hop = (SH / (12 * Math.PI * 0.34615)) / G;
+  return {
+    G, mu: G * M_PLANCK * 1e9, eps, D: 1 / eps,
+    reaches: 0.361 * k, magneton: CY * G / (2 * Math.PI),
+    hop, persist: (hop - 1) / (hop + 1), a0gap: SH / (8 * Math.PI * Math.PI * G),
+  };
+};
+
+const MOVERS: [string, (d: ReturnType<typeof derived>) => string][] = [
+  ["G — the constant", d => d.G.toFixed(6)],
+  ["µ — heaviest emitter (µg)", d => d.mu.toFixed(3)],
+  ["the Compton constant", d => d.G.toFixed(6)],
+  ["ε — space made per charge", d => d.eps.toFixed(4)],
+  ["D — how it spreads", d => d.D.toFixed(3)],
+  ["REACHES — λ/R_h", d => d.reaches.toFixed(4)],
+  ["MAGNETON (µ_B)", d => d.magneton.toFixed(5)],
+  ["the hopping gap", d => d.hop.toFixed(2) + "×"],
+  ["persistence p owed", d => d.persist.toFixed(4)],
+  ["the two a₀ routes differ by", d => d.a0gap.toFixed(4)],
+];
+
+const movers = (s: Surface) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+  const x0 = 14, colw = Math.min(112, (width - 210) / 4), y0 = 30;
+  ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+
+  ROUTES.forEach(([name], i) => {
+    ctx.fillStyle = i === 3 ? GOOD : i === 0 ? INK : FAINT;
+    ctx.textAlign = "right";
+    ctx.fillText(name, 200 + colw * (i + 1) - 6, y0 - 12);
+  });
+  ctx.fillStyle = FAINT; ctx.textAlign = "left";
+  ctx.fillText("carries G, so the geometry reaches it", x0, y0 - 12);
+
+  MOVERS.forEach(([label, f], r) => {
+    const y = y0 + 8 + r * 17;
+    ctx.fillStyle = INK; ctx.textAlign = "left";
+    ctx.fillText(label, x0, y);
+    ROUTES.forEach(([, k], i) => {
+      const v = f(derived(k)), same = v === f(derived(1));
+      ctx.fillStyle = same ? GOOD : BAD;
+      ctx.textAlign = "right";
+      ctx.fillText(v, 200 + colw * (i + 1) - 6, y);
+    });
+  });
+
+  ctx.fillStyle = FAINT;
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  ctx.fillText(
+    "13/8 = DEG/2SHEET is a clean count of the lattice ONLY at k = 1 — it is (13/8)/k² and nothing else recovers it",
+    x0, height - 10);
+};
+
+// ---------------------------------------------------------------------------
+
+const KEPT: [string, string[]][] = [
+  ["the pull, and relativity", [
+    "the inverse square, exponent −2", "the equivalence principle",
+    "BIAS = 1/26", "met's bracket 1 + (½/R)ln", "1/γ³ and 1/γ",
+    "Mercury's sixth, +1.66°/9.93°", "A = e^−2u, B = e^+2u, β = γ = 1",
+    "six sixths, 6.05 … 6.22", "light's deflection 4GM/bc²",
+    "the geodesic, to 10⁻⁷", "Shapiro delay, Cassini γ", "screen",
+  ]],
+  ["the cosmology", [
+    "dR/dt = c, R = ct", "ADVANCE = SHEET/2 = 4", "H₀ = 1/t₀, the forced age",
+    "q₀ = 0 exactly", "the supernova residual, 0.061 mag", "no CMB, at any temperature",
+  ]],
+  ["the rotation curves — ONLY the shapes", [
+    "the MOND interpolation, derived", "transport slopes −2 / −1, and √M",
+    "Tully–Fisher's SLOPE, 3.42", "the four cosines 0.4721 … 0.3610",
+    "that there IS a step, and its ¼-power size",
+  ]],
+  ["black holes", [
+    "the throat, e/2 = 1.3591 R_s", "r_ph = 2GM/c²",
+    "the shadow, 2e/3√3 = 1.0463", "no horizons, redshift e² = 7.4",
+    "and no echoes",
+  ]],
+  ["magnetism, and the quantum coda", [
+    "P quantised in quarters", "the sign law (1 − P_a P_b)",
+    "∇·B = 0, no monopoles", "3cos²θ − 1, 1/R⁴, five orientations",
+    "cutting a magnet halves it", "1/m², so µ_B/µ_N = 1836",
+    "g = 1 — still refuted", "⟨111⟩ by 11.1% — still refuted",
+    "m_eff = 38.7 kg per A·m", "α/(m_e/m_P)² = 4.166·10⁴²",
+    "E = ħω, λ = h/p, Ω² = k² + m²",
+  ]],
+];
+
+const kept = (s: Surface) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+  const cols = width > 720 ? 3 : width > 480 ? 2 : 1;
+  const cw = (width - 20) / cols;
+  let col = 0, y = 26;
+
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  ctx.textAlign = "left";
+  ctx.fillStyle = SEEN;
+  ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+  ctx.fillText("identical in every route — pure counts, or computed from a measured GM", 12, 14);
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+
+  for (const [group, items] of KEPT) {
+    if (y + (items.length + 2) * 13 > height - 26 && col < cols - 1) { col++; y = 26; }
+    ctx.fillStyle = FAINT;
+    ctx.fillText(group.toUpperCase(), 12 + col * cw, y);
+    y += 14;
+    for (const it of items) {
+      ctx.fillStyle = GOOD; ctx.fillText("✓", 12 + col * cw, y);
+      ctx.fillStyle = INK; ctx.fillText(it, 24 + col * cw, y);
+      y += 13;
+    }
+    y += 8;
+  }
+
+  ctx.fillStyle = BAD;
+  ctx.fillText("needs re-running, not settled by scaling:  R/R_s = 0.7219 · the neutron star's ⅔ · every Euclidean angle, under L∞ only",
+    12, height - 8);
+};
+
+// ---------------------------------------------------------------------------
+// AND THE ROTATION CURVES ARE NOT INVARIANT, WHICH THE FIRST PASS GOT WRONG.
+//
+// `a₀` has TWO derivations in this file and only one of them is free of `G`:
+//
+//     cH₀/2π                 no G      — invariant under any geometry
+//     4πG/(SHEET·t₀)         a₀ ∝ G    — moves as k²
+//
+// and the file's own audit says the SECOND is the principled one: the 2π in
+// the first was borrowed from `inStep`, a coherence condition the polarity
+// result retired. So the route that survives the audit is exactly the route
+// that makes every rotation-curve number depend on the shape of the front.
+//
+// Downstream of a₀: v_flat ∝ a₀^¼ (from v⁴ = GMa₀), the step radii ∝ 1/√a₀
+// (since g ∝ 1/r²), and the cluster supply ∝ √a₀ (the √(a₀/g_N) ceiling).
+
+const A0ROWS: [string, (f: number) => string][] = [
+  ["a₀ itself, ×", f => f.toFixed(4)],
+  ["v_flat, × — so the 1.1% rms", f => Math.pow(f, 0.25).toFixed(4)],
+  ["the step, 33 / 52 kpc →", f => (33 / Math.sqrt(f)).toFixed(1) + " / " + (52 / Math.sqrt(f)).toFixed(1)],
+  ["clusters supply 3.94 →", f => (3.94 * Math.sqrt(f)).toFixed(2)],
+  ["…so short by", f => (6.0 / (3.94 * Math.sqrt(f))).toFixed(2) + "×"],
+];
+
+const viaA0 = (s: Surface) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+  const x0 = 14, colw = Math.min(112, (width - 210) / 4), y0 = 44;
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  ctx.textAlign = "left";
+  ctx.fillStyle = DATA;
+  ctx.fillText("a₀ = cH₀/2π has no G and is invariant. a₀ = 4πG/(SHEET·t₀) is ∝ G — and the audit calls that one the principled route.", x0, 14);
+  ctx.fillStyle = FAINT;
+  ctx.fillText("on that route the whole rotation-curve block moves:", x0, 28);
+
+  ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+  ROUTES.forEach(([name], i) => {
+    ctx.fillStyle = i === 3 ? GOOD : i === 0 ? INK : FAINT;
+    ctx.textAlign = "right";
+    ctx.fillText(name, 200 + colw * (i + 1) - 6, y0 - 4);
+  });
+
+  A0ROWS.forEach(([label, f], r) => {
+    const y = y0 + 16 + r * 17;
+    ctx.fillStyle = INK; ctx.textAlign = "left";
+    ctx.fillText(label, x0, y);
+    ROUTES.forEach(([, k], i) => {
+      const v = f(k * k), same = v === f(1);
+      ctx.fillStyle = same ? GOOD : BAD;
+      ctx.textAlign = "right";
+      ctx.fillText(v, 200 + colw * (i + 1) - 6, y);
+    });
+  });
+
+  ctx.fillStyle = BAD;
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  ctx.fillText("square-Euclid costs 7.6% on v_flat against a fit quoted at 1.1% rms — the Milky Way result does not survive it.", x0, height - 10);
+};
+
+export const WanderA0 = ({ height = 175 }: { height?: number }) =>
+  <Panel paint={viaA0} height={height}
+    note="and everything downstream of a₀ — which is not invariant" />;
+
+export const WanderMovers = ({ height = 235 }: { height?: number }) =>
+  <Panel paint={movers} height={height}
+    note="everything the geometry can reach — and it is ten things" />;
+
+export const WanderKept = ({ height = 330 }: { height?: number }) =>
+  <Panel paint={kept} height={height}
+    note="and everything it cannot" />;
+
+// ---------------------------------------------------------------------------
+// EVERY PATH A RAY COULD TAKE, AS A FIELD — because "it propagates in a circle"
+// is an ASSUMPTION and this is what the lattice actually offers instead.
+//
+// The four maps are four answers to one question — what is a heading? — and
+// each makes a different aggregate shape. None of them is a circle for free:
+//
+//   one heading, held        8 rays. The aggregate is a SQUARE, and the only
+//                            thing there is to see is veins.
+//   the sheet, symmetric     the current `wander`. Diagonals broaden, the axes
+//     wander                 cannot (a face step has no constituents), so the
+//                            veins fatten unevenly and the count stays 8.
+//   free headings            a heading is any unit vector, realised by mixing.
+//                            The ring closes — and is SHARP on the axes and
+//                            BLURRED on the diagonals, because the radial
+//                            spread is √((1 − Σuᵢ⁴)t) and Σuᵢ⁴ is 1 on an axis.
+//   a surface of emitters    many emitters, one heading each. The veins widen
+//                            by the body's own size rather than by any rule —
+//                            which is the other way to fill a shell, and it
+//                            works out to about 2.5 body radii and no further.
+//
+// The alpha is the probability, gamma-corrected, so the thin parts are visible
+// rather than clipped to black. Everything is enumerated, not sampled: with
+// free headings x and y are INDEPENDENT binomials, so the field is exact.
+
+const BIN = (t: number, p: number) => {
+  const o = new Float64Array(t + 1), lp = Math.log(Math.max(p, 1e-300)),
+    lq = Math.log(Math.max(1 - p, 1e-300));
+  for (let k = 0; k <= t; k++)
+    o[k] = Math.exp(lfac(t) - lfac(k) - lfac(t - k) + k * lp + (t - k) * lq);
+  return o;
+};
+
+type Field = { g: Float64Array; n: number; t: number };
+
+const blank = (t: number): Field =>
+  ({ g: new Float64Array((2 * t + 1) * (2 * t + 1)), n: 2 * t + 1, t });
+
+const put = (f: Field, x: number, y: number, p: number) => {
+  const i = Math.round(x) + f.t, j = Math.round(y) + f.t;
+  if (i >= 0 && j >= 0 && i < f.n && j < f.n) f.g[i * f.n + j] += p;
+};
+
+const FIELDS: [string, string, (t: number) => Field][] = [
+  ["one heading, held", "8 rays — the aggregate is a square", t => {
+    const f = blank(t);
+    for (const d of SHEET_2D) put(f, d[0] * t, d[1] * t, 1 / 8);
+    return f;
+  }],
+  ["the sheet, symmetric wander", "diagonals broaden, axes cannot", t => {
+    const f = blank(t);
+    for (const d of SHEET_2D) for (const q of cloudOf(d, t, "wander")) put(f, q.x, q.y, q.p / 8);
+    return f;
+  }],
+  ["free headings", "the ring closes — sharp on the axes", t => {
+    const f = blank(t), N = 360;
+    for (let a = 0; a < N; a++) {
+      const th = 2 * Math.PI * a / N;
+      const X = BIN(t, (1 + Math.cos(th)) / 2), Y = BIN(t, (1 + Math.sin(th)) / 2);
+      for (let i = 0; i <= t; i++) {
+        if (X[i] < 1e-11) continue;
+        for (let j = 0; j <= t; j++) {
+          if (Y[j] < 1e-11) continue;
+          put(f, 2 * i - t, 2 * j - t, X[i] * Y[j] / N);
+        }
+      }
+    }
+    return f;
+  }],
+  ["a surface of emitters", "veins widen by the body, not by a rule", t => {
+    const f = blank(t), R = Math.max(2, Math.round(t / 4));
+    let n = 0;
+    for (let x = -R; x <= R; x++) for (let y = -R; y <= R; y++) {
+      if (x * x + y * y > R * R) continue;
+      n++;
+      for (const d of SHEET_2D) put(f, x + d[0] * (t - R), y + d[1] * (t - R), 1);
+    }
+    for (let i = 0; i < f.g.length; i++) f.g[i] /= n * 8;
+    return f;
+  }],
+];
+
+const paths = (t: number) => (s: Surface) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+  const cw = width / 4, R = Math.min(cw / 2 - 10, (height - 56) / 2);
+  const scale = R / (t * Math.SQRT2);
+
+  FIELDS.forEach(([title, blurb, make], col) => {
+    const f = make(t), cx = cw * (col + 0.5), cy = 26 + R;
+    let peak = 0;
+    for (const v of f.g) peak = Math.max(peak, v);
+
+    const px = Math.max(1, scale * 2);
+    for (let i = 0; i < f.n; i++) for (let j = 0; j < f.n; j++) {
+      const v = f.g[i * f.n + j];
+      if (v <= 0) continue;
+      ctx.globalAlpha = Math.min(1, Math.pow(v / peak, 0.30));
+      ctx.fillStyle = MODEL;
+      ctx.fillRect(cx + (i - f.t) * scale - px / 2, cy - (j - f.t) * scale - px / 2, px, px);
+    }
+
+    ctx.globalAlpha = 0.45;
+    ctx.strokeStyle = DATA; ctx.setLineDash([3, 3]);
+    ctx.beginPath(); ctx.arc(cx, cy, t * scale, 0, Math.PI * 2); ctx.stroke();
+    ctx.setLineDash([]); ctx.globalAlpha = 1;
+
+    ctx.fillStyle = INK; ctx.textAlign = "center";
+    ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText(title, cx, 14);
+    ctx.fillStyle = FAINT;
+    ctx.font = "9px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText(blurb, cx, height - 18);
+  });
+
+  ctx.fillStyle = FAINT; ctx.textAlign = "left";
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  ctx.fillText(
+    "alpha is the probability of a path ending there, gamma 0.30 so the thin parts show. dashed: the circle of radius t.",
+    10, height - 5);
+};
+
+export const WanderPaths = ({ ticks = 26, height = 250 }: { ticks?: number, height?: number }) =>
+  <Panel paint={paths(ticks)} height={height}
+    note="every path a ray could take — and the aggregate shape each rule makes" />;
+
+// ---------------------------------------------------------------------------
+// AND THE WANDER THAT DOES NOT DISCRIMINATE — which is the honest version of
+// "a world where the discreteness of the spread matters", and it fails.
+//
+// The wander above is picky: it mixes a heading with ITS OWN constituents, so a
+// face step (having none) never wanders and a corner step wanders most. That
+// pickiness is doing the work. Take it away — with probability w take a
+// UNIFORMLY RANDOM lattice step, otherwise your heading, caring neither what
+// your heading is nor which way you wander — and:
+//
+//     mean step = (1 − w)·d + w·⟨random⟩ = (1 − w)·d
+//
+// because the 26 come in ± pairs and average to nothing. So every speed is
+// scaled by the same (1 − w) and THE RATIO IS UNTOUCHED: face (1−w), diagonal
+// (1−w)√2, corner (1−w)√3, at every w. The square is still a square.
+//
+// What w buys is blur, and blur only HIDES the square, and only near in: the
+// corner excess grows as 0.414(1−w)t while the blur grows as √(var·t), so their
+// ratio goes to nought and the square comes back at every w < 1 — at t ≈ 29
+// ticks for w = 0.5, 222 for w = 0.8, 3547 for w = 0.95. At w = 1 it is gone,
+// and so is propagation: the mean speed is nought and nothing goes anywhere.
+
+const UNIFORM: [string, number][] = [["w = 0", 0], ["w = 0.5", 0.5], ["w = 0.8", 0.8], ["w = 0.95", 0.95]];
+
+const blind = (t: number) => (s: Surface) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+  const cw = width / 4, R = Math.min(cw / 2 - 10, (height - 58) / 2);
+  const scale = R / (t * Math.SQRT2);
+  const N = 2600;
+
+  UNIFORM.forEach(([label, w], col) => {
+    const cx = cw * (col + 0.5), cy = 26 + R;
+
+    // the square the means still make
+    ctx.globalAlpha = 0.5; ctx.strokeStyle = GRID;
+    const m = (1 - w) * t * scale;
+    ctx.strokeRect(cx - m, cy - m, 2 * m, 2 * m);
+    ctx.strokeStyle = DATA; ctx.setLineDash([3, 3]);
+    ctx.beginPath(); ctx.arc(cx, cy, m, 0, Math.PI * 2); ctx.stroke();
+    ctx.setLineDash([]); ctx.globalAlpha = 1;
+
+    for (const d of SHEET_2D)
+      for (let n = 0; n < N; n++) {
+        let x = 0, y = 0;
+        for (let k = 0; k < t; k++) {
+          const st = Math.random() < w ? SHEET_2D[(Math.random() * 8) | 0] : d;
+          x += st[0]; y += st[1];
+        }
+        ctx.globalAlpha = 0.05;
+        ctx.fillStyle = MODEL;
+        ctx.fillRect(cx + x * scale, cy - y * scale, 1.6, 1.6);
+      }
+    ctx.globalAlpha = 1;
+
+    ctx.fillStyle = INK; ctx.textAlign = "center";
+    ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText(label, cx, 14);
+    ctx.fillStyle = FAINT; ctx.font = "9px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText("diag/face = " + Math.SQRT2.toFixed(4), cx, height - 18);
+  });
+
+  ctx.fillStyle = BAD; ctx.textAlign = "left";
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  ctx.fillText(
+    "a wander that does not discriminate scales every speed by the same (1 − w) — so the ratio never moves, and the square only gets blurrier and smaller.",
+    10, height - 5);
+};
+
+export const WanderBlind = ({ ticks = 26, height = 250 }: { ticks?: number, height?: number }) =>
+  <Panel paint={blind(ticks)} height={height}
+    note="and the same, with a wander that does not discriminate" />;
+
+// ---------------------------------------------------------------------------
+// FORWARD-ONLY WANDER — you may not switch to just any direction, only to one
+// you are already going in. Which is the best-behaved rule of the three.
+//
+// The candidate set is every lattice direction with a POSITIVE projection on
+// the heading. Its size is 9 for a face or an edge and 10 for a corner — which
+// are exactly the counts `magnet.ts` already uses for the ⟨111⟩ easy axis, and
+// arrived at here from somewhere else entirely.
+//
+// The cone's mean step has a closed form, and it is what does the work:
+//
+//     face    cone mean = 1          so the speed is 1 at EVERY w
+//     edge    cone mean = 2√2/3      speed = √2 (1 − w/3)
+//     corner  cone mean = √3/2       speed = √3 (1 − w/2)
+//
+// So wandering forward SHORTENS the diagonals in Euclidean terms and leaves the
+// axes alone — the correction wanted, with nothing singled out by hand. One w
+// gets the spread to 1.57% (against 3.5% for the constituent rule); two —
+// w = 3(1−1/√2) for an edge, 2(1−1/√3) for a corner — zero it exactly.
+
+const FWD: [string, (w: number) => number, string][] = [
+  ["corner  √3(1−w/2)", w => Math.sqrt(3) * (1 - w / 2), MODEL],
+  ["edge  √2(1−w/3)", w => Math.SQRT2 * (1 - w / 3), SEEN],
+  ["face  1", () => 1, GOOD],
+];
+
+const forward = (s: Surface) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+  const x0 = 46, x1 = width - 132, y0 = 26, y1 = height - 42;
+  const X = (w: number) => x0 + w * (x1 - x0);
+  const Y = (v: number) => y1 - (v - 0.8) / (1.8 - 0.8) * (y1 - y0);
+
+  ctx.strokeStyle = GRID;
+  ctx.beginPath(); ctx.moveTo(x0, y0); ctx.lineTo(x0, y1); ctx.lineTo(x1, y1); ctx.stroke();
+
+  ctx.strokeStyle = DATA; ctx.setLineDash([4, 3]);
+  ctx.beginPath(); ctx.moveTo(x0, Y(1)); ctx.lineTo(x1, Y(1)); ctx.stroke();
+  ctx.setLineDash([]);
+
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  for (const [label, f, col] of FWD) {
+    ctx.strokeStyle = col; ctx.lineWidth = 1.6;
+    ctx.beginPath();
+    for (let i = 0; i <= 100; i++) {
+      const w = i / 100;
+      i ? ctx.lineTo(X(w), Y(f(w))) : ctx.moveTo(X(w), Y(f(w)));
+    }
+    ctx.stroke();
+    ctx.fillStyle = col; ctx.textAlign = "left";
+    ctx.fillText(label, x1 + 6, Y(f(1)) + 3);
+  }
+
+  for (const [w, nm] of [[3 * (1 - Math.SQRT1_2), "edge = 1"],
+                         [2 * (1 - 1 / Math.sqrt(3)), "corner = 1"]] as [number, string][]) {
+    ctx.strokeStyle = FAINT; ctx.setLineDash([2, 3]);
+    ctx.beginPath(); ctx.moveTo(X(w), Y(1)); ctx.lineTo(X(w), y1); ctx.stroke();
+    ctx.setLineDash([]);
+    ctx.fillStyle = FAINT; ctx.textAlign = "center";
+    ctx.font = "9px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText(w.toFixed(4), X(w), y1 + 12);
+    ctx.fillText(nm, X(w), y1 + 23);
+    ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  }
+
+  ctx.fillStyle = FAINT; ctx.textAlign = "left";
+  ctx.fillText("mean Euclidean speed", 6, 14);
+  ctx.fillText("w — how often you deviate, forward only", x0, height - 6);
+  ctx.fillStyle = GOOD; ctx.textAlign = "right";
+  ctx.fillText("best single w = 0.8453 → 1.57% spread", x1, y0 + 4);
+};
+
+export const WanderForward = ({ height = 235 }: { height?: number }) =>
+  <Panel paint={forward} height={height}
+    note="forward-only: you may deviate, but only into a direction you are already going" />;
+
+// ---------------------------------------------------------------------------
+// THE PATH DISTRIBUTION ITSELF, SWEPT THROUGH w — the veins, exactly.
+//
+// Under forward-only wander a heading's candidates are the lattice directions
+// with a positive projection on it, which in the plane is always THREE. So a
+// walk of t ticks is a TRINOMIAL over (how many of each), and the field can be
+// enumerated rather than sampled — every path, with its exact weight.
+//
+// What the veins are: a face heading's cone is {(1,0), (1,1), (1,−1)}, and
+// every one of those has x = 1. So after t ticks x = t EXACTLY, whatever the
+// path — the face front is a flat bar at x = t that spreads only sideways.
+// A diagonal's cone is {(1,0), (1,1), (0,1)}, which does not fix anything, so
+// it spreads into a wedge. Bars where the axes are, wedges between them: that
+// is the vein structure, and it is a fact about which directions share a
+// component rather than about any parameter.
+
+const CONE2 = (h: [number, number]) =>
+  SHEET_2D.filter(d => d[0] * h[0] + d[1] * h[1] > 1e-9);
+
+/**
+ * STEADY-STATE OCCUPANCY — where the charges ARE, not where one pulse got to.
+ *
+ * The panel above this one draws a single pulse at age `t`, which is a shell
+ * and therefore a ring with nothing inside it. That is not what a source looks
+ * like. A source pulses every tick, so at any moment there are charges of every
+ * age in flight at once, and what fills the picture is the SUM over ages —
+ * which is the quantity `chance(m,r)` is about.
+ *
+ * Each cell is then drawn against the MEAN AT ITS OWN RADIUS, so the 1/r
+ * falloff divides out and what is left is purely angular: where, at a given
+ * distance, the field is thick and where it is thin. That is the vein.
+ */
+const veinField = (t: number, w: number) => {
+  const raw = new Map<string, number>();
+
+  for (const h of SHEET_2D) {
+    const C = CONE2(h), m = C.length;
+    const rest = C.filter(c => c !== h);
+    const ps = [(1 - w) + w / m, w / m, w / m];
+    const st = [h, ...rest];
+
+    for (let age = 1; age <= t; age++)
+      for (let a = 0; a <= age; a++)
+        for (let b = 0; b <= age - a; b++) {
+          const c = age - a - b;
+          const lp = lfac(age) - lfac(a) - lfac(b) - lfac(c)
+            + a * Math.log(Math.max(ps[0], 1e-300))
+            + b * Math.log(Math.max(ps[1], 1e-300))
+            + c * Math.log(Math.max(ps[2], 1e-300));
+          const p = Math.exp(lp);
+          if (p < 1e-10) continue;
+
+          const x = a * st[0][0] + b * st[1][0] + c * st[2][0];
+          const y = a * st[0][1] + b * st[1][1] + c * st[2][1];
+          const k = x + "," + y;
+          raw.set(k, (raw.get(k) ?? 0) + p / 8);
+        }
+  }
+
+  // divide out the radial falloff: each cell against the mean at its radius
+  const sum = new Map<number, number>(), count = new Map<number, number>();
+  for (const [k, v] of raw) {
+    const [x, y] = k.split(",").map(Number);
+    const r = Math.round(Math.hypot(x, y));
+    sum.set(r, (sum.get(r) ?? 0) + v);
+    count.set(r, (count.get(r) ?? 0) + 1);
+  }
+
+  const out = new Map<string, number>();
+  for (const [k, v] of raw) {
+    const [x, y] = k.split(",").map(Number);
+    const r = Math.round(Math.hypot(x, y));
+    out.set(k, v / ((sum.get(r) as number) / (count.get(r) as number)));
+  }
+  return out;
+};
+
+const EXACT_W = 3 * (1 - Math.SQRT1_2);
+
+const veins = (t: number) => (s: Surface) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+  const ws = [0, 0.3, 0.6, EXACT_W, 1];
+  const cw = width / ws.length, R = Math.min(cw / 2 - 8, (height - 56) / 2);
+  const scale = R / t;
+
+  ws.forEach((w, col) => {
+    const F = veinField(t, w), cx = cw * (col + 0.5), cy = 26 + R;
+    let peak = 0;
+    for (const v of F.values()) peak = Math.max(peak, v);
+
+    const px = Math.max(1.4, scale * 1.15);
+    for (const [k, v] of F) {
+      const [x, y] = k.split(",").map(Number);
+      if (Math.hypot(x, y) > t) continue;
+      ctx.globalAlpha = Math.min(1, Math.pow(Math.min(v / peak, 1), 0.55));
+      ctx.fillStyle = MODEL;
+      ctx.fillRect(cx + x * scale - px / 2, cy - y * scale - px / 2, px, px);
+    }
+
+    ctx.globalAlpha = 0.35;
+    ctx.strokeStyle = DATA; ctx.setLineDash([3, 3]);
+    ctx.beginPath(); ctx.arc(cx, cy, t * scale, 0, Math.PI * 2); ctx.stroke();
+    ctx.setLineDash([]); ctx.globalAlpha = 1;
+
+    const diag = (1 - w) * Math.SQRT2 + w * 2 * Math.SQRT2 / 3;
+    ctx.fillStyle = INK; ctx.textAlign = "center";
+    ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText("w = " + (w === EXACT_W ? w.toFixed(4) : w.toFixed(2)), cx, 14);
+  });
+
+  ctx.fillStyle = FAINT;
+};
+
+export const WanderVeins = ({ ticks = 22, height = 150 }: { ticks?: number, height?: number }) =>
+  <Panel paint={veins(ticks)} height={height}
+    note="" />;
+
+export const WanderPattern = ({ ticks = 28, height = 260 }: { ticks?: number, height?: number }) =>
+  <Panel paint={pattern(ticks)} height={height}
+    note="where one pulse ends up — the same rules, three ways of stepping" />;
+
+export const WanderSpread = ({ height = 210 }: { height?: number }) =>
+  <Panel paint={collimation} height={height}
+    note="and the beams collimate rather than spread" />;
+
+export const WanderShell = ({ height = 150 }: { height?: number }) =>
+  <Panel paint={coefficient} height={height}
+    note="what each geometry puts through a shell" />;
+
+export const Wander = ({ ticks = 28 }: { ticks?: number } = {}) => <>
+  <WanderPattern ticks={ticks} />
+  <WanderSpread />
+  <WanderShell />
+  <WanderMovers />
+  <WanderA0 />
+  <WanderKept />
+</>;

From 68ecc01deb1192608266f14b6786d70b94f255d6 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Fri, 14 Aug 2026 16:05:49 +0200
Subject: [PATCH 39/47] Thinking about discrete model: movement

---
 orbitmines.com/src/routes/Physics.tsx         |  46 +-
 .../2026.RayCalculiAndPhysics/rotation.tsx    |  45 +-
 .../2026.RayCalculiAndPhysics/tests/README.md |  13 +
 .../2026.RayCalculiAndPhysics/tests/cones.ts  | 301 +++++++++
 .../2026.RayCalculiAndPhysics/tests/gas.ts    | 376 +++++++++++
 .../tests/lattices.ts                         | 449 +++++++++++++
 .../2026.RayCalculiAndPhysics/tests/run.sh    |   1 +
 .../2026.RayCalculiAndPhysics/tests/veined.ts | 325 +++++++++
 .../2026.RayCalculiAndPhysics/tests/veins.ts  | 624 ++++++++++++++++++
 .../2026.RayCalculiAndPhysics/tests/wave.ts   | 241 +++++++
 .../2026.RayCalculiAndPhysics/tests/ways.ts   | 209 ++++++
 .../2026.RayCalculiAndPhysics/wander.tsx      | 390 +++++++++--
 12 files changed, 2941 insertions(+), 79 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/cones.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/gas.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/lattices.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/veined.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/veins.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/wave.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ways.ts

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index a1d5926..9f74ada 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -18,7 +18,7 @@ import {
 } from "./archive/2026.RayCalculiAndPhysics/law";
 import { gravitational, massUnit } from "./archive/2026.RayCalculiAndPhysics/gravity";
 import { lineGroups } from "./archive/2026.RayCalculiAndPhysics/lines";
-import { Wander, WanderBlind, WanderForward, WanderPaths, WanderVeins } from "./archive/2026.RayCalculiAndPhysics/wander";
+import { Wander, WanderBlind, WanderForward, WanderMedium, WanderPaths, WanderVeins } from "./archive/2026.RayCalculiAndPhysics/wander";
 import { Model } from "./archive/2026.RayCalculiAndPhysics/model";
 import { asGroup, MODELS, weighed } from "./archive/2026.RayCalculiAndPhysics/models";
 import { PACE, Polarity } from "./archive/2026.RayCalculiAndPhysics/physics";
@@ -181,7 +181,7 @@ const Physics = () => {
       Let's get started with gravity.
 
       <Section head="Gravity">
-        Gravity comes down to two essential rules:
+        Gravity in this model comes down to two essential rules:
         <BR/>
         (G/1) Annihilation: When two rays meet, they annihilate, leaving a single neutral spatial point behind.
 
@@ -221,14 +221,16 @@ const Physics = () => {
 
         <BR/>
 
-        So since speed of light is 'c' in physics, we'll need some way to reference any kind of physics concept in its discrete form. Let's mark them by just putting a line on top of any variable when we want to reference its discrete form. (This will likely create some ambiguities - but at least in the context of this project that will be the case.)
+        <Para>
+          So since speed of light is '<K>c</K>' in physics, we'll need some way to reference any kind of physics concept in its discrete form. Let's mark them by just putting a line on top of any variable when we want to reference its discrete form. (This will likely create some ambiguities - but at least in the context of this project that will be the case.)
+        </Para>
 
         <Eq>
           <K><Bar>c</Bar></K> = <Frac over={<><K><Bar>STEP</Bar></K> = 1</>} under={<><K><Bar>TICK</Bar></K> = 1</>} /> =
           1 <F>(<Bar>x</Bar>/<Bar>t</Bar>)</F>
         </Eq>
 
-        <span style={{textAlign: 'left', width: '100%'}}>These variables couldn't really be anything other than this, but this elementary thing is pretty important. Speed of light is just phrased as a single lattice step per tick. These don't need any units since we're not comparing them to anything else, but if one really wanted, you could use the <Bar>x</Bar>/<Bar>t</Bar>. <Bar>x</Bar> meaning distance. <Bar>t</Bar> meaning a light tick.</span>
+        <span style={{textAlign: 'left', width: '100%'}}>These variables couldn't really be anything other than this, but this elementary thing is pretty important. Speed of light is just phrased as a single lattice step per tick. These don't need any units since we're not comparing them to anything else, but if one really wanted, you could use the <Bar>x</Bar>/<Bar>t</Bar>. <Bar>x</Bar> meaning distance. <Bar>t</Bar> meaning a light tick. <span className="bp5-text-muted">(Notice there's something close to analogous here to <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "Planck units", link: "https://en.wikipedia.org/wiki/Planck_units"}}/>, but here we make no assumption from the size of lattice to the metric system. Just discrete units which we would be able to use outside of a physics model.)</span></span>
 
         <BR/>
 
@@ -242,6 +244,30 @@ const Physics = () => {
 
         <span style={{textAlign: 'left', width: '100%'}}>You're allowed to change the <K><Bar>D</Bar></K> ofc. But unless otherwise specified variables have these default values.</span>
 
+        <Head>Movement</Head>
+
+        There's a real assumption to made here at the beginning. Which is how does one from a perspective of discreteness, recover rays propagating in a circle. That's making the assumption you'd want it to propegate in a circle in the first place - whether that's the actual accurate model. Also to consider would be that a large surface of stuff sending out rays could more accurately describe a circle, than say a single point with a local neighbourhood. This is essentially a statement of discrete movement, how should that happen? Where as the aggregate we might see a sphere, a cube, a (curved) diamond-shape. All are these are technically possibilities. We could imagine a world where discretized effects matter here for the spread of those rays.
+
+        <BR/>
+
+        <Para>Let's for a moment assume we wouldn't be able to completely reproduce a circle from a single point with a discrete number of points around it. What would that look like? </Para> 
+
+        <BR/>
+
+        One thing is very clear, we at least need some concept of something analogous to a diagonal. If we just had a perfect lattice as our space. No diagonal would actually cost less movement than just crossing the sides of the triangle.
+
+        <BR/>  
+          
+        One view would be: There's a propegation direction, but the ray sometimes wanders from diagonal to non-diagonal and back to a diagonal: attempting some forward-preference. This 'wandering' would result in cones in each direction, with relative deadzones on the boundaries of them.
+
+        <WanderVeins aspect={3}/>
+
+        But this would have to be some measurable effect, and at least for our solar system, where we can test with a much higher degree of accuracy, this perspective wouldn't sit well unless we choose a particular method for this wandering which would recreate a circle, and we'd have to explain why that number.
+
+        <BR/>
+
+        This was the original idea on which I built the continuous model (Kind of assuming I'd be able to create a circle), but I've since realized a better second option:
+
         <BR/>
 
         Then a related number to dimension, all possible paths out of a point (the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "degree", link: "https://en.wikipedia.org/wiki/Degree_(graph_theory)"}}/> assuming diagonals are included). 
@@ -264,18 +290,6 @@ const Physics = () => {
 
         <BR/>
 
-        <Head>Movement</Head>
-
-        There's a real assumption to made here at the beginning. Which is how does one from a perspective of discreteness, recover rays propagating in a circle. That's making the assumption you'd want it to propegate in a circle in the first place - whether that's the actual accurate model. Also to consider would be that a large surface of stuff sending out rays could more accurately describe a circle, than say a single point with a local neighbourhood. This is essentially a statement of discrete movement, how should that happen? Where on the aggregate we might see a sphere, a cube, a (curved) diamond-shape. All are these are technically possibilities. We could imagine a world where discretized effects matter here for the spread of those rays.
-
-        <BR/>
-
-        <Para>Let's for a moment assume we wouldn't be able to completely reproduce a circle from a single point with a discrete <K><Bar>SHEET</Bar></K>. What would that look like? One view would be: There's a propegation direction, but the ray sometimes wanders from diagonal to non-diagonal and back to a diagonal: attempting some forward-preference. This 'wandering' would result in cones in each direction, with relative deadzones on the boundaries of them.</Para> 
-
-        <WanderVeins />
-
-        <BR/>
-
         It turns out that this is all the machinary we need to derive gravitational laws that approximate <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "Newtonian gravity", link: "https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation"}}/> and <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "General relativity", link: "https://en.wikipedia.org/wiki/General_relativity"}}/> and go beyond them.
 
         <BR/>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
index 5fb5f7c..117b1bb 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
@@ -713,15 +713,38 @@ const A0_FIXED = C * H0_SI / (2 * Math.PI);
 const a0At = (z: number) => A0_FIXED * (1 + z);        // coasting: 1+z = t₀/t
 
 /** the boost over the purely baryonic speed, inside one effective radius */
-const boostAt = (d: HighZ, a0: number) => {
+const boostAt = (d: HighZ, a0: number, F = 1) => {
   const M = Math.pow(10, d.logMs) * MSUN / (1 - d.fgas);
-  const gN = G * M / Math.pow(d.Re * KPC, 2);
+  const gN = F * G * M / Math.pow(d.Re * KPC, 2);
   return Math.sqrt((gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0)) / gN);
 };
 
 /** what Genzel's f_DM < 0.2 allows, as a boost factor */
 const ALLOWED = 1.12;
 
+/**
+ * AND WHAT THE SAME DISCS LOOK LIKE IF THE FIELD IS VEINED.
+ *
+ * `chance` divides by 4πr², a shell average, and every dot above is read off
+ * that. `tests/veins.ts` measured what that average is an average OVER — ridges
+ * along the lattice headings, wedges between them, and for a POINT source a
+ * peak over mean of 4.3 with the fifth percentile at zero. The shell average
+ * survives exactly (⟨F⟩ = 1 by construction), so the radial law and every
+ * number on this plot are untouched; what is new is that the answer depends on
+ * WHICH WAY you are looking, with the pattern fixed to the lattice.
+ *
+ * These discs are the most forgiving case there is. A ridge points along the
+ * lattice rather than away from the source, so ridges from different parts of a
+ * body are parallel and stack — but a body of radius Rs seen from r does smooth
+ * anything finer than Rs/r, and the baryons of these galaxies sit inside about
+ * one effective radius, so Rs/r ≈ 1 and almost all of the structure is gone.
+ *
+ * From `tests/veined.ts`, at Rs/r = 1: p95 = 1.0321, p05 = 0.9660. Those are the
+ * numbers below, and they are quantiles rather than extremes so the bar is what
+ * ninety per cent of directions fall inside.
+ */
+const F_RIDGE = 1.0321, F_WEDGE = 0.9660;
+
 const highz = (s: Surface) => {
   const box = frame(s, 58);
   const { ctx } = s;
@@ -759,6 +782,21 @@ const highz = (s: Surface) => {
     ctx.strokeStyle = "rgba(255,255,255,0.16)"; ctx.lineWidth = 1;
     ctx.beginPath(); ctx.moveTo(X(d.z), Y(bf)); ctx.lineTo(X(d.z), Y(bm)); ctx.stroke();
 
+    // the veined reading: the same disc seen along a ridge and down a wedge.
+    // Drawn as a capped bar offset a little to the right so it does not sit
+    // under the model dot — the point of it is the WIDTH, and a marker hidden
+    // behind another marker has no width to read.
+    const hi = boostAt(d, a0At(d.z), F_RIDGE), lo = boostAt(d, a0At(d.z), F_WEDGE);
+    const vx = X(d.z) + 7;
+    ctx.strokeStyle = FLOOR; ctx.lineWidth = 1.4;
+    ctx.beginPath(); ctx.moveTo(vx, Y(hi)); ctx.lineTo(vx, Y(lo)); ctx.stroke();
+    for (const b of [hi, lo]) {
+      ctx.beginPath(); ctx.moveTo(vx - 3, Y(b)); ctx.lineTo(vx + 3, Y(b)); ctx.stroke();
+    }
+    ctx.fillStyle = FLOOR;
+    ctx.beginPath(); ctx.arc(vx, Y(hi), 2.2, 0, 2 * Math.PI); ctx.fill();
+    ctx.beginPath(); ctx.arc(vx, Y(lo), 2.2, 0, 2 * Math.PI); ctx.fill();
+
     ctx.fillStyle = DATA;
     ctx.beginPath(); ctx.arc(X(d.z), Y(bf), 3.1, 0, 2 * Math.PI); ctx.fill();
     ctx.fillStyle = MODEL;
@@ -775,6 +813,7 @@ const highz = (s: Surface) => {
   tag(s, X(0.66), Y(1.44), "EXCLUDED — Genzel measures f_DM(<Re) < 0.2, i.e. under 1.12", SEEN);
   tag(s, X(0.66), Y(1.325), "a₀ = cH₀/2π·(1+z) — THIS MODEL", MODEL);
   tag(s, X(0.66), Y(1.265), "a₀ fixed — ordinary MOND", DATA);
+  tag(s, X(0.66), Y(1.205), "veined field — ridge to wedge, 90% of directions", FLOOR);
   tag(s, X(0.66), Y(1.028), "NEWTON & GR — the baryons alone", RELAT);
 
   under(s, box, "redshift");
@@ -786,7 +825,7 @@ const highz = (s: Surface) => {
 /** the prediction that dates the model, against the measurement that refuses it */
 export const HighRedshift = ({ height = 320 }: { height?: number }) =>
   <Panel paint={highz} height={height}
-    note="six massive discs at z ≈ 1–2 — where a₀ ∝ 1/t is refused" />;
+    note="six massive discs at z ≈ 1–2 — where a₀ ∝ 1/t is refused, veined or not" />;
 
 // ---------------------------------------------------------------------------
 // AND THE SAME PICTURE AT z ≈ 2, WHICH IS WHERE THE READINGS COME APART.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
index 075d19b..201b5e9 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
@@ -20,6 +20,19 @@ than as silent agreement.
 
 ## what each one settles
 
+### the shape of propagation
+
+| | |
+|---|---|
+| `turns` | why a turn is eight ticks in every dimension |
+| `ways` | **the shipped wander against the one `wander.tsx` models** — they are not the same rule, and in 3D no `w` puts the emission sheet on a circle |
+| `veins` | what the ridges do with distance, cone shape and an extended emitter, and what all of it does to light |
+| `gas` | **the fully discrete version** — bits per direction, streaming, and a momentum-conserving swap on head-on pairs; the front is beams with no medium and closed and round with one |
+| `wave` | **the same lattice propagating as a wave instead of a ray** — the front is a circle at the sound speed and the grain vanishes as the pulse widens |
+| `lattices` | **which space gives a sphere** — a sweep of spatial constructions against the spherical-design condition, and the shell search that finds 26 directions exact through rank 6 |
+| `veined` | **what every law becomes if the field is veined rather than shell-averaged** — the radial law survives exactly, the Solar System kills it, galaxies cannot see it |
+| `cones` | **is there a rule with nothing tuned that gives a sphere** — no, and in 3D no `w` can, plus what each candidate rule does to every published number |
+
 ### the force law
 
 | | |
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/cones.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/cones.ts
new file mode 100644
index 0000000..a8d507f
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/cones.ts
@@ -0,0 +1,301 @@
+/**
+ * IS THERE A RULE WITH NOTHING TO TUNE THAT STILL GIVES A CIRCLE — and what
+ * would each candidate do to the gravity the article has already published.
+ *
+ * Every "front is a circle" result so far has been bought with a `w`: pick the
+ * turn rate that happens to equalise the crest speeds and the front rounds. That
+ * is a fitted parameter dressed as a derivation, and the honest question is
+ * whether any rule gets there WITHOUT one — no free number, or the trivial
+ * w = 1 ("always take an alternative"), which is the only value that is not a
+ * choice.
+ *
+ * The second half is what actually matters downstream. Geometry reaches the
+ * predictions through one number:
+ *
+ *     k = (1/8) Σ 1/v(d)      over the eight directions of the emission sheet
+ *
+ * — what a unit-thickness shell holds, against what the closed form assumes —
+ * because `chance` divides by the closed form's SHEET/4πr². `Ḡ` goes as k², and
+ * `models.ts` carries every mass as M/GRAVITY so `Ḡ` cancels out of the orbital
+ * dynamics before it is used. What does NOT cancel is the acceleration scale,
+ * a₀ = 4πG/(SHEET·t₀) ∝ Ḡ ∝ k², and everything MOND-shaped hangs off that:
+ *
+ *     v_flat ∝ a₀^(1/4) ∝ √k        the flat rotation speedC
+ *     R_step ∝ a₀^(−1/2) ∝ 1/k      where g_N falls to a₀
+ *     cluster shortfall ∝ 1/k
+ *
+ * so one column of this table is the whole of the damage each rule does.
+ *
+ * Run: ./run.sh cones
+ */
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the published constants, recomputed rather than imported
+
+const D = 3;
+const SHEET = Math.pow(3, D - 1) - 1;            // 8
+const DEG = Math.pow(3, D) - 1;                  // 26
+const BITE = 1, LIGHT = 1, CORE = 0.5;
+const M_PLANCK = 2.176434e-8;                    // kg
+
+/** the published Ḡ, at k = 1 — a perfect sphere assumed rather than derived */
+const G_AT = (k: number) =>
+  k * k * BITE * 0.5 * SHEET * SHEET * LIGHT / (4 * Math.PI * Math.PI * CORE * DEG);
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the rules
+
+type Rule = {
+  name: string;
+  free: boolean;                                  // is there a w to tune?
+  w?: number;
+  /** the alternatives a heading admits, and how the weight is split over them */
+  step: (h: number[], w: number) => { d: number[], p: number }[];
+  /** how many ticks a step of this displacement costs */
+  cost?: (d: number[]) => number;
+  note: string;
+};
+
+const dirsC = (d: number): number[][] => {
+  let out: number[][] = [[]];
+  for (let i = 0; i < d; i++) out = out.flatMap(p => [-1, 0, 1].map(v => [...p, v]));
+  return out.filter(p => p.some(v => v !== 0));
+};
+
+const rankC = (h: number[]) => h.filter(v => v !== 0).length;
+const normC = (v: number[]) => Math.hypot(...v);
+const dotC = (a: number[], b: number[]) => a.reduce((s, v, i) => s + v * b[i], 0);
+const sameC = (a: number[], b: number[]) => a.every((v, i) => v === b[i]);
+
+/** the alternatives `discrete.ts` builds, in any dimension */
+const shipWays = (h: number[]) => {
+  const out: number[][] = [];
+  for (let a = 0; a < h.length; a++) {
+    if (h[a]) { const one = h.map(() => 0); one[a] = h[a]; out.push(one); }
+    else for (const s of [1, -1]) { const off = h.slice(); off[a] = s; out.push(off); }
+  }
+  return out;
+};
+
+/** (1−w) straight on, w spread uniformly over a list */
+const mixC = (h: number[], alt: number[][], w: number) => {
+  const acc = new Map<string, { d: number[], p: number }>();
+  const put = (d: number[], p: number) => {
+    const k = d.join(",");
+    const e = acc.get(k);
+    if (e) e.p += p; else acc.set(k, { d, p });
+  };
+  put(h, 1 - w);
+  for (const d of alt) put(d, w / alt.length);
+  return [...acc.values()].filter(e => e.p > 1e-15);
+};
+
+const RULES: Rule[] = [
+  {
+    name: "shipped, w=1", free: false, w: 1,
+    step: (h, w) => mixC(h, shipWays(h), w),
+    note: "discrete.ts as it stands, with nothing tunedC",
+  },
+  {
+    name: "shipped, tunedC", free: true,
+    step: (h, w) => mixC(h, shipWays(h), w),
+    note: "the sameC, with w chosen to round the front — exists in 2D only",
+  },
+  {
+    name: "forward, w=1", free: false, w: 1,
+    step: (h, w) => mixC(h, dirsC(h.length).filter(d => dotC(d, h) > 0), w),
+    note: "wander.tsx's cone: every direction with positive overlap, uniformly",
+  },
+  {
+    name: "forward, tunedC", free: true,
+    step: (h, w) => mixC(h, dirsC(h.length).filter(d => dotC(d, h) > 0), w),
+    note: "and the sameC cone with w fitted — this is where 0.8787 comes from",
+  },
+  {
+    name: "hemisphere, w=1", free: false, w: 1,
+    step: (h, w) => mixC(h, dirsC(h.length).filter(d => dotC(d, h) >= 0), w),
+    note: "the perpendiculars allowed in as well",
+  },
+  {
+    name: "overlap-weighted", free: false,
+    step: h => {
+      const ds = dirsC(h.length).map(d => ({ d, p: Math.max(0, dotC(d, h)) }));
+      const s = ds.reduce((a, c) => a + c.p, 0);
+      return ds.filter(c => c.p > 0).map(c => ({ d: c.d, p: c.p / s }));
+    },
+    note: "no w AT ALL: weight each direction by how much of the heading it keeps",
+  },
+  {
+    name: "timed, w=1", free: false, w: 1,
+    step: (h, w) => mixC(h, shipWays(h), w),
+    cost: normC,
+    note: "shipped steps, but a step of length |d| COSTS |d| ticks",
+  },
+  {
+    name: "timed-forward, w=1", free: false, w: 1,
+    step: (h, w) => mixC(h, dirsC(h.length).filter(d => dotC(d, h) > 0), w),
+    cost: normC,
+    note: "the sameC idea on the forward cone",
+  },
+  {
+    name: "blind, w=1", free: false, w: 1,
+    step: (h, w) => mixC(h, dirsC(h.length), w),
+    note: "no cone: pick any direction. ⟨step⟩ = 0, so nothing propagates",
+  },
+];
+
+/** the Euclidean speedC of the crest of a heading: ⟨displacement⟩ / ⟨cost⟩ */
+const speedC = (r: Rule, h: number[], w: number) => {
+  const st = r.step(h, w);
+  const disp = h.map((_, i) => st.reduce((a, c) => a + c.p * c.d[i], 0));
+  const cost = r.cost ? st.reduce((a, c) => a + c.p * (r.cost as (d: number[]) => number)(c.d), 0) : 1;
+  return normC(disp) / cost;
+};
+
+/** the w that equalises rankC-1 and rankC-2, if there is one in [0,1] */
+const tunedC = (r: Rule, d: number) => {
+  const f = dirsC(d).find(h => rankC(h) === 1) as number[];
+  const e = dirsC(d).find(h => rankC(h) === 2) as number[];
+  const g = (w: number) => speedC(r, e, w) / speedC(r, f, w) - 1;
+  if (g(0) * g(1) > 0) return NaN;
+  let lo = 0, hi = 1;
+  for (let i = 0; i < 200; i++) { const m = (lo + hi) / 2; if (g(lo) * g(m) <= 0) hi = m; else lo = m; }
+  return (lo + hi) / 2;
+};
+
+const padC = (x: number, n = 4, w = 10) => (isFinite(x) ? x.toFixed(n) : "—").padStart(w);
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log("CONES — a circle with nothing tunedC, and what each rule costs gravity\n");
+
+// ── 1. speeds and roundness ──────────────────────────────────────────────────
+
+console.log("─".repeat(96));
+console.log("1. WHAT SHAPE EACH RULE'S FRONT IS\n");
+console.log("  rule                     w      face      edge    corner   sheet e/f   full max/min");
+for (const r of RULES) {
+  const w = r.free ? tunedC(r, 3) : (r.w ?? 1);
+  if (!isFinite(w)) {
+    console.log("  " + r.name.padEnd(20) + "   none" + "         no w in [0,1] rounds it — see §2");
+    continue;
+  }
+  const hs = [1, 2, 3].map(k => dirsC(3).find(h => rankC(h) === k) as number[]);
+  const vs = hs.map(h => speedC(r, h, w));
+  const live = vs.every(v => v > 1e-12);
+  console.log("  " + r.name.padEnd(20) + w.toFixed(4).padStart(7)
+    + vs.map(v => padC(v, 4, 10)).join("")
+    + (live ? padC(vs[1] / vs[0], 4, 12) + padC(Math.max(...vs) / Math.min(...vs), 4, 15)
+      : "     stationary — ⟨step⟩ = 0"));
+}
+console.log("\n  `sheet e/f` is the one the article's k uses: the emission sheet is a");
+console.log("  coordinate plane, so it holds rankC-1 and rankC-2 headings and no corners.");
+console.log("  1.0000 there is a circular front IN THE SHEET; 1.0000 in `full max/min`");
+console.log("  is a spherical front in the whole lattice, which is a stronger claim and");
+console.log("  is what a wandering charge would actually need.\n");
+
+// ── 2. the parameter-free question ───────────────────────────────────────────
+
+console.log("─".repeat(96));
+console.log("2. WITH NOTHING TUNED\n");
+console.log("  rule                  sheet e/f   corner/f   full max/min");
+let bestFree = "", bestFreeR = Infinity;
+for (const r of RULES.filter(x => !x.free)) {
+  const hs = [1, 2, 3].map(k => dirsC(3).find(h => rankC(h) === k) as number[]);
+  const vs = hs.map(h => speedC(r, h, r.w ?? 1));
+  if (!vs.every(v => v > 1e-12)) {
+    console.log("  " + r.name.padEnd(20) + "   stationary — ⟨step⟩ = 0, nothing propagates");
+    console.log("      " + r.note);
+    continue;
+  }
+  const ratio = Math.max(...vs) / Math.min(...vs);
+  if (ratio < bestFreeR) { bestFreeR = ratio; bestFree = r.name; }
+  console.log("  " + r.name.padEnd(20) + padC(vs[1] / vs[0], 4, 11)
+    + padC(vs[2] / vs[0], 4, 11) + padC(ratio, 4, 15));
+  console.log("      " + r.note);
+}
+console.log("\n  NOT ONE OF THEM IS ROUND. The best a rule with nothing to tune manages");
+console.log("  is " + bestFree + " at " + bestFreeR.toFixed(4) + ", and the best ANY rule here manages,");
+console.log("  with a w fitted for exactly this purpose, is forward-tunedC at 1.0298.");
+console.log("  `blind` is round only in the sense that a rock is: ⟨step⟩ = 0 in every");
+console.log("  direction, so there is no front and nothing to be the shape of.");
+console.log();
+console.log("  `timed` was worth testing and does not work either. The thought was that");
+console.log("  if a step of Euclidean length |d| costs |d| ticks then speedC = ⟨d⟩/⟨|d|⟩");
+console.log("  would come out the sameC everywhere. It does not: |⟨d⟩| is the length of");
+console.log("  an average and ⟨|d|⟩ is an average of lengths, and those two disagree by");
+console.log("  exactly as much as the alternatives disagree in direction — which is a");
+console.log("  different amount for a face than for a diagonal. It moves the numbers");
+console.log("  (1.0607 → 1.0338 in the sheet) without closing the gap.");
+console.log();
+console.log("  AND THERE IS A COUNTING REASON why tuning cannot rescue it either. In d");
+console.log("  dimensions a heading has d speedC classes by rankC, so roundness is d − 1");
+console.log("  equations, and a turn rate is ONE knob. d = 2 is the only case where the");
+console.log("  count works, which is exactly why the plane rounds at 2(1 − 1/√2) and");
+console.log("  three dimensions does not round anywhere. The circle in the pictures is");
+console.log("  a two-dimensional accident, and the sphere the closed form assumes is not");
+console.log("  reachable by choosing how often a charge turns.\n");
+
+// ── 3. what it does to gravity ───────────────────────────────────────────────
+
+console.log("─".repeat(96));
+console.log("3. WHAT EACH RULE DOES TO THE PUBLISHED NUMBERS");
+console.log("   k = (1/8) Σ 1/v over the eight sheet directions — what a shell holds");
+console.log("   against what `chance` assumes. Ḡ ∝ k², and a₀ ∝ Ḡ, so:\n");
+
+const kOf = (r: Rule, w: number) => {
+  const sheet = dirsC(3).filter(h => h[2] === 0);   // the coordinate plane: 8 of them
+  return sheet.reduce((a, h) => a + 1 / speedC(r, h, w), 0) / sheet.length;
+};
+
+console.log("  rule                     w        k        Ḡ       µ (µg)  v_flat  R_step(kpc)  clust");
+const base = { R1: 33, R2: 52, cl: 1.52 };
+for (const r of RULES) {
+  const w = r.free ? tunedC(r, 3) : (r.w ?? 1);
+  const k = kOf(r, w);
+  if (!isFinite(k) || k > 1e6) {
+    console.log("  " + r.name.padEnd(20) + "     —         —        —          —       —        —          —");
+    continue;
+  }
+  const G = G_AT(k);
+  console.log("  " + r.name.padEnd(20) + (isFinite(w) ? w.toFixed(4) : "none").padStart(7)
+    + padC(k, 4, 9) + padC(G, 6, 10) + padC(G * M_PLANCK * 1e9, 4, 11)
+    + padC(Math.sqrt(k), 4, 8)
+    + ("  " + (base.R1 / k).toFixed(1) + " / " + (base.R2 / k).toFixed(1)).padStart(13)
+    + padC(base.cl / k, 3, 8));
+}
+console.log("\n  v_flat is a MULTIPLIER on the published flat rotation speedC, R_step the");
+console.log("  two radii where g_N falls to a₀ for the Milky Way (published 33 / 52 kpc),");
+console.log("  and `clust` the cluster shortfall (published 1.52×, and MOND's own known");
+console.log("  cluster problem is that this number is about 2). µ is the mass unit,");
+console.log("  published 1.357 µg.\n");
+
+// ── 4. which of the existing tests actually move ─────────────────────────────
+
+console.log("─".repeat(96));
+console.log("4. WHICH GRAVITY TESTS THIS TOUCHES AT ALL\n");
+console.log("  INSENSITIVE — every mass in `models.ts` is carried as M/GRAVITY, so the");
+console.log("  dynamics compute Ḡ·(M/Ḡ) and the constant is gone before it is used.");
+console.log("  These run on a measured GM and do not move by one digit under any rule:");
+console.log("    three, combined, frontcheck, sne, caught, arms, rootm, rootm2, feed,");
+console.log("    selfcon, fixedpoint, speedloop, drivers, galaxy_sc, perm, vmass, sens,");
+console.log("    sign, transport, expand, genzel, empty, spacing, blocking, redo, shape,");
+console.log("    quant, steps, joint, recon, which138, accum, accumulate, asym");
+console.log();
+console.log("  SENSITIVE — anything that goes through a₀ or through the mass unit:");
+console.log("    · the acceleration scale a₀ = 4πG/(SHEET·t₀)             ∝ k²");
+console.log("    · flat rotation speeds and the BTFR normalisation        ∝ √k");
+console.log("    · the two step radii and the cluster shortfall           ∝ 1/k");
+console.log("    · µ = Ḡ·m_Planck, and the Compton relation through it    ∝ k²");
+console.log();
+console.log("  ELECTROMAGNETIC — polarity, pol2, pulses, magnets, coulomb, moment,");
+console.log("  dipole, poles, ordering, budget, tradeoff, scale, maxwell, nopolarity:");
+console.log("  these run on the sameC propagation, so a change of rule changes them the");
+console.log("  sameC way it changes gravity — the ratio of the two forces is built from");
+console.log("  the sameC k and cancels. That is why the XOR side is not listed above.");
+console.log();
+console.log("  and NONE of them is sensitive to the veins, which is the point worth");
+console.log("  keeping: every one of these is a RADIAL number, read off a shell average.");
+console.log("  The angular structure integrates out of all of them and shows up only in");
+console.log("  what `veins` measures — which is why it was invisible until it was looked");
+console.log("  for, and why no existing test would have caught it.");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/gas.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/gas.ts
new file mode 100644
index 0000000..2ac4498
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/gas.ts
@@ -0,0 +1,376 @@
+/**
+ * THE DISCRETE VERSION — integers, no occupancy vector, no weights, no wander.
+ *
+ * `wave` measured the frontG of a lattice Boltzmann, which carries a real number
+ * per direction per cell and relaxes towards an equilibrium with chosen weights.
+ * That is the STATISTICS of the thing, not the thing, and it is a fair objection
+ * that it is not the model: nobody wants a rule that says "adjust your heading
+ * according to a weighted average of your neighbourhood". That would be an
+ * absurd rule and it is not what is being proposed.
+ *
+ * What is being proposed is entirely discrete and has three parts:
+ *
+ *   STATE       each cell holds, for each of the lattice's directions, whether
+ *               there is a charge there heading that way. One bit. No counts, no
+ *               reals, no probabilities.
+ *
+ *   STREAM      every charge moves one cell along its own direction. Nothing
+ *               changes heading. A charge alone in empty space goes perfectly
+ *               straight for ever, exactly as it does now.
+ *
+ *   COLLIDE     a charge changes heading ONLY when it lands on the same cell as
+ *               another charge, only as a function of what is in that one cell,
+ *               and only into an outcome with the SAME NUMBER of charges and the
+ *               SAME TOTAL MOMENTUM. Head-on pairs come out sideways. Everything
+ *               else is left alone.
+ *
+ * There is no turn rate, no cone, no distribution to choose and nothing that
+ * looks at a neighbourhood. The weights in `wave` are not an input to this —
+ * they are what the equilibrium of that collision turns out to be, which is a
+ * result and not a rule.
+ *
+ * This is a lattice gas cellular automaton (Hardy, de Pazzis & Pomeau 1973,
+ * J. Math. Phys. 14:1746; Frisch, Hasslacher & Pomeau 1986, PRL 56:1505), runG on
+ * both classical lattices — HPP's four directions, which fail at rank 4, and
+ * FHP's six, which do not.
+ *
+ * I expected the frontG to come out square on one and round on the other. IT DOES
+ * NOT, and the reason is worth more than the expectation was. The speed of a
+ * small disturbance is set by the SECOND moment of the direction set, and rank 2
+ * is isotropic on both — on every cubic lattice, as `lattices` found. HPP's
+ * famous anisotropy lives in the momentum flux, which is a rank-4 quantity and
+ * shows up in FLOWS, not in the frontG of a pulse. So both lattices give a round
+ * frontG, and the thing that decides roundness is not which lattice but whether
+ * there is a medium at all.
+ *
+ * The sweep over background density is the part that answers the question. At
+ * density zero there are no collisions and the release is a set of beams — one
+ * per lattice direction, which is precisely the ray picture and precisely the
+ * veins. Turn the density up and the same beams become a circle. ONE charge is a
+ * ray and goes straight; MANY charges are a wave and it is round. Nothing in
+ * between was tuned.
+ *
+ * Run: ./runG.sh gas
+ */
+
+// ─────────────────────────────────────────────────────────────────────────────
+// two spaces
+
+/**
+ * FHP: a triangular lattice, six directions, held in axial coordinates (q, r)
+ * so the arithmetic stays integer. Euclidean position is x = q + r/2 and
+ * y = r·√3/2, under which the six neighbours below sit at 0°, 60°, … 300° and
+ * the opposite of direction i is i + 3.
+ */
+const FHP = {
+  name: "FHP, triangular",
+  n: 6,
+  step: [[1, 0], [0, 1], [-1, 1], [-1, 0], [0, -1], [1, -1]],
+  xy: (q: number, r: number): [number, number] => [q + r / 2, r * Math.sqrt(3) / 2],
+};
+
+/** HPP: the square lattice, four directions, opposite of i is i + 2 */
+const HPP = {
+  name: "HPP, square",
+  n: 4,
+  step: [[1, 0], [0, 1], [-1, 0], [0, -1]],
+  xy: (q: number, r: number): [number, number] => [q, r],
+};
+
+type SpaceG = typeof FHP;
+
+/**
+ * The collision tableG, built rather than written out: for every possible cell
+ * contents, the outcome. A pair head-on is the only case either lattice acts
+ * on, plus FHP's three-body symmetric case, and both outcomes are picked to
+ * have the same count and the same total momentum as the input — which is
+ * checked below rather than trusted.
+ *
+ * `alt` is the second outcome for FHP's head-on case, which has two equally
+ * good answers (rotate left or rotate right). Choosing one of them always would
+ * put a handedness into the space, so the automaton alternates by cell parity —
+ * a deterministic choice, not a random one, and no distribution is involved.
+ */
+const tableG = (S: SpaceG) => {
+  const N = 1 << S.n;
+  const main = new Uint8Array(N), alt = new Uint8Array(N);
+  for (let s = 0; s < N; s++) { main[s] = s; alt[s] = s; }
+
+  const half = S.n / 2;
+  for (let i = 0; i < half; i++) {
+    const headOn = (1 << i) | (1 << (i + half));
+    if (S.n === 4) {
+      main[headOn] = (1 << ((i + 1) % 4)) | (1 << ((i + 3) % 4));
+      alt[headOn] = main[headOn];
+    } else {
+      main[headOn] = (1 << ((i + 1) % 6)) | (1 << ((i + 4) % 6));
+      alt[headOn] = (1 << ((i + 5) % 6)) | (1 << ((i + 2) % 6));
+    }
+  }
+  if (S.n === 6) {                                   // the three-body symmetric case
+    main[0b010101] = 0b101010; alt[0b010101] = 0b101010;
+    main[0b101010] = 0b010101; alt[0b101010] = 0b010101;
+  }
+  return { main, alt };
+};
+
+/** count and momentum of a cell state, for auditing the tableG */
+const auditG = (S: SpaceG, t: ReturnType<typeof tableG>) => {
+  const bad: string[] = [];
+  for (let s = 0; s < (1 << S.n); s++) {
+    for (const out of [t.main[s], t.alt[s]]) {
+      let c0 = 0, c1 = 0, px = 0, py = 0, qx = 0, qy = 0;
+      for (let i = 0; i < S.n; i++) {
+        const [ex, ey] = S.xy(S.step[i][0], S.step[i][1]);
+        if (s & (1 << i)) { c0++; px += ex; py += ey; }
+        if (out & (1 << i)) { c1++; qx += ex; qy += ey; }
+      }
+      if (c0 !== c1 || Math.abs(px - qx) > 1e-9 || Math.abs(py - qy) > 1e-9)
+        bad.push(s.toString(2).padStart(S.n, "0") + " → " + out.toString(2).padStart(S.n, "0"));
+    }
+  }
+  return bad;
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the automaton
+
+let SEED_G = 20260814;
+const rndG = () => (SEED_G = (SEED_G * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+
+/**
+ * A box of cells, filled at background density `d` (each direction of each cell
+ * independently occupied or not — which is the equilibrium of this collision at
+ * zero mean velocity), a solid blob dropped in the middle, and T ticks of
+ * stream-then-collide. Returns the density above background, averaged over
+ * `runs` independent fillings so the ring is visible over the shot noise.
+ */
+const runG = (S: SpaceG, L: number, T: number, d: number, runs: number, blob = true) => {
+  const t = tableG(S), o = (L - 1) / 2, C = L * L;
+  const acc = new Float64Array(C);
+
+  for (let k = 0; k < runs; k++) {
+    let cur = new Uint8Array(C), nxt = new Uint8Array(C);
+    for (let c = 0; c < C; c++) {
+      let s = 0;
+      for (let i = 0; i < S.n; i++) if (rndG() < d) s |= 1 << i;
+      cur[c] = s;
+    }
+    if (blob) for (let r = -3; r <= 3; r++) for (let q = -3; q <= 3; q++)
+      if (q * q + r * r + q * r <= 9) cur[(r + o) * L + (q + o)] = (1 << S.n) - 1;
+
+    for (let step = 0; step < T; step++) {
+      nxt.fill(0);
+      for (let r = 0; r < L; r++) for (let q = 0; q < L; q++) {
+        const s = cur[r * L + q];
+        if (!s) continue;
+        const out = ((q + r) & 1) ? t.alt[s] : t.main[s];
+        for (let i = 0; i < S.n; i++) {
+          if (!(out & (1 << i))) continue;
+          const nq = (q + S.step[i][0] + L) % L, nr = (r + S.step[i][1] + L) % L;
+          nxt[nr * L + nq] |= 1 << i;
+        }
+      }
+      const tmp = cur; cur = nxt; nxt = tmp;
+    }
+
+    for (let c = 0; c < C; c++) {
+      let n = 0;
+      for (let i = 0; i < S.n; i++) if (cur[c] & (1 << i)) n++;
+      acc[c] += n;
+    }
+  }
+
+  const mean = d * S.n;
+  for (let c = 0; c < C; c++) acc[c] = acc[c] / runs - mean;
+  return { S, L, o, T, rho: acc };
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+const NB_G = 72;                                       // 5° bins — the gas is noisy
+const angBinG = (x: number, y: number) =>
+  Math.min(NB_G - 1, Math.floor(((Math.atan2(y, x) + 2 * Math.PI) % (2 * Math.PI)) / (2 * Math.PI) * NB_G));
+
+/**
+ * THE FRONT, read in a window rather than over the whole disk. The first version
+ * of this took the centre of mass of everything positive out to r = 62 and could
+ * not tell six beams from a circle — at d = 0 it reported a swing of 0.0025 for
+ * a picture that is literally six spikes and nothing in between, because the
+ * empty bins have no weight to have a radius with.
+ *
+ * Two things fix it. The window [0.40 T, 1.05 T] keeps the outgoing frontG and
+ * drops both the churn left at the origin and everything past the ballistic
+ * limit, where nothing can be and any signal is the noise floor of the average.
+ * And the isotropy is read off the AMPLITUDE per direction, not the radius:
+ * beams are bins with everything next to bins with nothing, which is a statement
+ * about how much, not about how far.
+ */
+const frontG = (F: ReturnType<typeof runG>) => {
+  const lo = 0.40 * F.T, hi = 1.05 * F.T;
+  const A = new Float64Array(NB_G), WR = new Float64Array(NB_G);
+  const H = (F.L - 1) / 2;
+  for (let r = -H; r <= H; r++) for (let q = -H; q <= H; q++) {
+    const [x, y] = F.S.xy(q, r);
+    const d = Math.hypot(x, y);
+    if (d < lo || d > hi) continue;
+    const v = Math.max(0, F.rho[(r + F.o) * F.L + (q + F.o)]);
+    const b = angBinG(x, y);
+    A[b] += v; WR[b] += v * d;
+  }
+  return {
+    amp: Array.from(A),
+    R: Array.from(A, (a, b) => a > 0 ? WR[b] / a : NaN),
+  };
+};
+
+/**
+ * `rms` over ALL bins including the empty ones — an empty bin is the whole
+ * point when the question is whether the frontG has holes in it. max/min is not
+ * used: on a gas of this size it is a reading of the noisiest single bin.
+ */
+const spreadG = (a: number[]) => {
+  const f = a.map(v => isFinite(v) ? v : 0);
+  const m = f.reduce((x, y) => x + y, 0) / f.length;
+  if (!(m > 0)) return { mean: NaN, rms: NaN, holes: NaN };
+  return {
+    mean: m,
+    rms: Math.sqrt(f.reduce((s, v) => s + (v / m - 1) ** 2, 0) / f.length),
+    holes: f.filter(v => v < 0.05 * m).length / f.length,
+  };
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log("THE DISCRETE VERSION — bits, streaming, and collisions\n");
+
+console.log("─".repeat(80));
+console.log("1. THE COLLISION TABLE, AUDITED\n");
+for (const S of [HPP, FHP]) {
+  const t = tableG(S);
+  const bad = auditG(S, t);
+  const acts = [...Array(1 << S.n).keys()].filter(s => t.main[s] !== s || t.alt[s] !== s);
+  console.log("  " + S.name.padEnd(20) + String(1 << S.n).padStart(4) + " possible cell states, "
+    + String(acts.length).padStart(2) + " of them collide");
+  console.log("    conservation of count and momentum: "
+    + (bad.length ? "VIOLATED in " + bad.length + " cases" : "holds in every case"));
+  console.log("    the states that act: " + acts.map(s => s.toString(2).padStart(S.n, "0")).join(" "));
+}
+console.log("\n  that is the entire rule. Every other cell state is left exactly as it is,");
+console.log("  and a cell with one charge in it is always left exactly as it is — which");
+console.log("  is what `a lone charge goes straight for ever` means.\n");
+
+console.log("─".repeat(80));
+console.log("2. ONE CHARGE IS A RAY, MANY ARE A WAVE\n");
+console.log("   the same automaton at different background densities. At d = 0 there is");
+console.log("   nothing to collide with and the release is beams; the frontG swing is how");
+console.log("   much the ring's radius varies with direction, so small is round.\n");
+
+console.log("   space                  d    frontG r    ring rms   amplitude rms   empty");
+for (const S of [FHP, HPP]) {
+  for (const d of [0, 0.02, 0.08, 0.20, 0.35]) {
+    const F = runG(S, 141, 40, d, d === 0 ? 4 : 32);
+    const f = frontG(F);
+    const sa = spreadG(f.amp);
+    const rr = f.R.filter(v => isFinite(v));
+    const mr = rr.reduce((a, b) => a + b, 0) / rr.length;
+    const rms = Math.sqrt(rr.reduce((a, v) => a + (v / mr - 1) ** 2, 0) / rr.length);
+    console.log("  " + S.name.padEnd(20) + d.toFixed(2).padStart(6)
+      + mr.toFixed(1).padStart(10) + rms.toFixed(4).padStart(11)
+      + sa.rms.toFixed(4).padStart(15) + (100 * sa.holes).toFixed(0).padStart(7) + "%");
+  }
+  const F0 = runG(S, 141, 40, 0.20, 32, false);        // the same runG with NO pulse:
+  const s0 = spreadG(frontG(F0).amp);                   // whatever this reads is noise
+  console.log("  " + (S.name + ", no pulse").padEnd(20) + "  0.20"
+    + "         —          —" + s0.rms.toFixed(4).padStart(15) + "      —");
+  console.log();
+}
+console.log("  `empty` is the share of the 72 directions with essentially nothing in");
+console.log("  them. At d = 0 it is the gaps between the beams and it is most of the");
+console.log("  circle; the frontG only closes when there is something to collide with.\n");
+
+console.log("  FHP and HPP runG the SAME rule — stream, then swap head-on pairs sideways —");
+console.log("  and differ only in how many directions the space has. FOUR IS ENOUGH, and");
+console.log("  that was not what I expected: HPP fails the rank-4 condition and FHP");
+console.log("  passes it, yet at every density above 0.08 both sit at the noise floor of");
+console.log("  this measurement. The reason is that the speed of a small disturbance is a");
+console.log("  RANK 2 quantity, and rank 2 is isotropic on both — on every cubic lattice.");
+console.log("  HPP's anisotropy is in the momentum flux and shows up in flows, not in the");
+console.log("  frontG of a pulse. So the lattice was never what decided this. What decided");
+console.log("  it is the column above: 83% of the sky empty at d = 0, 0% at d = 0.08.\n");
+
+console.log("─".repeat(80));
+console.log("3. WHICH REGIME THIS IS IN — and what it therefore does not show\n");
+console.log("   A collision table this thin leaves most charges alone most of the time.");
+console.log("   The mean free path below is 1 / (fraction of charges in a colliding cell");
+console.log("   state at equilibrium), which for FHP-I is small because only 5 of the 64");
+console.log("   states act at all.\n");
+{
+  const bits = (s: number, n: number) => {
+    let c = 0;
+    for (let i = 0; i < n; i++) if (s & (1 << i)) c++;
+    return c;
+  };
+  console.log("    space                  d    collides/tick   mean free path   Kn at r = 33");
+  for (const S of [FHP, HPP]) {
+    const t = tableG(S);
+    for (const d of [0.08, 0.20, 0.35, 0.50]) {
+      let coll = 0, tot = 0;
+      for (let st = 0; st < (1 << S.n); st++) {
+        let p = 1;
+        for (let i = 0; i < S.n; i++) p *= (st & (1 << i)) ? d : (1 - d);
+        const n = bits(st, S.n);
+        tot += p * n;
+        if (t.main[st] !== st || t.alt[st] !== st) coll += p * n;
+      }
+      const mfp = tot / coll;
+      console.log("    " + S.name.padEnd(20) + d.toFixed(2).padStart(6)
+        + (coll / tot).toFixed(4).padStart(15) + mfp.toFixed(1).padStart(16)
+        + (mfp / 33).toFixed(2).padStart(15));
+    }
+  }
+}
+console.log("\n   A Knudsen number of 0.3 is not a fluid. So THE FRONT MEASURED ABOVE IS");
+console.log("   NOT A SOUND WAVE — the angle-averaged profile is one broad bump at");
+console.log("   0.83 c, not a ring at FHP's sound speed of 1/√2 = 0.707 with a ballistic");
+console.log("   precursor at 1.0 behind it. What fills the empty directions here is");
+console.log("   plain SCATTERING: a charge knocked off its heading two or three times");
+console.log("   ends up displaced along a SUM of different lattice vectors, and sums of");
+console.log("   lattice vectors point anywhere. Six directions become a continuum.");
+console.log();
+console.log("   That is a real mechanism and it is enough for the angular gaps, but on");
+console.log("   its own it is the CARRIED-HEADING case from `veins`, which goes");
+console.log("   diffusive: scattering buys the angles and loses the light cone. The cone");
+console.log("   comes back only in the hydrodynamic limit, where the collective mode is");
+console.log("   sound and travels ballistically however much the carriers scatter — and");
+console.log("   that limit is what `wave` measures, at a collision rate high enough to");
+console.log("   reach it (front → 1/√3, swing → 1e-2). The two files are the same system");
+console.log("   at two collision rates, and only the second one is in the regime that");
+console.log("   the argument actually needs.\n");
+
+console.log("─".repeat(80));
+console.log("WHAT THIS ANSWERS\n");
+console.log("  · the rule is discrete all the way down. One bit per direction per cell,");
+console.log("    streaming that never touches a heading, and a lookup table on one");
+console.log("    cell's own contents. There is no weight anywhere in it — nothing is");
+console.log("    weighted, nothing is averaged, nothing consults a neighbourhood. The");
+console.log("    4/9, 1/9, 1/36 in `wave` is a DESCRIPTION of where this ends up, the");
+console.log("    way a temperature describes a gas. It is not a rule and nobody sets it.");
+console.log("  · a heading changes only in a collision, and only for the reason the model");
+console.log("    already has one: two charges met head-on. That case is already singled");
+console.log("    out in `discrete.ts`. What is missing there is only that the outcome be");
+console.log("    forced to keep the total momentum, which head-on annihilation does not.");
+console.log("  · the ray picture is not wrong — it is the d → 0 column. At zero density");
+console.log("    the front is beams and 83% of the directions have nothing in them at");
+console.log("    all, which is the veins in their purest form. The model has been");
+console.log("    computing the collisionless limit, where every charge keeps the heading");
+console.log("    it left with and the lattice's few directions are all there is.");
+console.log("  · and the fix is not a better lattice or a better distribution. It is a");
+console.log("    medium. But the medium has to be thick enough to be one: at the");
+console.log("    collision rate here the gaps fill and the cone does not survive, and");
+console.log("    both are needed. What creates the circle is not any charge going round");
+console.log("    it — no charge crosses more than a few cells before being turned. It is");
+console.log("    that momentum cannot be destroyed, so an excess of it at a cell has to");
+console.log("    be handed to the next one, and the hand-off travels at a speed set by");
+console.log("    Σ c⊗c over the directions, which is ∝ δ on any cubic lattice. The front");
+console.log("    is a relay, not a journey, and it is round because the pressure is.");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/lattices.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/lattices.ts
new file mode 100644
index 0000000..f134b2a
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/lattices.ts
@@ -0,0 +1,449 @@
+/**
+ * WHICH SPACE GIVES A SPHERE — a sweep over spatial constructions rather than
+ * over turn rates, and the one condition that decides it.
+ *
+ * Everything tried so far has been a knob: pick `w` so the diagonal crest and
+ * the face crest come out level. That buys a circle in the plane, buys nothing
+ * in three dimensions (`ways`: d − 1 conditions against one knob), and leaves
+ * the field veined either way (`veins`). This file stops adjusting the walk and
+ * changes the SPACE it walks on.
+ *
+ * THE CONDITION, which is not invented here and is not a fit. Take the
+ * neighbour set {c_i} with weights {w_i} and look at
+ *
+ *     S(n̂) = Σ w_i (c_i·n̂)²          the second moment along n̂
+ *     Q(n̂) = Σ w_i (c_i·n̂)⁴          the fourth
+ *
+ * If S and Q do not depend on n̂, then no measurement built out of moments up to
+ * fourth order can tell one direction from another — the space has no grain at
+ * that order, and anything spreading on it spreads in a sphere. If they do
+ * depend on n̂, the grain is there and shows up exactly as the veins did. The
+ * property is standard and has a name: the set has to be a SPHERICAL DESIGN of
+ * strength ≥ 4 (Delsarte, Goethals & Seidel 1977, Geom. Dedicata 6:363).
+ *
+ * WHY FOURTH ORDER AND NOT SECOND. Second order is easy — any set with cubic
+ * symmetry has S constant, which is why the model's 1/r² came out right and why
+ * nothing so far has caught the problem. The direction dependence lives at
+ * fourth order, which is the first place a cube can be told from a sphere. This
+ * is the same criterion that forces lattice-gas hydrodynamics off the cubic
+ * lattice (d'Humières, Lallemand & Frisch 1986, Europhys. Lett. 2:291), and it
+ * is why quasicrystals are elastically isotropic while crystals are not.
+ *
+ * AND WHERE THE WANDERING COMES IN. A design condition is a statement about an
+ * AVERAGE over the neighbour set, so it says nothing at all about a single
+ * charge going straight — one charge always sees the lattice. It is the
+ * spreading that averages, which is the intuition being asked for: light is
+ * round BECAUSE it wanders, not in spite of it, and the wander does not need a
+ * tuned rate. It needs a space whose neighbours average to a sphere.
+ *
+ * Run: ./run.sh lattices
+ */
+
+const PHI = (1 + Math.sqrt(5)) / 2;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the candidate spaces
+
+type Space = { name: string; dim: number; c: number[][]; w?: number[]; note: string };
+
+const perms = (v: number[]) => {                    // all distinct coordinate permutations
+  const out: number[][] = [];
+  const go = (cur: number[], rest: number[]) => {
+    if (!rest.length) { out.push(cur); return; }
+    const seen = new Set<number>();
+    rest.forEach((x, i) => {
+      if (seen.has(x)) return;
+      seen.add(x);
+      go([...cur, x], rest.filter((_, j) => j !== i));
+    });
+  };
+  go([], v);
+  return out;
+};
+
+const signs = (v: number[]) => {
+  let out: number[][] = [[]];
+  for (const x of v) out = out.flatMap(p => x === 0 ? [[...p, 0]] : [[...p, x], [...p, -x]]);
+  const seen = new Set<string>();
+  return out.filter(p => { const k = p.join(","); if (seen.has(k)) return false; seen.add(k); return true; });
+};
+
+/** every distinct signed permutation of a pattern */
+const orbit = (v: number[]) => {
+  const seen = new Set<string>(), out: number[][] = [];
+  for (const p of perms(v)) for (const s of signs(p)) {
+    const k = s.map(x => x.toFixed(6)).join(",");
+    if (!seen.has(k)) { seen.add(k); out.push(s); }
+  }
+  return out;
+};
+
+/** cyclic shifts only — the icosahedral families are not fully permutable */
+const cyclic = (v: number[]) => {
+  const out: number[][] = [];
+  const seen = new Set<string>();
+  for (let r = 0; r < v.length; r++) {
+    const p = v.map((_, i) => v[(i + r) % v.length]);
+    for (const s of signs(p)) {
+      const k = s.map(x => x.toFixed(6)).join(",");
+      if (!seen.has(k)) { seen.add(k); out.push(s); }
+    }
+  }
+  return out;
+};
+
+const FACE = orbit([1, 0, 0]);                       // 6
+const EDGE = orbit([1, 1, 0]);                       // 12  — also FCC nearest neighbours
+const CORNER = orbit([1, 1, 1]);                     // 8   — also BCC nearest neighbours
+
+const ICO12 = cyclic([0, 1, PHI]);                   // icosahedron vertices
+const DOD20 = [...orbit([1, 1, 1]), ...cyclic([0, 1 / PHI, PHI])];
+const ICOSIDOD30 = [...orbit([1, 0, 0]).map(v => v.map(x => x * PHI)),
+  ...cyclic([1 / 2, PHI / 2, PHI * PHI / 2])];
+
+const FCHC24 = orbit([1, 1, 0, 0]);                  // the 24-cell, 4D, all length √2
+const CROSS4 = orbit([1, 0, 0, 0]);                  // 4D axes, 8
+const CUBE4 = signs([1, 1, 1, 1]);                   // 4D hypercube corners, 16
+
+const E8: number[][] = (() => {
+  const out: number[][] = [];
+  for (let i = 0; i < 8; i++) for (let j = i + 1; j < 8; j++)
+    for (const a of [1, -1]) for (const b of [1, -1]) {
+      const v = new Array(8).fill(0); v[i] = a; v[j] = b; out.push(v);
+    }
+  for (let m = 0; m < 256; m++) {
+    let neg = 0;
+    const v = new Array(8).fill(0).map((_, i) => { const s = (m >> i) & 1; neg += s; return s ? -0.5 : 0.5; });
+    if (neg % 2 === 0) out.push(v);
+  }
+  return out;
+})();
+
+const wOf = (c: number[][], f: (v: number[]) => number) => c.map(f);
+
+const SETS: Space[] = [
+  { name: "cubic 6 (faces)", dim: 3, c: FACE, note: "simple cubic, nearest neighbours" },
+  { name: "cubic 12 (edges)", dim: 3, c: EDGE, note: "= FCC nearest neighbours, all length √2" },
+  { name: "cubic 8 (corners)", dim: 3, c: CORNER, note: "= BCC nearest neighbours, all length √3" },
+  { name: "cubic 18", dim: 3, c: [...FACE, ...EDGE], note: "faces and edges, unweighted" },
+  {
+    name: "cubic 18, D3Q19 w", dim: 3, c: [...FACE, ...EDGE],
+    w: [...FACE.map(() => 1 / 18), ...EDGE.map(() => 1 / 36)],
+    note: "the lattice-Boltzmann weights, which exist for exactly this reason",
+  },
+  { name: "cubic 26", dim: 3, c: [...FACE, ...EDGE, ...CORNER], note: "the model's own neighbourhood" },
+  {
+    name: "cubic 26, D3Q27 w", dim: 3, c: [...FACE, ...EDGE, ...CORNER],
+    w: [...FACE.map(() => 2 / 27), ...EDGE.map(() => 1 / 54), ...CORNER.map(() => 1 / 216)],
+    note: "and the 27-velocity weights",
+  },
+  {
+    name: "cubic 26, 1/|c|", dim: 3, c: [...FACE, ...EDGE, ...CORNER],
+    w: wOf([...FACE, ...EDGE, ...CORNER], v => 1 / Math.hypot(...v)),
+    note: "a plausible-looking guess, included to show that plausible is not enough",
+  },
+  { name: "icosahedron 12", dim: 3, c: ICO12, note: "six axes — NOT a crystal lattice" },
+  { name: "dodecahedron 20", dim: 3, c: DOD20, note: "ten axes, icosahedral symmetry" },
+  { name: "icosidodeca 30", dim: 3, c: ICOSIDOD30, note: "fifteen axes, icosahedral symmetry" },
+  { name: "ico 12+20+30", dim: 3, c: [...ICO12, ...DOD20, ...ICOSIDOD30], note: "all three shells at once" },
+  { name: "4D cross 8", dim: 4, c: CROSS4, note: "4D simple cubic" },
+  { name: "4D cube 16", dim: 4, c: CUBE4, note: "4D hypercube corners" },
+  { name: "4D 24-cell (FCHC)", dim: 4, c: FCHC24, note: "24 neighbours, ALL the same length" },
+  { name: "4D 8+16", dim: 4, c: [...CROSS4, ...CUBE4], note: "the dual 24-cell, mixed lengths" },
+  { name: "8D E8 roots 240", dim: 8, c: E8, note: "the densest thing there is in eight dimensions" },
+];
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the moments along a direction
+
+const dot = (a: number[], b: number[]) => a.reduce((s, v, i) => s + v * b[i], 0);
+
+/** a spread of unit directions to test against, deterministic so runs compare */
+const probes = (dim: number, n = 4000) => {
+  let seed = 12345;
+  const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+  const out: number[][] = [];
+  while (out.length < n) {
+    const v = new Array(dim).fill(0).map(() => {
+      let u = 0, s = 0;
+      do { u = 2 * rnd() - 1; s = 2 * rnd() - 1; } while (u * u + s * s >= 1 || u * u + s * s === 0);
+      return u * Math.sqrt(-2 * Math.log(u * u + s * s) / (u * u + s * s));
+    });
+    const L = Math.hypot(...v);
+    if (L > 1e-9) out.push(v.map(x => x / L));
+  }
+  return out;
+};
+
+/** max/min of Σ w (c·n̂)^p over the probe directions — 1 exactly means no grain */
+const moment = (S: Space, p: number, ns: number[][]) => {
+  const w = S.w ?? S.c.map(() => 1 / S.c.length);
+  let lo = Infinity, hi = -Infinity;
+  for (const n of ns) {
+    let m = 0;
+    for (let i = 0; i < S.c.length; i++) m += w[i] * Math.pow(dot(S.c[i], n), p);
+    lo = Math.min(lo, m); hi = Math.max(hi, m);
+  }
+  return { lo, hi, ratio: hi / lo };
+};
+
+const flag = (r: number) => Math.abs(r - 1) < 1e-9 ? "  exact" : "  " + ((r - 1) * 100).toFixed(2) + "%";
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log("WHICH SPACE GIVES A SPHERE\n");
+console.log("  S(n̂) = Σ w (c·n̂)²   and   Q(n̂) = Σ w (c·n̂)⁴, over 4000 directions.");
+console.log("  The column is max/min − 1: how much the space can tell one direction");
+console.log("  from another at that order. `exact` means it cannot, to machine");
+console.log("  precision, and that is the whole of the condition.\n");
+
+console.log("─".repeat(88));
+console.log("  space                    n     dim    rank 2     rank 4     rank 6   design");
+for (const S of SETS) {
+  const ns = probes(S.dim);
+  const m2 = moment(S, 2, ns), m4 = moment(S, 4, ns), m6 = moment(S, 6, ns);
+  const strength = Math.abs(m6.ratio - 1) < 1e-9 ? "≥ 7"
+    : Math.abs(m4.ratio - 1) < 1e-9 ? "5"
+      : Math.abs(m2.ratio - 1) < 1e-9 ? "3" : "1";
+  console.log("  " + S.name.padEnd(22) + String(S.c.length).padStart(5)
+    + String(S.dim).padStart(7) + flag(m2.ratio).padStart(11)
+    + flag(m4.ratio).padStart(11) + flag(m6.ratio).padStart(11)
+    + strength.padStart(8));
+}
+
+console.log("\n  and what each one is:");
+for (const S of SETS) console.log("    " + S.name.padEnd(22) + S.note);
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+// ─────────────────────────────────────────────────────────────────────────────
+// how much freedom there actually is, and how far up you can push it
+
+console.log("\n" + "─".repeat(88));
+console.log("HOW MUCH IS FORCED, AND HOW FAR UP IT CAN BE PUSHED\n");
+console.log("  A cubic-symmetric neighbour set has very few invariants, and that is what");
+console.log("  makes this tractable. At rank 4 the moment along n̂ can only be");
+console.log("");
+console.log("      Q(n̂) = A + B · Σ nᵢ⁴");
+console.log("");
+console.log("  because Σnᵢ² = 1 uses up everything else, so `isotropic at rank 4` is the");
+console.log("  SINGLE equation B = 0 — not three. With three orbits and one normalisation");
+console.log("  that leaves a ONE-PARAMETER FAMILY of weightings, which is why D3Q19 and");
+console.log("  D3Q27 both came out exact above: they are two points on the same line, not");
+console.log("  two derivations of the same answer. Rank 6 adds two more invariants, and");
+console.log("  three orbits cannot kill those as well — which is what the 49.99% and");
+console.log("  59.25% in the table are.");
+console.log();
+console.log("  So the real question is not which weights, it is HOW MANY SHELLS. Below is");
+console.log("  a sweep of every subset of the first nine cubic shells, scored by whether");
+console.log("  non-negative weights exist that are exact at rank 4, and then at rank 6.\n");
+
+const SHELLS: number[][][] = [
+  orbit([1, 0, 0]), orbit([1, 1, 0]), orbit([1, 1, 1]),
+  orbit([2, 0, 0]), orbit([2, 1, 0]), orbit([2, 1, 1]),
+  orbit([2, 2, 0]), orbit([2, 2, 1]), orbit([3, 0, 0]),
+];
+const SHELL_NAME = ["100", "110", "111", "200", "210", "211", "220", "221", "300"];
+
+/** row-reduce in place and return the pivot columns */
+const rref = (M: number[][]) => {
+  const rows = M.length, cols = M[0].length, piv: number[] = [];
+  let r = 0;
+  for (let c = 0; c < cols && r < rows; c++) {
+    let best = r;
+    for (let i = r; i < rows; i++) if (Math.abs(M[i][c]) > Math.abs(M[best][c])) best = i;
+    if (Math.abs(M[best][c]) < 1e-9) continue;
+    [M[r], M[best]] = [M[best], M[r]];
+    const d = M[r][c];
+    for (let j = c; j < cols; j++) M[r][j] /= d;
+    for (let i = 0; i < rows; i++) {
+      if (i === r) continue;
+      const f = M[i][c];
+      if (!f) continue;
+      for (let j = c; j < cols; j++) M[i][j] -= f * M[r][j];
+    }
+    piv.push(c); r++;
+  }
+  return piv;
+};
+
+/** a basis for {w : moments of every rank in `ranks` are direction-independent} */
+const nullFor = (sh: number[][][], ranks: number[], ns: number[][]) => {
+  const k = sh.length, rows: number[][] = [];
+  for (const p of ranks) {
+    const base = sh.map(o => o.reduce((s, c) => s + Math.pow(dot(c, ns[0]), p), 0));
+    for (let j = 1; j < ns.length; j++)
+      rows.push(sh.map((o, i) => o.reduce((s, c) => s + Math.pow(dot(c, ns[j]), p), 0) - base[i]));
+  }
+  const M = rows.map(r => r.slice());
+  const piv = rref(M);
+  const free = [...Array(k).keys()].filter(c => !piv.includes(c));
+  return free.map(f => {
+    const v = new Array(k).fill(0);
+    v[f] = 1;
+    piv.forEach((c, i) => { v[c] = -M[i][f]; });
+    return v;
+  });
+};
+
+/** is there a non-negative, non-zero vector in the span? */
+const positiveIn = (basis: number[][]) => {
+  if (!basis.length) return null;
+  const ok = (v: number[]) => v.some(x => x > 1e-9) && v.every(x => x > -1e-9);
+  for (const v of basis) { if (ok(v)) return v; if (ok(v.map(x => -x))) return v.map(x => -x); }
+  if (basis.length === 1) return null;
+  for (let t = 0; t <= 200; t++) {                 // crude sweep of the 2-parameter case
+    const f = t / 200;
+    for (const sgn of [1, -1]) {
+      const v = basis[0].map((x, i) => sgn * (f * x + (1 - f) * basis[1][i]));
+      if (ok(v)) return v;
+    }
+  }
+  return null;
+};
+
+{
+  const NS = probes(3, 220);
+  const found: { rank: number, shells: number[], w: number[] }[] = [];
+
+  for (let mask = 1; mask < (1 << SHELLS.length); mask++) {
+    const idx = [...Array(SHELLS.length).keys()].filter(i => mask & (1 << i));
+    if (idx.length > 5) continue;
+    const sh = idx.map(i => SHELLS[i]);
+    for (const upto of [6, 4]) {
+      const ranks = upto === 6 ? [4, 6] : [4];
+      const w = positiveIn(nullFor(sh, ranks, NS));
+      if (w) { found.push({ rank: upto, shells: idx, w }); break; }
+    }
+  }
+
+  const at = (r: number) => found.filter(f => f.rank === r)
+    .sort((a, b) => a.shells.length - b.shells.length);
+
+  /** integer ratios, for reading the weighting rather than squinting at decimals */
+  const ratios = (w: number[]) => {
+    const nz = w.filter(x => x > 1e-9);
+    const m = Math.min(...nz);
+    const scaled = w.map(x => x / m);
+    for (let k = 1; k <= 64; k++)
+      if (scaled.every(x => Math.abs(x * k - Math.round(x * k)) < 1e-6))
+        return scaled.map(x => Math.round(x * k)).join(" : ");
+    return scaled.map(x => x.toFixed(3)).join(" : ");
+  };
+
+  const show = (title: string, list: typeof found, n: number) => {
+    console.log("  " + title);
+    const clean = list.filter(f => f.w.every(x => x > 1e-9));   // a zero weight is a
+    if (!clean.length) { console.log("    none\n"); return; }   // smaller set already listed
+    for (const f of clean.slice(0, n)) {
+      const dirs = f.shells.reduce((a, i) => a + SHELLS[i].length, 0);
+      const mass = f.shells.reduce((a, i, j) => a + SHELLS[i].length * f.w[j], 0);
+
+      // VERIFIED BY MEASUREMENT, not by trusting the null space: rebuild the
+      // neighbour set with these weights and read the moments off it directly.
+      const c: number[][] = [], w: number[] = [];
+      f.shells.forEach((i, j) => SHELLS[i].forEach(v => { c.push(v); w.push(f.w[j] / mass); }));
+      const V: Space = { name: "", dim: 3, c, w, note: "" };
+      const ns = probes(3);
+      const d = [2, 4, 6].map(p => moment(V, p, ns).ratio);
+
+      console.log("    " + f.shells.map(i => SHELL_NAME[i]).join(" + ").padEnd(24)
+        + String(dirs).padStart(4) + " dirs   " + ratios(f.w).padEnd(18)
+        + "  rank 2/4/6: " + d.map(flag).join(""));
+    }
+    console.log();
+  };
+
+  show("exact at rank 4 — smallest shell sets:", at(4), 6);
+  show("exact at rank 4 AND rank 6 — smallest shell sets:", at(6), 6);
+
+  console.log("  the count is the point. Rank 4 is cheap: two shells will do it and the");
+  console.log("  model's own three already can. Rank 6 costs more shells, i.e. a");
+  console.log("  NEIGHBOURHOOD THAT REACHES FURTHER THAN ONE CELL — which is a real");
+  console.log("  statement about the model and not a free choice: to be blind to");
+  console.log("  direction at sixth order a charge has to be able to step two cells.\n");
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// and how big the leftover is, which depends on what is propagating
+
+console.log("─".repeat(88));
+console.log("A RAY HAS NO WAVELENGTH AND A WAVE DOES — which decides everything\n");
+console.log("  The grain measured above is a property of the STEP, so it enters anything");
+console.log("  propagating on the lattice at a size set by how many steps that thing is");
+console.log("  spread over. For a single charge with a remembered heading the answer is");
+console.log("  `one`, and there is no suppression at all — which is the veins, and why");
+console.log("  they never thinned out with distance. For a disturbance of wavelength λ");
+console.log("  the moments enter the dispersion as powers of (Δx/λ):\n");
+console.log("      rank 2 isotropic → the leading term is already round");
+console.log("      rank 4 grain     → Δc/c ~ (2πΔx/λ)²");
+console.log("      rank 6 grain     → Δc/c ~ (2πΔx/λ)⁴   once rank 4 is exact\n");
+
+{
+  const LP = 1.616255e-35;
+  const rows: [string, number][] = [
+    ["visible light, 500 nm", 500e-9],
+    ["gamma ray, 1 MeV", 1.24e-12],
+    ["LHC-scale, 14 TeV", 8.9e-20],
+    ["one Planck length", LP],
+  ];
+  console.log("    probe                        λ (m)     (2πΔx/λ)²     (2πΔx/λ)⁴");
+  for (const [nm, lam] of rows) {
+    const e = 2 * Math.PI * LP / lam;
+    console.log("    " + nm.padEnd(24) + lam.toExponential(2).padStart(10)
+      + (e * e).toExponential(2).padStart(14) + Math.pow(e, 4).toExponential(2).padStart(14));
+  }
+}
+console.log("\n  so a WAVE of any wavelength anyone can make is spherical to fifty-odd");
+console.log("  decimal places on the plain cubic lattice, and the design weights buy a");
+console.log("  further hundred that nobody needs. The lattice was never the problem.\n");
+
+console.log("\n" + "─".repeat(88));
+console.log("WHAT IT MEANS FOR THE MODEL\n");
+console.log("  · rank 2 is free — nearly every set has it, which is exactly why the");
+console.log("    model's 1/r² came out right and why nothing here ever noticed anything.");
+console.log("    THE GRAIN IS AT RANK 4, the first order at which a cube differs from a");
+console.log("    sphere, and that is what the veins are.");
+console.log();
+console.log("  · but the cubic lattice is NOT the problem. Weighted, the model's own 26");
+console.log("    directions are exact at rank 4 already. And the weighting is not a fit:");
+console.log("    isotropy at rank 4 is the single condition B = 0, so it fixes the");
+console.log("    weights up to one parameter, and D3Q19 and D3Q27 are two points on that");
+console.log("    line. The unweighted set is off by 66.65%; that is the whole defect.");
+console.log();
+console.log("  · going further costs shells rather than cleverness, and 26 directions");
+console.log("    are STILL enough if they are the right ones: 111 + 200 + 220 weighted");
+console.log("    16 : 10 : 1 is exact at ranks 2, 4 and 6 with exactly the count the");
+console.log("    model already carries. Keeping the present neighbourhood and adding");
+console.log("    only the six two-cell axis steps does it too, at 16 : 8 : 2 : 1.");
+console.log();
+console.log("  · in three dimensions the icosahedral sets are exact at rank 4 with only");
+console.log("    twelve directions, fewer than the model uses — but they do not tile, so");
+console.log("    the space would have to be a quasilattice. The 4D 24-cell is exact and");
+console.log("    DOES tile, with all 24 neighbours the same length. E8 is exact through");
+console.log("    rank 6. None of these is needed, but they are what `as symmetric as");
+console.log("    possible` actually looks like.");
+console.log();
+console.log("  AND THE ANSWER TO WHY LIGHT WOULD WANDER.");
+console.log();
+console.log("  A design condition is a statement about an AVERAGE over the neighbours.");
+console.log("  A charge going straight never takes that average — it sees one direction");
+console.log("  for its whole life, which is why a ray is veined and why the veins never");
+console.log("  thinned out with distance. A charge that deviates DOES take it, and the");
+console.log("  average is round. So the wander is not a correction bolted onto straight-");
+console.log("  line motion to fix its shape; it is the only thing that lets a discrete");
+console.log("  space have a shape at all.");
+console.log();
+console.log("  And it needs no rate. What the earlier files kept trying to tune was `how");
+console.log("  often` — which cannot work, because roundness is d − 1 conditions and a");
+console.log("  rate is one knob. What actually decides it is `among what, in what");
+console.log("  proportion`, and that is a property of the space, fixed by the demand");
+console.log("  that no direction be distinguishable. Movement is: step to a neighbour,");
+console.log("  chosen with the weights the space forces. Nothing else.");
+console.log();
+console.log("  The last table is why this is not a small correction to what is there");
+console.log("  now. For a WAVE the residual grain is suppressed by (Δx/λ)², so light of");
+console.log("  any wavelength anyone can produce is spherical to fifty decimal places");
+console.log("  even unweighted. For a RAY it is not suppressed at all. The model's");
+console.log("  problem was never the cubic lattice — it was treating propagation as a");
+console.log("  charge that remembers where it was going.");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
index 4d4e140..5e97c5f 100755
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
@@ -31,6 +31,7 @@ ORDER=(
   recon which138 accum accumulate asym
   pulses magnets coulomb moment dipole poles ordering budget tradeoff scale maxwell
   nopolarity
+  turns ways veins cones veined lattices wave gas
 )
 
 if [ "${1:-}" = "--list" ]; then printf '%s\n' "${ORDER[@]}"; exit 0; fi
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/veined.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/veined.ts
new file mode 100644
index 0000000..d5991a1
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/veined.ts
@@ -0,0 +1,325 @@
+/**
+ * WHAT THE LAWS LOOK LIKE IF THE FIELD IS VEINED — every prediction re-read with
+ * the angular structure left in, instead of averaged over a shell.
+ *
+ * `chance(m,r)` divides by 4πr², a shell average, and every number the article
+ * publishes is read off that. `veins` measured what the average is an average
+ * OVER: ridges along the lattice headings and thin wedges between them, peak
+ * over mean about 4.2 at the rounding w, scale free in radius. Nothing that has
+ * been tested so far can see it, because every existing test is a RADIAL number
+ * and the angular structure integrates out of all of them.
+ *
+ * So the question this file asks is the one that was left open: if the field
+ * really is veined, what does each law become, and what does each measurement
+ * then say about it. The force law becomes
+ *
+ *     g(r, θ) = F(θ) · GM/r²        with ⟨F⟩ = 1 over angle
+ *
+ * — the radial exponent is untouched, the shell average is untouched, and what
+ * is new is that F swings by a factor of a few DEPENDING ON WHICH WAY YOU LOOK,
+ * with the pattern fixed to the lattice rather than to the source.
+ *
+ * THE ONE THING THAT SOFTENS IT is source extent. A ridge points along the
+ * lattice, not away from the emitter, so ridges from different parts of an
+ * extended body are PARALLEL and stack rather than cancel — but a body of
+ * radius Rs seen from distance r does smooth structure finer than Rs/r. That is
+ * measured here rather than assumed, and it is the whole reason the answer
+ * differs between the Solar System and a galaxy: the Sun at one au is a point
+ * and a disc at one effective radius is not.
+ *
+ * Run: ./run.sh veined
+ */
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the lattice and the shipped rule, own copy
+
+const DIRS_V: [number, number][] = [
+  [1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1],
+];
+const SHIP_W_V = 2 * (1 - Math.SQRT1_2);
+
+const waysOfV = (h: [number, number]): [number, number][] => {
+  const out: [number, number][] = [];
+  for (let a = 0; a < 2; a++) {
+    if (h[a]) out.push(a === 0 ? [h[0], 0] : [0, h[1]]);
+    else for (const s of [1, -1] as const) out.push(a === 0 ? [s, h[1]] : [h[0], s]);
+  }
+  return out;
+};
+
+const kernelOfV = (h: [number, number], w: number): [number, number][] => {
+  const idx = (d: [number, number]) => DIRS_V.findIndex(e => e[0] === d[0] && e[1] === d[1]);
+  const acc = new Map<number, number>();
+  acc.set(idx(h), 1 - w);
+  const alt = waysOfV(h);
+  for (const d of alt) acc.set(idx(d), (acc.get(idx(d)) ?? 0) + w / alt.length);
+  return [...acc].filter(([, p]) => p > 0);
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the field of a body of radius Rs, in cells
+
+const NB_V = 360;
+const angleBinV = (x: number, y: number) =>
+  Math.min(NB_V - 1, Math.floor(((Math.atan2(y, x) + 2 * Math.PI) % (2 * Math.PI)) / (2 * Math.PI) * NB_V));
+
+/**
+ * Steady-state occupancy from every cell of a disk of radius Rs, each pulsing
+ * into all eight headings every tick — a body radiating isotropically. The
+ * heading a charge left with is remembered and only the step deviates, which is
+ * what `discrete.ts` does and what `veins` showed is required for anything to
+ * propagate ballistically at all.
+ */
+const fieldOf = (T: number, Rs: number, w = SHIP_W_V) => {
+  const N = 2 * T + 3, o = T + 1, S = N * N;
+  let cur = new Float64Array(S * 8), nxt = new Float64Array(S * 8);
+  const occ = new Float64Array(S);
+  const K = DIRS_V.map(h => kernelOfV(h, w));
+
+  const emit: [number, number][] = [];
+  for (let y = -Rs; y <= Rs; y++) for (let x = -Rs; x <= Rs; x++)
+    if (x * x + y * y <= Rs * Rs) emit.push([x, y]);
+  const inj = 1 / (8 * emit.length);
+
+  for (let t = 1; t <= T; t++) {
+    nxt.fill(0);
+    for (let y = 1; y < N - 1; y++) for (let x = 1; x < N - 1; x++) {
+      const c = (y * N + x) * 8;
+      for (let h = 0; h < 8; h++) {
+        const v = cur[c + h];
+        if (v === 0) continue;
+        for (const [i, p] of K[h])
+          nxt[(((y + DIRS_V[i][1]) * N + (x + DIRS_V[i][0])) * 8) + h] += v * p;
+      }
+    }
+    for (const [ex, ey] of emit)
+      for (let h = 0; h < 8; h++) nxt[(((o + ey) * N + (o + ex)) * 8) + h] += inj;
+    const tmp = cur; cur = nxt; nxt = tmp;
+    for (let k = 0; k < S; k++) {
+      let s = 0;
+      for (let h = 0; h < 8; h++) s += cur[k * 8 + h];
+      occ[k] += s;
+    }
+  }
+  return { T, N, o, occ, emit: emit.length };
+};
+
+/** F(θ) at radius r: the field over its own mean at that radius, ⟨F⟩ = 1 */
+const Ftheta = (f: ReturnType<typeof fieldOf>, r: number, dr = 1.5) => {
+  const sum = new Float64Array(NB_V), cnt = new Float64Array(NB_V);
+  for (let y = -f.T; y <= f.T; y++) for (let x = -f.T; x <= f.T; x++) {
+    const R = Math.hypot(x, y);
+    if (R < r - dr || R > r + dr) continue;
+    const b = angleBinV(x, y);
+    sum[b] += f.occ[(y + f.o) * f.N + (x + f.o)]; cnt[b] += 1;
+  }
+  const out: number[] = [];
+  for (let b = 0; b < NB_V; b++) if (cnt[b] > 0) out.push(sum[b] / cnt[b]);
+  const m = out.reduce((a, c) => a + c, 0) / out.length;
+  return out.map(v => v / m);
+};
+
+const spreadV = (F: number[]) => {
+  const s = F.slice().sort((a, b) => a - b);
+  const q = (f: number) => s[Math.round(f * (s.length - 1))];
+  return { peak: q(1), dead: q(0), p95: q(0.95), p05: q(0.05),
+    rms: Math.sqrt(F.reduce((a, v) => a + (v - 1) ** 2, 0) / F.length) };
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// how much source extent buys
+
+console.log("WHAT THE LAWS LOOK LIKE IF THE FIELD IS VEINED\n");
+console.log("─".repeat(84));
+console.log("1. HOW MUCH AN EXTENDED SOURCE SMOOTHS IT");
+console.log("   F(θ) is the field over its own shell mean, so ⟨F⟩ = 1 by construction");
+console.log("   and everything below is purely the angular structure the shell average");
+console.log("   is hiding. Rs/r is the body's radius over the distance it is seen from.\n");
+
+const T = 120, RPROBE = 55;
+
+/**
+ * Sampled rather than fitted. An exponential in Rs/r was tried first and is not
+ * good enough to hang a table on — the curve is much steeper than exponential
+ * near zero and much flatter past a half, and one decay constant misses by 0.38
+ * on a range of 3.3. So the curve is measured on a grid and read off by
+ * interpolating log(peak − 1), which is smooth in Rs/r and exact at every
+ * sampled point by construction.
+ */
+const XS = [0, 1, 3, 5, 8, 11, 14, 17, 22, 28, 36, 44, 55];
+const CURVE: { x: number, peak: number, p95: number, p05: number, dead: number }[] = [];
+
+console.log("    Rs/r     peak      p95      p05     dead      rms");
+for (const Rs of XS) {
+  const F = Ftheta(fieldOf(T, Rs), RPROBE);
+  const st = spreadV(F);
+  CURVE.push({ x: Rs / RPROBE, peak: st.peak, p95: st.p95, p05: st.p05, dead: st.dead });
+  console.log("  " + (Rs / RPROBE).toFixed(3).padStart(7)
+    + [st.peak, st.p95, st.p05, st.dead, st.rms].map(v => v.toFixed(4).padStart(9)).join(""));
+}
+
+/** read the curve at any Rs/r, interpolating log(v − 1) for the ridge side and
+ *  log(1 − v) for the wedge side, so both approach 1 smoothly and neither can
+ *  overshoot past it */
+const readAt = (x: number, key: "peak" | "p95" | "p05" | "dead") => {
+  if (x <= CURVE[0].x) return CURVE[0][key];
+  const last = CURVE[CURVE.length - 1];
+  if (x >= last.x) return last[key];
+  let i = 0;
+  while (i < CURVE.length - 2 && CURVE[i + 1].x < x) i++;
+  const A = CURVE[i], B = CURVE[i + 1];
+  const f = (x - A.x) / (B.x - A.x);
+  const up = A[key] > 1;
+  const g = (v: number) => Math.log(Math.max(up ? v - 1 : 1 - v, 1e-12));
+  const lv = g(A[key]) + f * (g(B[key]) - g(A[key]));
+  return up ? 1 + Math.exp(lv) : 1 - Math.exp(lv);
+};
+
+console.log("\n  a point source keeps the whole " + CURVE[0].peak.toFixed(2) + "× on the ridge and drops to "
+  + CURVE[0].p05.toFixed(4) + " at the fifth");
+console.log("  percentile — the wedges between the headings are not merely thin, they");
+console.log("  are EMPTY. By Rs/r = 1 the whole structure is down to "
+  + readAt(1, "peak").toFixed(3) + "×.");
+console.log();
+console.log("  the wiggle around Rs/r ≈ 0.5 is commensurability, not noise: a disk whose");
+console.log("  radius is a simple fraction of the probe radius lines its own ridges up");
+console.log("  with the ones it is smoothing. It is under a tenth of the range and does");
+console.log("  not touch any conclusion, but it is why the column is not monotone.\n");
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the systems
+
+console.log("─".repeat(84));
+console.log("2. EVERY MEASUREMENT, RE-READ WITH F(θ) LEFT IN\n");
+
+type Sys = {
+  name: string;
+  Rs: number; r: number;              // same units, whatever they are
+  /** how the observable responds to g → F·g */
+  law: "newton" | "mond" | "boost";
+  obs: string;
+  bound: number;                      // fractional precision of the measurement
+  ref: string;
+};
+
+const SYS: Sys[] = [
+  { name: "Earth's orbit", Rs: 6.957e8, r: 1.496e11, law: "newton",
+    obs: "g from the Sun, over one year", bound: 1e-10,
+    ref: "planetary ephemerides (INPOP/DE), anomalous accel. ≲ 10⁻¹⁰ of Newton" },
+  { name: "Cassini light bend", Rs: 6.957e8, r: 1.6 * 6.957e8, law: "newton",
+    obs: "γ, the deflection coefficient", bound: 2.3e-5,
+    ref: "Bertotti, Iess & Tortora 2003, Nature 425:374 — γ = 1+(2.1±2.3)·10⁻⁵" },
+  { name: "S2 around Sgr A*", Rs: 1.2e10, r: 1.8e13, law: "newton",
+    obs: "orbital precession", bound: 0.1,
+    ref: "GRAVITY 2020, A&A 636:L5 — Schwarzschild precession to 10%" },
+  { name: "Milky Way v_c(R)", Rs: 3, r: 10, law: "mond",
+    obs: "circular speed at 10 kpc, by azimuth", bound: 0.013,
+    ref: "Eilers et al. 2019, ApJ 871:120 — v_c to ≈3 km/s of 230" },
+  { name: "Genzel discs", Rs: 5, r: 5.5, law: "boost",
+    obs: "v/v_baryons inside one Re", bound: 0.05,
+    ref: "Genzel et al. 2017, Nature 543:397 — f_DM(<Re) < 0.2" },
+  { name: "BTFR scatter", Rs: 4, r: 20, law: "mond",
+    obs: "flat rotation speed at fixed baryonic mass", bound: 0.021,
+    ref: "Lelli et al. 2019, MNRAS 484:3267 — 0.09 dex ≈ 2.1% in v" },
+  { name: "wide binaries", Rs: 7e8, r: 3e15, law: "newton",
+    obs: "relative acceleration", bound: 0.2,
+    ref: "Gaia wide-binary samples — the deep-MOND regime, ≈20% level" },
+];
+
+/** how a fractional change in g shows up in each observable */
+const respond = (law: Sys["law"], F: number) =>
+  law === "newton" ? F                    // g ∝ F
+    : law === "mond" ? Math.pow(F, 0.25)  // v ∝ g^(1/4) in the deep regime
+      : Math.pow(F, 0.25);                // the boost, near enough, inside Re
+
+console.log("  system              Rs/r    F p95    F p05   predicted   measured to    verdict");
+for (const s of SYS) {
+  const x = s.Rs / s.r;
+  const hi = readAt(x, "p95"), lo = readAt(x, "p05");
+  const swing = respond(s.law, hi) - respond(s.law, lo);
+  const over = swing / s.bound;
+  console.log("  " + s.name.padEnd(20) + x.toExponential(1).padStart(8)
+    + hi.toFixed(3).padStart(9) + lo.toFixed(3).padStart(9)
+    + (swing * 100).toFixed(1).padStart(10) + "%"
+    + (s.bound * 100).toPrecision(2).padStart(12) + "%"
+    + ("  " + (over > 1 ? "× " + (over >= 100 ? over.toExponential(1) : over.toFixed(0)) + " over"
+      : "within")).padStart(14));
+}
+console.log("\n  `predicted` is the swing in the observable between the 95th and 5th");
+console.log("  percentile direction — how much the answer changes with which way you");
+console.log("  happen to be looking. It is a swing and not an offset, so it cannot be");
+console.log("  absorbed into a redefinition of G or of a mass.");
+console.log();
+for (const s of SYS) console.log("    " + s.name.padEnd(20) + s.ref);
+
+console.log("\n  the split is entirely Rs/r, and it is worth stating plainly: THE VEINS");
+console.log("  ARE NOT REFUTED BY GALAXIES. A disc seen at one effective radius has");
+console.log("  Rs/r ≈ 1 and the structure is smoothed to a few per cent, which is why");
+console.log("  no rotation-curve test in this directory would ever have caught it. They");
+console.log("  are refuted by THE SOLAR SYSTEM, where the Sun at one au is a point");
+console.log("  source to four parts in a thousand and the predicted swing in g over a");
+console.log("  year is a factor of a few against an ephemeris good to 10⁻¹⁰.\n");
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the Genzel discs specifically, since that is the panel
+
+console.log("─".repeat(84));
+console.log("3. THE GENZEL DISCS, DISC BY DISC");
+console.log("   what the boost becomes when the ridge and the wedge are read separately");
+console.log("   rather than averaged. Re from Table 1; the baryons sit inside about one");
+console.log("   Re, so Rs/r is near 1 and this is the most forgiving case there is.\n");
+
+const DISCS: [string, number, number][] = [   // name, z, Re (kpc)
+  ["COS4_01351", 0.854, 8.2], ["D3a_6397", 1.500, 7.4], ["GS4_43501", 1.613, 4.9],
+  ["zC_406690", 2.196, 5.5], ["zC_400569", 2.242, 3.3],
+];
+
+const sd = CURVE[CURVE.length - 1];           // Rs/r = 1, the disc case
+console.log("  at Rs/r = 1:  peak " + sd.peak.toFixed(4) + "   p95 " + sd.p95.toFixed(4)
+  + "   p05 " + sd.p05.toFixed(4) + "   dead " + sd.dead.toFixed(4));
+console.log("  boost multiplier = F^(1/4):  ridge ×" + Math.pow(sd.peak, 0.25).toFixed(4)
+  + "   wedge ×" + Math.pow(sd.dead, 0.25).toFixed(4) + "\n");
+
+console.log("  disc            z      Re    boost   ridge   wedge   allowed  still over?");
+const C = 299792458, KPC = 3.0856775814913673e19, MSUN = 1.98892e30, G = 6.674e-11;
+const H0 = 70.9e3 / 3.0856775814913673e22, A0 = C * H0 / (2 * Math.PI);
+const MASS: Record<string, [number, number]> = {   // logMs, fgas
+  COS4_01351: [11.07, 0.35], D3a_6397: [11.07, 0.45], GS4_43501: [10.71, 0.50],
+  zC_406690: [10.62, 0.55], zC_400569: [11.07, 0.45],
+};
+for (const [name, z, Re] of DISCS) {
+  const [logMs, fgas] = MASS[name];
+  const M = Math.pow(10, logMs) * MSUN / (1 - fgas);
+  const a0 = A0 * (1 + z);
+  const boost = (F: number) => {
+    const gN = F * G * M / Math.pow(Re * KPC, 2);
+    return Math.sqrt((gN / 2 + Math.sqrt(gN * gN / 4 + gN * a0)) / gN);
+  };
+  const b = boost(1), hi = boost(sd.peak), lo = boost(sd.dead);
+  console.log("  " + name.padEnd(14) + z.toFixed(2).padStart(5) + Re.toFixed(1).padStart(7)
+    + b.toFixed(3).padStart(8) + hi.toFixed(3).padStart(8) + lo.toFixed(3).padStart(8)
+    + "    1.120" + (lo > 1.12 ? "   yes, all of it" : hi > 1.12 ? "   only the ridge" : "   no"));
+}
+console.log("\n  note which way round it goes: the RIDGE is the direction with the LOWER");
+console.log("  boost, because a stronger g_N is further from the deep-MOND regime and so");
+console.log("  gets less of a lift. The ridge therefore moves each disc DOWN towards the");
+console.log("  allowed line and the wedge moves it up — and even so, four of the five");
+console.log("  clear 1.120 on both sides. The angular structure is worth about ±0.5% on");
+console.log("  a boost that has to fall by 5%, so it is not a spare parameter that could");
+console.log("  have absorbed the high-redshift problem. It widens the dots and changes");
+console.log("  nothing.\n");
+
+console.log("─".repeat(84));
+console.log("WHAT THIS SETTLES");
+console.log("  · the radial law is untouched: ⟨F⟩ = 1, so 1/r² and every shell average");
+console.log("    survive exactly, which is why nothing in this directory saw it");
+console.log("  · the new content is azimuthal, fixed to the lattice rather than to the");
+console.log("    source, and therefore MODULATED BY THE EARTH'S OWN MOTION");
+console.log("  · extended sources smooth it, and only extended sources do: " + CURVE[0].peak.toFixed(2)
+  + "× at");
+console.log("    Rs/r = 0, " + readAt(0.3, "peak").toFixed(2) + "× at 0.3, "
+  + readAt(1, "peak").toFixed(3) + "× at 1");
+console.log("  · so galaxies are nearly blind to it and the Solar System is not, and it");
+console.log("    is the Solar System that rules it out — by ten orders of magnitude on");
+console.log("    the ephemeris, and four on Cassini");
+console.log("  · and it does not rescue Genzel: it widens those dots, both ways");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/veins.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/veins.ts
new file mode 100644
index 0000000..499abca
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/veins.ts
@@ -0,0 +1,624 @@
+/**
+ * THE VEINS — do they thin out with distance, can a different cone kill them,
+ * does an extended emitter wash them out, and WHAT DOES ANY OF IT DO TO LIGHT.
+ *
+ * A wandering charge steps along the heading it left with, or with probability
+ * `w` along one of the alternatives that heading admits. Some `w` puts the front
+ * on a circle — 2(1 − 1/√2) = 0.5858 for the rule `discrete.ts` ships, which is
+ * what everything here runs on; see `ways` for why that is not the 0.8787 in
+ * `wander.tsx`. Rounding the front does NOT make the field inside it smooth:
+ * there are ridges along the eight lattice headings and thin wedges between
+ * them, because a FACE heading's alternatives
+ *
+ *     {(1,0), (1,1), (1,−1)}      every member has x = 1
+ *
+ * advance x by exactly one per tick whatever path is taken, piling the whole
+ * distribution onto the bar x = t, whereas a DIAGONAL's
+ *
+ *     {(1,0), (0,1)}              nothing is shared
+ *
+ * fix nothing and open into a wedge. `w` decides how often the alternatives are
+ * used, not what is in them, so no `w` can flatten that.
+ *
+ * That is a statement about gravity, but THE SAME LATTICE CARRIES LIGHT — a
+ * charge in flight is a charge in flight — so whatever the veins do to the
+ * gravitational field they do to a beam, and light is the thing we have measured
+ * to eighteen decimal places. Two observables have to be kept apart:
+ *
+ *   TIMING     when the front arrives in direction θ   → c(θ): resonators, GW170817
+ *   INTENSITY  how much is in flight in direction θ    → flux: photometry
+ *
+ * and TIMING has three readings that differ by a factor of four and must not be
+ * confused: the BALLISTIC edge (the luckiest path, which never turns and carries
+ * a part in 10²² at a hundred ticks), the CREST (where the bulk is), and the
+ * THRESHOLD (the radius beyond which a fraction ε still lies, which is the only
+ * one an instrument can report). Test 4 measures all three; the third is the one
+ * that comes out fatal, and test 6 asks whether anything cancels it.
+ *
+ * Run: ./run.sh veins
+ */
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the lattice, its own copy
+
+const DIRS: [number, number][] = [
+  [1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1],
+];
+
+const EXACT_W = 3 * (1 - Math.SQRT1_2);          // 0.87867965…  wander.tsx
+const SHIP_W  = 2 * (1 - Math.SQRT1_2);          // 0.58578644…  discrete.ts, in 2D
+
+type Cone = "shipped" | "forward" | "hemisphere" | "weighted" | "blind";
+
+/**
+ * `ways` exactly as `discrete.ts` builds it (~1366), two-dimensionally: one
+ * entry per axis, the axis taken apart if the heading uses it and the heading
+ * with ±1 added sideways if it does not, with the heading itself at [0] and the
+ * alternatives being everything after it.
+ *
+ *     (1,0)  →  alternatives (1,0) (1,1) (1,−1)     — the heading comes BACK
+ *     (1,1)  →  alternatives (1,0) (0,1)            — and here it does not
+ *
+ * That asymmetry is not in `wander.tsx`, which models a three-member cone for
+ * both, and it is the whole of the difference the `ways` test measures.
+ */
+const shippedWays = (h: [number, number]): [number, number][] => {
+  const out: [number, number][] = [];
+  for (let a = 0; a < 2; a++) {
+    if (h[a]) out.push(a === 0 ? [h[0], 0] : [0, h[1]]);
+    else for (const s of [1, -1] as const)
+      out.push(a === 0 ? [s, h[1]] : [h[0], s]);
+  }
+  return out;
+};
+
+/**
+ * Four ways of saying "a charge may turn, but not by much". `forward` is the
+ * rule the article runs on: strictly positive overlap with where it was already
+ * going. `hemisphere` admits the two perpendiculars as well (overlap ≥ 0),
+ * `weighted` keeps every direction with positive overlap but in proportion to
+ * it, and `blind` is the original wander with no cone at all.
+ */
+const kernel = (h: [number, number], kind: Cone, w: number): [number, number][] => {
+  const dot = (d: [number, number]) => d[0] * h[0] + d[1] * h[1];
+  const idx = (d: [number, number]) => DIRS.findIndex(e => e[0] === d[0] && e[1] === d[1]);
+
+  if (kind === "shipped") {
+    const alt = shippedWays(h), acc = new Map<number, number>();
+    acc.set(idx(h), 1 - w);
+    for (const d of alt) acc.set(idx(d), (acc.get(idx(d)) ?? 0) + w / alt.length);
+    return [...acc].filter(([, p]) => p > 0);
+  }
+  if (kind === "weighted") {
+    const ws = DIRS.map(d => Math.max(0, dot(d)));
+    const s = ws.reduce((a, b) => a + b, 0);
+    return DIRS.map((d, i) => [i, ws[i] / s] as [number, number]).filter(([, p]) => p > 0);
+  }
+  const C = kind === "blind" ? DIRS.slice()
+    : kind === "hemisphere" ? DIRS.filter(d => dot(d) >= -1e-9)
+      : DIRS.filter(d => dot(d) > 1e-9);
+
+  return C.map(d => [idx(d),
+    ((d[0] === h[0] && d[1] === h[1]) ? (1 - w) : 0) + w / C.length] as [number, number]);
+};
+
+/** ⟨step⟩ out of heading h: the rate the CREST of a pulse actually advances */
+const crestSpeed = (h: [number, number], kind: Cone, w: number) => {
+  let x = 0, y = 0;
+  for (const [i, p] of kernel(h, kind, w)) { x += p * DIRS[i][0]; y += p * DIRS[i][1]; }
+  return Math.hypot(x, y);
+};
+
+const swing = (a: number[]) => {
+  const f = a.filter(v => isFinite(v) && v > 0);
+  if (!f.length) return NaN;
+  const m = f.reduce((x, y) => x + y, 0) / f.length;
+  return (Math.max(...f) - Math.min(...f)) / m;
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the walk
+
+type Field = {
+  T: number; N: number; o: number;
+  occ: Float64Array;          // summed over ticks (steady state) or last tick (pulse)
+  first: Int32Array;          // first tick a cell carries anything at all
+};
+
+/**
+ * `emit` is the list of cells that pulse — one cell for a point source, a disk
+ * of them for a surface. Every emitter injects into all eight headings equally,
+ * which is the "radiating in every direction" case; the whole question is
+ * whether isotropy at the source buys isotropy at radius r.
+ *
+ * `steady` = true keeps pulsing every tick and accumulates, which is what a
+ * source looks like and what `chance(m,r)` is an average over. `steady` = false
+ * emits once and reports the distribution at age T, which is what a front is.
+ *
+ * `carry` is the question of WHAT THE CONE IS THE CONE OF, and it is an
+ * assumption rather than a result, so both halves of it are run everywhere here.
+ *
+ *   carry = false   the cone is always the cone of the heading the charge LEFT
+ *                   with. This is what ships: `discrete.ts` says it in as many
+ *                   words — "Where it is going, remembered — not where it went
+ *                   last time" — and never writes `r.heading`, so a wander is a
+ *                   deviation about a fixed line that the charge returns to.
+ *                   `wander.tsx` does the same (`… ? random : d`, off `d`).
+ *
+ *   carry = true    the cone is the cone of the LAST STEP TAKEN. Nothing in the
+ *                   lattice distinguishes the two — a cell has edges, not
+ *                   memories — so if the heading is not carried in the state
+ *                   there is nothing to remember it, and this is arguably the
+ *                   more honest discrete reading.
+ *
+ * They are not small variants of each other. Under `carry` the heading itself
+ * random-walks around the eight, decorrelates in a few ticks, and the motion
+ * turns from ballistic into DIFFUSIVE — which is a statement about whether
+ * anything propagates at all, and is measured in test 0 below rather than
+ * asserted.
+ */
+const run = (T: number, w: number, kind: Cone, emit: [number, number][],
+  steady = true, carry = false): Field => {
+  const N = 2 * T + 3, o = T + 1, S = N * N;
+  let cur = new Float64Array(S * 8), nxt = new Float64Array(S * 8);
+  const occ = new Float64Array(S);
+  const first = new Int32Array(S).fill(-1);
+  const K = DIRS.map(h => kernel(h, kind, w));
+  const inj = 1 / (8 * emit.length);
+
+  const fire = (a: Float64Array) => {
+    for (const [ex, ey] of emit)
+      for (let h = 0; h < 8; h++) a[(((o + ey) * N + (o + ex)) * 8) + h] += inj;
+  };
+  fire(cur);
+
+  for (let t = 1; t <= T; t++) {
+    nxt.fill(0);
+    for (let y = 1; y < N - 1; y++) for (let x = 1; x < N - 1; x++) {
+      const c = (y * N + x) * 8;
+      for (let h = 0; h < 8; h++) {
+        const v = cur[c + h];
+        if (v === 0) continue;
+        for (const [i, p] of K[h])
+          nxt[(((y + DIRS[i][1]) * N + (x + DIRS[i][0])) * 8) + (carry ? i : h)] += v * p;
+      }
+    }
+    if (steady) fire(nxt);
+    const tmp = cur; cur = nxt; nxt = tmp;
+
+    for (let k = 0; k < S; k++) {
+      let s = 0;
+      for (let h = 0; h < 8; h++) s += cur[k * 8 + h];
+      if (steady) occ[k] += s; else occ[k] = s;
+      if (s > 1e-300 && first[k] < 0) first[k] = t;
+    }
+  }
+  return { T, N, o, occ, first };
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// reading a field
+
+const NB = 360;                                  // one angular bin per degree
+
+const bin = (x: number, y: number) =>
+  Math.min(NB - 1, Math.floor(((Math.atan2(y, x) + 2 * Math.PI) % (2 * Math.PI)) / (2 * Math.PI) * NB));
+
+/** mean occupancy per angular bin in the annulus at r; ALWAYS length NB */
+const profile = (f: Field, r: number, dr = 1.5) => {
+  const sum = new Float64Array(NB), cnt = new Float64Array(NB);
+  for (let y = -f.T; y <= f.T; y++) for (let x = -f.T; x <= f.T; x++) {
+    const R = Math.hypot(x, y);
+    if (R < r - dr || R > r + dr) continue;
+    const b = bin(x, y);
+    sum[b] += f.occ[(y + f.o) * f.N + (x + f.o)];
+    cnt[b] += 1;
+  }
+  const out = new Array<number>(NB).fill(0);
+  for (let b = 0; b < NB; b++) if (cnt[b] > 0) out[b] = sum[b] / cnt[b];
+  return out;
+};
+
+const stats = (p: number[]) => {
+  const mean = p.reduce((a, b) => a + b, 0) / p.length;
+  const s = p.slice().sort((a, b) => a - b);
+  const q = (f: number) => s[Math.round(f * (s.length - 1))] / mean;
+  return { mean, peak: q(1), dead: q(0), p95: q(0.95), p05: q(0.05),
+    empty: p.filter(v => v <= 0).length / p.length,
+    rms: Math.sqrt(p.reduce((a, b) => a + (b / mean - 1) ** 2, 0) / p.length) };
+};
+
+/** the crest radius per angular bin of a single pulse of age T, over T */
+const crestProfile = (f: Field) => {
+  const wr = new Float64Array(NB), ws = new Float64Array(NB);
+  for (let y = -f.T; y <= f.T; y++) for (let x = -f.T; x <= f.T; x++) {
+    const v = f.occ[(y + f.o) * f.N + (x + f.o)];
+    if (v <= 0) continue;
+    const b = bin(x, y);
+    wr[b] += v * Math.hypot(x, y); ws[b] += v;
+  }
+  return Array.from(wr, (v, b) => ws[b] > 0 ? v / ws[b] / f.T : NaN);
+};
+
+/** the outermost cell reached in each angular bin, over T — the lucky path */
+const edgeProfile = (f: Field) => {
+  const best = new Float64Array(NB);
+  for (let y = -f.T; y <= f.T; y++) for (let x = -f.T; x <= f.T; x++)
+    if (f.occ[(y + f.o) * f.N + (x + f.o)] > 0)
+      best[bin(x, y)] = Math.max(best[bin(x, y)], Math.hypot(x, y) / f.T);
+  return Array.from(best);
+};
+
+const pad = (x: number, n = 4, wdt = 9) => x.toFixed(n).padStart(wdt);
+
+/**
+ * The `w` at which a cone puts the diagonal crest and the face crest at the same
+ * radius, i.e. the `w` at which THAT cone's front is a circle. `forward` gives
+ * the 3(1 − 1/√2) the article runs on; the other families have their own, and
+ * comparing the veins AT EACH FAMILY'S OWN ROUNDING w is the only fair way to
+ * ask whether some other cone would do better.
+ */
+const roundingW = (kind: Cone) => {
+  const f = (w: number) => crestSpeed(DIRS[1], kind, w) / crestSpeed(DIRS[0], kind, w) - 1;
+  let lo = 0, hi = 1;
+  if (f(lo) * f(hi) > 0) return NaN;
+  for (let i = 0; i < 200; i++) {
+    const m = (lo + hi) / 2;
+    if (f(lo) * f(m) <= 0) hi = m; else lo = m;
+  }
+  return (lo + hi) / 2;
+};
+
+/**
+ * WHAT A DETECTOR WOULD ACTUALLY TIME. The crest is the mass-weighted mean
+ * radius, which is not what an instrument reports: an instrument fires when
+ * enough has arrived. So for each direction, find the radius beyond which a
+ * fraction `eps` of that direction's pulse still lies, and call the arrival
+ * time R/T. Sweeping `eps` sweeps from a very insensitive detector (10⁻¹) to a
+ * very sensitive one (10⁻⁹), and the answer is allowed to depend on it.
+ */
+const thresholdProfile = (f: Field, eps: number) => {
+  const bins: number[][] = Array.from({ length: NB }, (): number[] => []);
+  const rads: number[][] = Array.from({ length: NB }, (): number[] => []);
+  for (let y = -f.T; y <= f.T; y++) for (let x = -f.T; x <= f.T; x++) {
+    const v = f.occ[(y + f.o) * f.N + (x + f.o)];
+    if (v <= 0) continue;
+    const b = bin(x, y);
+    bins[b].push(v); rads[b].push(Math.hypot(x, y));
+  }
+  return bins.map((vs, b) => {
+    if (!vs.length) return NaN;
+    const ord = vs.map((_, i) => i).sort((i, j) => rads[b][j] - rads[b][i]);   // outward in
+    const tot = vs.reduce((a, c) => a + c, 0);
+    let acc = 0;
+    for (const i of ord) { acc += vs[i]; if (acc >= eps * tot) return rads[b][i] / f.T; }
+    return NaN;
+  });
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log("VEINS — distance, cone shape, extended emitters, and light\n");
+console.log("  the shipped rule rounds its front at w = 2(1 − 1/√2) = " + SHIP_W.toFixed(6));
+console.log("  (`wander.tsx` models a different cone and gets 3(1 − 1/√2) = "
+  + EXACT_W.toFixed(4) + "; see the `ways` test for which is which and why it matters)");
+console.log("  contrast is read as PEAK/MEAN over 1° angular bins, never max/min:");
+console.log("  at small w the wedges are exactly empty and max/min divides by zero,");
+console.log("  which is a fact about w and not a measurement.\n");
+console.log("  EVERY TEST IS RUN BOTH WAYS:");
+console.log("    remembered  the cone is the cone of the heading the charge LEFT with");
+console.log("                — what `discrete.ts` and `wander.tsx` actually do");
+console.log("    carried     the cone is the cone of the LAST STEP TAKEN — arguably");
+console.log("                the more honest reading, since a cell has edges and not");
+console.log("                memories, and nothing in the lattice holds the original\n");
+
+const MODES: [string, boolean][] = [["remembered", false], ["carried", true]];
+
+// ── 0. does anything propagate at all ────────────────────────────────────────
+
+console.log("─".repeat(78));
+console.log("0. BALLISTIC OR DIFFUSIVE?");
+console.log("   the mean radius of ONE pulse against its age. Ballistic is r ∝ t and");
+console.log("   is what a light cone means; diffusive is r ∝ √t and means the front");
+console.log("   slows to a stop and there is no cone and no speed of light.\n");
+
+const AGES = [8, 16, 32, 64, 128];
+console.log("   mode         w    " + AGES.map(t => ("t=" + t).padStart(9)).join("") + "     ⟨r⟩∝t^");
+for (const [name, carry] of MODES) {
+  for (const w of [0.3, SHIP_W, 1]) {
+    const rs = AGES.map(T => {
+      const f = run(T, w, "shipped", [[0, 0]], false, carry);
+      let wr = 0, ws = 0;
+      for (let y = -T; y <= T; y++) for (let x = -T; x <= T; x++) {
+        const v = f.occ[(y + f.o) * f.N + (x + f.o)];
+        wr += v * Math.hypot(x, y); ws += v;
+      }
+      return wr / ws;
+    });
+    const lx = AGES.map(Math.log), ly = rs.map(Math.log);
+    const mx = lx.reduce((a, b) => a + b) / lx.length, my = ly.reduce((a, b) => a + b) / ly.length;
+    const sl = lx.reduce((a, v, i) => a + (v - mx) * (ly[i] - my), 0)
+      / lx.reduce((a, v) => a + (v - mx) ** 2, 0);
+    console.log("  " + name.padEnd(11) + (w === SHIP_W ? w.toFixed(3) : w.toFixed(2)).padStart(6)
+      + rs.map(v => pad(v, 3)).join("") + "     " + sl.toFixed(4));
+  }
+}
+console.log("\n  an exponent of 1 is a light cone. An exponent of ½ is a puddle.\n");
+
+// ── 1. contrast against radius ───────────────────────────────────────────────
+
+console.log("─".repeat(78));
+console.log("1. DOES THE CONTRAST THIN OUT WITH DISTANCE?");
+console.log("   steady-state occupancy from ONE cell radiating into all eight headings");
+console.log("   every tick, each annulus read against its own mean so the 1/r falloff");
+console.log("   is divided out. ONLY r ≤ T/2 is reported: past that the sum over ages");
+console.log("   is still front-dominated and is not a steady state.\n");
+
+const T1 = 120;
+const WS = [0.3, 0.6, SHIP_W, 1];
+const RS = [20, 30, 40, 50, 60];
+
+const slope = (xs: number[], ys: number[]) => {
+  const lx = xs.map(Math.log), ly = ys.map(Math.log);
+  const mx = lx.reduce((a, b) => a + b) / lx.length, my = ly.reduce((a, b) => a + b) / ly.length;
+  return lx.reduce((a, v, i) => a + (v - mx) * (ly[i] - my), 0)
+    / lx.reduce((a, v) => a + (v - mx) ** 2, 0);
+};
+
+for (const [name, carry] of MODES) {
+  console.log("  " + name + ":");
+  console.log("     w   " + RS.map(r => ("r=" + r).padStart(9)).join("") + "     slope");
+  for (const w of WS) {
+    const f = run(T1, w, "shipped", [[0, 0]], true, carry);
+    const row = RS.map(r => stats(profile(f, r)).peak);
+    console.log("  " + (w === SHIP_W ? w.toFixed(4) : w.toFixed(2)).padStart(6)
+      + row.map(v => pad(v, 4)).join("") + "   " + pad(slope(RS, row), 4));
+  }
+  console.log();
+}
+console.log("  slope is d log(peak/mean) / d log r. Zero means SCALE FREE: the veins");
+console.log("  are as deep at a megaparsec as at ten cells. Negative means they wash");
+console.log("  out on their own and the far field is smooth after all.");
+
+console.log("\n  and the same radius (r = 35) from three run lengths, to check the");
+console.log("  number is a property of the field and not of where the box ends:\n");
+console.log("   mode          w     T=70     T=100     T=140");
+for (const [name, carry] of MODES)
+  for (const w of WS)
+    console.log("  " + name.padEnd(11) + (w === SHIP_W ? w.toFixed(4) : w.toFixed(2)).padStart(6)
+      + [70, 100, 140].map(T =>
+        pad(stats(profile(run(T, w, "shipped", [[0, 0]], true, carry), 35)).peak, 4)).join(""));
+console.log();
+
+// ── 2. what a different cone does ────────────────────────────────────────────
+
+console.log("─".repeat(78));
+console.log("2. CAN A DIFFERENT CONE KILL THEM?");
+console.log("   crest d/f is ⟨step⟩ along a diagonal over ⟨step⟩ along an axis, which");
+console.log("   only means anything when the heading is remembered — it is a one-step");
+console.log("   average and under `carried` the heading does not survive one step.");
+console.log("   `swing` is (max − min)/mean read off the field over all 360 directions.\n");
+
+const T2 = 100;
+console.log("  each family's OWN rounding w — the w at which ITS front is a circle:");
+for (const kind of ["shipped", "forward", "hemisphere", "weighted", "blind"] as Cone[])
+  console.log("    " + kind.padEnd(12) + (isFinite(roundingW(kind))
+    ? roundingW(kind).toFixed(6) : "none in [0,1]"));
+console.log();
+
+for (const [name, carry] of MODES) {
+  console.log("  " + name + ":");
+  console.log("  cone           w    crest d/f  crest swing  edge swing  peak/mean   rms");
+  for (const kind of ["shipped", "forward", "hemisphere", "weighted", "blind"] as Cone[]) {
+    const rw = roundingW(kind);
+    const wsOf = kind === "weighted" ? [1]
+      : !isFinite(rw) ? [EXACT_W, 1] : rw === 1 ? [1] : [rw, 1];
+    for (const w of wsOf) {
+      const st = stats(profile(run(T2, w, kind, [[0, 0]], true, carry), 50));
+      const p = run(T2, w, kind, [[0, 0]], false, carry);
+      const cf = crestSpeed(DIRS[0], kind, w), cd = crestSpeed(DIRS[1], kind, w);
+      console.log("  " + kind.padEnd(12) + (kind === "weighted" ? "   —  " : w.toFixed(4).padStart(7))
+        + pad(cd / cf, 4) + pad(swing(crestProfile(p)), 4, 12) + pad(swing(edgeProfile(p)), 4, 12)
+        + pad(st.peak, 3) + pad(st.rms, 3, 7));
+    }
+  }
+  console.log();
+}
+console.log("  a cone that ROUNDS THE FRONT and a cone that SMOOTHS THE FIELD are");
+console.log("  different requirements, and nothing here does both. `blind` at w = 1");
+console.log("  has ⟨step⟩ = 0 in every heading — a source that does not propagate at");
+console.log("  all — which is why that ratio comes out undefined.\n");
+
+// ── 3. an extended emitter ───────────────────────────────────────────────────
+
+console.log("─".repeat(78));
+console.log("3. DOES A SURFACE WASH IT OUT?");
+console.log("   every cell of a disk of radius Rs pulsing into all eight headings every");
+console.log("   tick — an isotropically radiating body, not a point. This is the");
+console.log("   question of whether a real emitter, which is a surface and not a cell,");
+console.log("   averages the ridges away by having many origins.\n");
+
+const T3 = 120;
+const disk = (R: number): [number, number][] => {
+  const out: [number, number][] = [];
+  for (let y = -R; y <= R; y++) for (let x = -R; x <= R; x++)
+    if (x * x + y * y <= R * R) out.push([x, y]);
+  return out;
+};
+
+for (const [name, carry] of MODES) {
+  console.log("  " + name + ":");
+  console.log("   Rs   cells    r=20     r=30     r=40     r=50     r=60");
+  for (const Rs of [0, 3, 8, 16, 30]) {
+    const em = Rs === 0 ? [[0, 0] as [number, number]] : disk(Rs);
+    const f = run(T3, SHIP_W, "shipped", em, true, carry);
+    console.log("  " + String(Rs).padStart(3) + "  " + String(em.length).padStart(5)
+      + [20, 30, 40, 50, 60].map(r => pad(stats(profile(f, r)).peak, 4)).join(""));
+  }
+  console.log();
+}
+console.log("  a ridge points along the LATTICE, not away from the emitter, so moving");
+console.log("  the emitter one cell over moves the ridge one cell sideways — it does");
+console.log("  not rotate it. Parallel ridges from every cell of the disk therefore");
+console.log("  stack rather than cancel, and the disk can only smooth structure FINER");
+console.log("  than itself. The table bears that out and puts a scale on it: the");
+console.log("  smoothing is a function of Rs/r and of nothing else, and it needs");
+console.log("  Rs/r ≳ 0.3 to bring the contrast under 2. A star seen from a parsec has");
+console.log("  Rs/r ~ 10⁻⁸ and a laser aperture at any useful range is smaller still,");
+console.log("  so for anything anyone would actually measure this buys nothing at all.");
+console.log("  An extended emitter helps only when you are practically inside it.\n");
+
+// ── 4. light ─────────────────────────────────────────────────────────────────
+
+console.log("─".repeat(78));
+console.log("4. THE SAME LATTICE CARRIES LIGHT — which observable does it hit?");
+console.log("   TIMING is what a resonator or a two-messenger burst weighs; INTENSITY");
+console.log("   is what a photometer weighs. They are independent and the bounds on");
+console.log("   them differ by fifteen orders of magnitude.\n");
+
+const T4 = 120;
+for (const [name, carry] of MODES) {
+  for (const w of [SHIP_W, 1]) {
+    const p = run(T4, w, "shipped", [[0, 0]], false, carry);
+    const s = run(T4, w, "shipped", [[0, 0]], true, carry);
+    const st = stats(profile(s, 50));
+    console.log("  " + name + ", w = " + (w === SHIP_W ? w.toFixed(4) : w.toFixed(2)));
+    console.log("    TIMING, crest      swing over 360°   " + swing(crestProfile(p)).toExponential(3));
+    console.log("    TIMING, ballistic  swing over 360°   " + swing(edgeProfile(p)).toExponential(3));
+    console.log("    TIMING, detector   swing at ε = "
+      + [1e-1, 1e-3, 1e-6, 1e-9].map(e =>
+        e.toExponential(0) + ": " + swing(thresholdProfile(p, e)).toFixed(4)).join("  "));
+    console.log("    INTENSITY          peak/mean         " + st.peak.toFixed(4)
+      + "      p95/p05  " + (st.p95 / st.p05).toFixed(4));
+  }
+}
+console.log("\n  the three TIMING rows are three different questions. `crest` is where");
+console.log("  the middle of the pulse is, `ballistic` is where the luckiest charge");
+console.log("  got to, and `detector` is the only one an experiment can report: the");
+console.log("  radius beyond which a fraction ε of the pulse still lies, which is what");
+console.log("  a threshold is. A resonator is very sensitive, so it reads the small ε.");
+
+console.log("\n  what the ballistic edge weighs — the chance a charge launched along a");
+console.log("  diagonal has still never turned after t ticks, which is the weight");
+console.log("  behind the fastest arrival and so behind any timing anisotropy read");
+console.log("  off the outermost cell rather than off the crest:\n");
+{
+  const stay = (w: number) => (1 - w) + w / 3;
+  console.log("     w      p(straight)     t=10       t=50      t=100");
+  for (const w of [SHIP_W, 1])
+    console.log("  " + w.toFixed(4).padStart(6) + "     " + stay(w).toFixed(6)
+      + [10, 50, 100].map(t => ("  " + Math.pow(stay(w), t).toExponential(2)).padStart(11)).join(""));
+}
+console.log();
+
+// ── 5. a round trip ──────────────────────────────────────────────────────────
+
+console.log("─".repeat(78));
+console.log("5. DOES A ROUND TRIP CANCEL IT OR SQUARE IT?");
+console.log("   an interferometer sends light out and back, so it weighs the product of");
+console.log("   the two legs. The kernel is symmetric under reversing every direction");
+console.log("   at once, so the return leg has the SAME profile as the outward one");
+console.log("   rather than the reciprocal of it — which is the difference between an");
+console.log("   effect that cancels and one that squares.\n");
+for (const [name, carry] of MODES) {
+  const f = run(100, SHIP_W, "shipped", [[0, 0]], true, carry);
+  const p = profile(f, 50);
+  const m = p.reduce((a, b) => a + b) / p.length;
+  const rel = p.map(v => v / m);
+  const trip = rel.map((v, b) => v * rel[(b + NB / 2) % NB]);
+  const rep = (lbl: string, a: number[]) => {
+    const mm = a.reduce((x, y) => x + y, 0) / a.length;
+    console.log("    " + lbl.padEnd(11) + "peak/mean " + (Math.max(...a) / mm).toFixed(4)
+      + "   swing " + swing(a).toFixed(4));
+  };
+  console.log("  " + name + ":");
+  rep("one way", rel); rep("round trip", trip);
+}
+console.log();
+
+// ── 6. does the ruler contract too? ──────────────────────────────────────────
+
+console.log("─".repeat(78));
+console.log("6. IS IT COMMON-MODE? — the only thing that can save the timing");
+console.log("   Test 4 says light arrives 10–18% early or late depending on which way");
+console.log("   it went, against a measured bound of Δc/c < 10⁻¹⁸. Taken at face value");
+console.log("   that is dead seventeen times over. There is exactly one way out, and");
+console.log("   it is the same one the Lorentz ether had: THE RULER IS MADE OF THE");
+console.log("   SAME STUFF. A bound pair is held at the separation where the field");
+console.log("   between them reaches a given strength, and that field is this field —");
+console.log("   so if the ridge directions are both faster AND longer by the same");
+console.log("   factor, an interferometer compares a length to a time and sees nothing.");
+console.log("   What an experiment measures is the RATIO, so that is what is reported.\n");
+
+{
+  const T6 = 120;
+  console.log("   mode          w    swing c(θ)  swing ℓ(θ)  swing c/ℓ   corr(c,ℓ)");
+  for (const [name, carry] of MODES) {
+    for (const w of [SHIP_W, 1]) {
+      const p = run(T6, w, "shipped", [[0, 0]], false, carry);
+      const s = run(T6, w, "shipped", [[0, 0]], true, carry);
+
+      // c(θ): where the front is, at a detector threshold
+      const c = thresholdProfile(p, 1e-3);
+
+      // ℓ(θ): the radius at which the STEADY field falls to a fixed strength,
+      // which is where a pair bound by that field would sit
+      const RMAX = T6 / 2 | 0;
+      const byR: number[][] = [];
+      for (let r = 4; r <= RMAX; r++) byR[r] = profile(s, r);
+      const at45 = byR[45].filter(v => v > 0);
+      const LEV = at45.reduce((a, b) => a + b, 0) / at45.length;   // so ℓ ≈ 45
+      const l = Array.from({ length: NB }, (_, b) => {
+        for (let r = RMAX; r >= 4; r--) if (byR[r][b] >= LEV) return r;
+        return NaN;
+      });
+
+      const ok = c.map((v, i) => [v, l[i]] as [number, number])
+        .filter(([a, b]) => isFinite(a) && isFinite(b) && b > 0);
+      const ratio = ok.map(([a, b]) => a / b);
+      const ca = ok.map(([a]) => a), la = ok.map(([, b]) => b);
+      const mu = (a: number[]) => a.reduce((x, y) => x + y, 0) / a.length;
+      const mc = mu(ca), ml = mu(la);
+      const corr = ok.reduce((a, [x, y]) => a + (x - mc) * (y - ml), 0)
+        / Math.sqrt(ca.reduce((a, x) => a + (x - mc) ** 2, 0) * la.reduce((a, y) => a + (y - ml) ** 2, 0));
+
+      console.log("  " + name.padEnd(11) + (w === SHIP_W ? w.toFixed(4) : w.toFixed(2)).padStart(6)
+        + pad(swing(ca), 4) + pad(swing(la), 4) + pad(swing(ratio), 4) + pad(corr, 4));
+    }
+  }
+  console.log("\n  swing c/ℓ is the number that has to beat 10⁻¹⁸. If it is the same");
+  console.log("  size as swing c(θ) then nothing cancels and the lattice is ruled out");
+  console.log("  by table-top optics; if it collapses towards zero then the anisotropy");
+  console.log("  is common-mode, hides inside the definition of the metre, and the");
+  console.log("  bound to beat is a different one.\n");
+}
+
+console.log("─".repeat(78));
+console.log("WHAT THIS SETTLES");
+console.log("  0  the heading has to be REMEMBERED. Carry it with the step instead and");
+console.log("     it decorrelates in a few ticks, ⟨r⟩ ∝ t^0.56 rather than t, and there");
+console.log("     is no light cone and no speed of light at all. So the assumption in");
+console.log("     `discrete.ts` is not free — it is what buys propagation.");
+console.log("  1  and remembering it is what makes the veins permanent: peak/mean ≈ 4");
+console.log("     at the rounding w, flat-to-rising in radius, stable in run length.");
+console.log("     Under `carried` they do wash out, but only because everything does.");
+console.log("  2  no cone in the family both rounds the front and smooths the field.");
+console.log("     `hemisphere` at its own rounding w is the best of them at 2.04 and");
+console.log("     is still nothing like smooth.");
+console.log("  3  an extended isotropic emitter smooths only below its own size. It");
+console.log("     needs Rs/r ≳ 0.3 to matter and no real source is anywhere near that.");
+console.log("  4  TIMING IS NOT SAFE, which is the opposite of what the front-shape");
+console.log("     argument suggests. The crest is isotropic at the rounding w, but what");
+console.log("     an instrument thresholds swings by 8–18% at every ε — against a");
+console.log("     measured Δc/c < 10⁻¹⁸ (Nagel 2015, Nat Commun 6:8174) and the");
+console.log("     GW170817 bound (Abbott 2017, ApJL 848:L13). Seventeen orders.");
+console.log("  5  and a round trip does not cancel it, it roughly squares it.");
+console.log("  6  nor does the ruler save it. Building the length standard out of the");
+console.log("     same field makes the ratio WORSE, not better: ℓ(θ) swings harder than");
+console.log("     c(θ) and is anti-correlated with it, so c/ℓ swings by 1.6–2.2.");
+console.log();
+console.log("  the honest reading: a rounded front is not isotropy, and this rule does");
+console.log("  not deliver isotropy in anything an experiment can point at. What is NOT");
+console.log("  settled here is 3D — everything above is the two-dimensional rule, and");
+console.log("  `ways` shows 3D is worse rather than better, since no w rounds the sheet");
+console.log("  there at all.");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/wave.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/wave.ts
new file mode 100644
index 0000000..746e5f9
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/wave.ts
@@ -0,0 +1,241 @@
+/**
+ * WHAT IT WOULD LOOK LIKE — the same lattice, propagating as a wave instead of
+ * as a charge that remembers where it was going.
+ *
+ * The thread so far: a ray with a remembered heading is veined (`veins`), no
+ * turn rate rounds it in three dimensions (`ways`), no rule with nothing tuned
+ * rounds it either (`cones`), and the grain sits at fourth order where a cube
+ * first differs from a sphere (`lattices`). The last of those also found that
+ * the cubic lattice is not the obstruction — weighted, the model's own 26
+ * directions are exact at rank 4 — which leaves one thing to check: whether the
+ * thing propagating can be something other than a ray.
+ *
+ * THE DILEMMA A RAY CANNOT ESCAPE, which is worth stating before the answer:
+ *
+ *   heading REMEMBERED   ballistic, but the source has only 8 (or 26) headings
+ *                        to emit into and they stay collimated — `WanderSpread`
+ *                        measured the beams SHARPENING as 1/√t. Eight beams,
+ *                        never a sphere.
+ *   heading CARRIED      the heading decorrelates in a couple of steps and the
+ *                        motion goes diffusive — `veins` test 0 measured
+ *                        ⟨r⟩ ∝ t^0.56. No light cone at all.
+ *
+ * Neither is a sphere, and no weighting fixes either, because both are
+ * statements about ONE charge and a design condition is a statement about an
+ * average.
+ *
+ * WHAT BREAKS IT. A wave is ballistic even though its carriers are not, and the
+ * reason is momentum: a disturbance in a medium whose collisions CONSERVE
+ * momentum travels at a fixed speed no matter how much the individual carriers
+ * scatter. That is the whole of sound, and this model already has the
+ * ingredient — charges meeting head-on and turning around is a collision.
+ *
+ * So this file runs the same cubic neighbourhood as a momentum-conserving
+ * lattice gas (a BGK lattice Boltzmann, which is the smallest thing that is
+ * one), drops a single pulseW into it, and measures the front. Three ways:
+ * with the weights the space forces, with weights that fail at rank 4, and
+ * against the ray model's own numbers.
+ *
+ * Run: ./run.sh wave
+ */
+
+// ─────────────────────────────────────────────────────────────────────────────
+// D2Q9 — nine states per cell: rest, four faces, four diagonals
+
+const CX = [0, 1, 0, -1, 0, 1, -1, -1, 1];
+const CY = [0, 0, 1, 0, -1, 1, 1, -1, -1];
+
+/**
+ * The forced weights, from `lattices`: in two dimensions the rank-4 condition
+ * on this neighbourhood is the single equation w_face = 4·w_diag, and with
+ * normalisation that pins the set to 4/9, 1/9, 1/36. `BROKEN` violates exactly
+ * that one equation (2 : 1 instead of 4 : 1) and is otherwise identical, so the
+ * difference between the two runs below is the rank-4 defect and nothing else.
+ */
+const FORCED = [4 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 36, 1 / 36, 1 / 36, 1 / 36];
+
+/**
+ * The rank-4 condition BROKEN AND NOTHING ELSE. The first attempt at this just
+ * halved the diagonal weight, which also breaks Σw cᵢcⱼ = c_s²δ — that is the
+ * RANK 2 condition, and without it the scheme is not a fluid at all rather than
+ * an anisotropic one. It duly fell over (speed drifting to 0.12, swingW 3.9),
+ * which measures nothing.
+ *
+ * These keep 2a + 4b = 1/3 exactly, so the sound speed is still 1/√3 and rank 2
+ * is still satisfied, and set a = 2b instead of the forced a = 4b. So the ONLY
+ * difference from `FORCED` is the one equation, which is the point of having it.
+ */
+const BROKEN = (() => {
+  const b = 1 / 24, a = 2 * b;                       // 2a + 4b = 1/3 still
+  return [1 - 4 * a - 4 * b, a, a, a, a, b, b, b, b];
+})();
+
+const CS2 = 1 / 3;                                   // the lattice sound speed, squared
+
+/**
+ * One pulseW, dropped into a still medium, run for T ticks. Momentum is
+ * conserved exactly by the collision (the equilibrium carries ρ and ρu and the
+ * relaxation preserves both), which is the only property that matters here —
+ * it is what makes the disturbance travel rather than spread.
+ */
+const pulseW = (T: number, W: number[], tau = 0.8) => {
+  // PERIODIC, and wide enough that nothing has wrapped by tick T. An absorbing
+  // edge is not a neutral choice here: a cell that is never collided is a hole
+  // in the medium, and a hole radiates. The first version of this used one and
+  // the reflection off it grew to fifteen times the pulseW it was measuring.
+  const N = 2 * Math.ceil(Math.SQRT2 * T) + 9, o = (N - 1) / 2, S = N * N;
+  let f = new Float64Array(S * 9), g = new Float64Array(S * 9);
+
+  for (let k = 0; k < S; k++) for (let i = 0; i < 9; i++) f[k * 9 + i] = W[i];
+  for (let i = 0; i < 9; i++) f[(o * N + o) * 9 + i] += 0.01 * W[i];   // the pulseW
+
+  for (let t = 0; t < T; t++) {
+    for (let y = 0; y < N; y++) for (let x = 0; x < N; x++) {
+      const k = y * N + x;
+      let r = 0, mx = 0, my = 0;
+      for (let i = 0; i < 9; i++) { const v = f[k * 9 + i]; r += v; mx += v * CX[i]; my += v * CY[i]; }
+      const vx = mx / r, vy = my / r, u2 = vx * vx + vy * vy;
+      for (let i = 0; i < 9; i++) {
+        const cu = CX[i] * vx + CY[i] * vy;
+        const eq = W[i] * r * (1 + cu / CS2 + cu * cu / (2 * CS2 * CS2) - u2 / (2 * CS2));
+        const nx = (x + CX[i] + N) % N, ny = (y + CY[i] + N) % N;
+        g[(ny * N + nx) * 9 + i] = f[k * 9 + i] - (f[k * 9 + i] - eq) / tau;
+      }
+    }
+    const tmp = f; f = g; g = tmp;
+  }
+
+  const d = new Float64Array(S);
+  for (let k = 0; k < S; k++) {
+    let r = 0;
+    for (let i = 0; i < 9; i++) r += f[k * 9 + i];
+    d[k] = r - 1;                                     // the disturbance, background removed
+  }
+  return { T, N, o, d };
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+const NB_W = 360;
+const binW = (x: number, y: number) =>
+  Math.min(NB_W - 1, Math.floor(((Math.atan2(y, x) + 2 * Math.PI) % (2 * Math.PI)) / (2 * Math.PI) * NB_W));
+
+/** where the ringW of the disturbance sits, per direction, and how tall it is */
+const ringW = (P: ReturnType<typeof pulseW>) => {
+  const bestR = new Float64Array(NB_W), bestV = new Float64Array(NB_W);
+  const H = (P.N - 1) / 2;
+  for (let y = -H; y <= H; y++) for (let x = -H; x <= H; x++) {
+    const r = Math.hypot(x, y);
+    if (r < 3) continue;
+    const v = Math.abs(P.d[(y + P.o) * P.N + (x + P.o)]);
+    const b = binW(x, y);
+    if (v > bestV[b]) { bestV[b] = v; bestR[b] = r; }
+  }
+  return { r: Array.from(bestR), v: Array.from(bestV) };
+};
+
+const swingW = (a: number[]) => {
+  const f = a.filter(v => isFinite(v) && v > 0);
+  const m = f.reduce((x, y) => x + y, 0) / f.length;
+  return { mean: m, lo: Math.min(...f) / m, hi: Math.max(...f) / m,
+    swingW: (Math.max(...f) - Math.min(...f)) / m };
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log("WHAT IT WOULD LOOK LIKE — the same lattice, as a wave\n");
+console.log("─".repeat(84));
+console.log("1. THE FRONT\n");
+console.log("   A pulseW of one part in a hundred, dropped into a still medium on the");
+console.log("   ordinary square lattice, with a collision that conserves mass and");
+console.log("   momentum and nothing else. `front` is where the ringW sits divided by the");
+console.log("   ticks, so it is a speed; `amplitude` is how tall the ringW is, which is");
+console.log("   the thing that was veined in the ray picture.\n");
+
+console.log("   weights          T     front speed       front swingW    amplitude swingW");
+for (const [name, W] of [["forced 4:1", FORCED], ["broken 2:1", BROKEN]] as [string, number[]][]) {
+  for (const T of [40, 80, 140]) {
+    const R = ringW(pulseW(T, W));
+    const sr = swingW(R.r.map(r => r / T)), sv = swingW(R.v);
+    console.log("  " + name.padEnd(14) + String(T).padStart(5)
+      + sr.mean.toFixed(6).padStart(14) + "   " + sr.swingW.toExponential(2).padStart(11)
+      + "     " + sv.swingW.toExponential(2).padStart(11));
+  }
+}
+console.log("\n   the lattice sound speed is 1/√3 = " + Math.sqrt(CS2).toFixed(6)
+  + ", which is what the front");
+console.log("   column should be reading. Both sets have the SAME sound speed by");
+console.log("   construction — rank 2 is satisfied either way — so anything separating");
+console.log("   them in the swingW columns is the rank-4 condition and nothing else.\n");
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log("─".repeat(84));
+console.log("2. AGAINST THE RAY, WHICH IS THE POINT\n");
+console.log("   the same lattice, the same neighbours, the same number of ticks —");
+console.log("   the only difference is what is being propagated.\n");
+
+{
+  const R = ringW(pulseW(140, FORCED));
+  const sr = swingW(R.r.map(r => r / 140)), sv = swingW(R.v);
+  const rows: [string, string, string][] = [
+    ["front shape", "√2 anisotropic, or one tuned w in 2D only",
+      "swingW " + sr.swingW.toExponential(2)],
+    ["field structure", "peak/mean 4.2, scale free — the veins",
+      "swingW " + sv.swingW.toExponential(2)],
+    ["how many directions", "8 beams, sharpening as 1/√t", "a continuum of k"],
+    ["with distance", "does not thin out (slope +0.22)", "→ 0 as (Δx/λ)²"],
+    ["needs tuning", "yes — a turn rate, and it fails in 3D", "no — one linear condition"],
+  ];
+  console.log("                         ray, heading remembered              wave");
+  for (const [a, b, c] of rows)
+    console.log("  " + a.padEnd(20) + b.padEnd(42) + c);
+}
+
+console.log("\n  and the reason the wave escapes the dilemma the ray could not: a ray");
+console.log("  carries its own direction, so it can only ever leave in one of the eight");
+console.log("  the lattice has. A wave has no direction of its own — what has a direction");
+console.log("  is a Fourier mode, and those are continuous, so the front is round for the");
+console.log("  same reason a pond's is: not because the water knows about circles, but");
+console.log("  because every direction is available and they all travel at the same rate.");
+console.log();
+console.log("  the wandering was the right instinct and the wrong mechanism. A charge");
+console.log("  that deviates is still a charge with a heading, and averaging its own");
+console.log("  deviations is not the same as averaging over an ensemble that exchanges");
+console.log("  momentum. Collisions are what does the averaging, and they are already in");
+console.log("  the model — a head-on meeting is one.\n");
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log("─".repeat(84));
+console.log("3. HOW MUCH GRAIN IS LEFT, AND WHERE IT WENT\n");
+console.log("   the front swingW against the pulseW's width in cells — the wave's own");
+console.log("   wavelength. If the residual is the lattice showing through, it has to");
+console.log("   fall as the disturbance spreads over more cells.\n");
+
+console.log("   weights        T     front swingW     × T      × T²");
+const decay: Record<string, [number, number][]> = { "forced 4:1": [], "broken 2:1": [] };
+for (const [name, W] of [["forced 4:1", FORCED], ["broken 2:1", BROKEN]] as [string, number[]][]) {
+  for (const T of [40, 70, 100, 140]) {
+    const s0 = swingW(ringW(pulseW(T, W)).r.map(r => r / T)).swingW;
+    decay[name].push([T, s0]);
+    console.log("  " + name.padEnd(13) + String(T).padStart(5)
+      + s0.toExponential(3).padStart(15) + (s0 * T).toFixed(3).padStart(9)
+      + (s0 * T * T).toFixed(1).padStart(9));
+  }
+}
+console.log();
+for (const k of Object.keys(decay)) {
+  const d = decay[k];
+  const lx = d.map(([t]) => Math.log(t)), ly = d.map(([, v]) => Math.log(v));
+  const mx = lx.reduce((a, b) => a + b) / lx.length, my = ly.reduce((a, b) => a + b) / ly.length;
+  const sl = lx.reduce((a, v, i) => a + (v - mx) * (ly[i] - my), 0)
+    / lx.reduce((a, v) => a + (v - mx) ** 2, 0);
+  console.log("   " + k.padEnd(13) + " swingW ∝ T^" + sl.toFixed(3));
+}
+console.log("\n   a negative exponent is the lattice hiding itself as the wave spreads");
+console.log("   over more cells — the suppression a ray never gets, because a ray is one");
+console.log("   cell wide however far it goes (`veins` measured its contrast RISING with");
+console.log("   radius, slope +0.22). Whatever the exact power, that sign is the whole");
+console.log("   difference between a model that survives contact with optics and one");
+console.log("   that does not.");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ways.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ways.ts
new file mode 100644
index 0000000..627db24
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ways.ts
@@ -0,0 +1,209 @@
+/**
+ * WHAT THE SHIPPED WANDER ACTUALLY DOES — against what `wander.tsx` says it does.
+ *
+ * `wander.tsx` computes the front speed of each direction class from
+ *
+ *     face    1
+ *     edge    √2 (1 − w/3)
+ *     corner  √3 (1 − w/2)
+ *
+ * and everything downstream of it — the claim that w = 3(1 − 1/√2) = 0.8787
+ * puts the front exactly on a circle, `k` = 1, and therefore that `Ḡ` and every
+ * published number survive the move from an assumed sphere to a derived one —
+ * rests on those three lines. They are a MODEL of the wander, not a reading of
+ * it, and they were never checked against the rule in `discrete.ts`.
+ *
+ * The rule there (`discrete.ts` ~1366) builds the alternatives like this, for a
+ * heading `head`, one entry per axis:
+ *
+ *     head[axis] ≠ 0   push head[axis] on its own          — taken apart
+ *     head[axis] = 0   push head with ±1 on that axis      — sideways added
+ *
+ * with `waysW[0] = head`, and then
+ *
+ *     with probability w, choose uniformly from waysW[1…]
+ *     otherwise carry straight on
+ *
+ * so the alternatives are waysW[1…] and the count of them depends on how many
+ * axes the heading has. That is the whole of it and it is exactly reproducible,
+ * which is what this file does: build `waysW` the same way, take the mean step,
+ * and compare.
+ *
+ * Run: ./run.sh waysW
+ */
+
+// ─────────────────────────────────────────────────────────────────────────────
+// the rule, transcribed
+
+/** every lattice direction in d dimensions: 3^d − 1 of them */
+const stepsW = (d: number): number[][] => {
+  let out: number[][] = [[]];
+  for (let i = 0; i < d; i++) out = out.flatMap(p => [-1, 0, 1].map(v => [...p, v]));
+  return out.filter(p => p.some(v => v !== 0));
+};
+
+/** `waysW` exactly as `discrete.ts` builds it — waysW[0] is the heading itself */
+const waysW = (head: number[]): number[][] => {
+  const out: number[][] = [head];
+  for (let axis = 0; axis < head.length; axis++) {
+    if (head[axis]) {
+      const one = new Array(head.length).fill(0);
+      one[axis] = head[axis];
+      out.push(one);
+    } else {
+      for (const side of [1, -1]) {
+        const off = head.slice();
+        off[axis] = side;
+        out.push(off);
+      }
+    }
+  }
+  return out;
+};
+
+/** ⟨step⟩ under the shipped rule: (1−w) straight on, w uniform over waysW[1…] */
+const meanStepW = (head: number[], w: number) => {
+  const alt = waysW(head).slice(1);
+  const m = head.map((v, i) => (1 - w) * v + (alt.length
+    ? (w / alt.length) * alt.reduce((a, c) => a + c[i], 0) : w * v));
+  return m;
+};
+
+const normW = (v: number[]) => Math.hypot(...v);
+const rankW = (h: number[]) => h.filter(v => v !== 0).length;   // 1 face, 2 edge, 3 corner
+
+/** what `wander.tsx` asserts instead */
+const FSPEED = (w: number, r: number) =>
+  r === 1 ? 1 : r === 2 ? Math.SQRT2 * (1 - w / 3) : Math.sqrt(3) * (1 - w / 2);
+
+const padW = (x: number, n = 4, wdt = 10) =>
+  (isFinite(x) ? x.toFixed(n) : "—").padStart(wdt);
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log("WAYS — the shipped wander against the one the article models\n");
+
+// ── 1. the alternatives ──────────────────────────────────────────────────────
+
+console.log("─".repeat(76));
+console.log("1. WHAT THE ALTERNATIVES ARE, by rankW of the heading\n");
+for (const d of [2, 3]) {
+  console.log("  d = " + d + ":");
+  const seen = new Set<number>();
+  for (const h of stepsW(d)) {
+    const r = rankW(h);
+    if (seen.has(r)) continue;
+    seen.add(r);
+    console.log("    rankW " + r + "  head " + JSON.stringify(h)
+      + "   alternatives (" + (waysW(h).length - 1) + "): "
+      + waysW(h).slice(1).map(v => JSON.stringify(v)).join(" "));
+  }
+  console.log();
+}
+console.log("  the heading REAPPEARS among the alternatives for a rankW-1 heading —");
+console.log("  taking (1,0,0) apart on its one non-zero axis gives (1,0,0) back — and");
+console.log("  does not for any other rankW. That asymmetry is the whole story below.\n");
+
+// ── 2. the speeds ────────────────────────────────────────────────────────────
+
+console.log("─".repeat(76));
+console.log("2. FRONT SPEED PER CLASS: shipped rule against wander.tsx\n");
+
+for (const d of [2, 3]) {
+  console.log("  d = " + d + ":");
+  console.log("     w    " + [1, 2, 3].filter(r => r <= d).flatMap(r =>
+    [("rankW" + r + " ship").padStart(11), ("rankW" + r + " art").padStart(11)]).join(""));
+  for (const w of [0, 0.3, 0.5858, 0.8787, 1]) {
+    const cells: string[] = [];
+    for (let r = 1; r <= d; r++) {
+      const h = stepsW(d).find(s => rankW(s) === r) as number[];
+      cells.push(padW(normW(meanStepW(h, w)), 4, 11), padW(FSPEED(w, r), 4, 11));
+    }
+    console.log("  " + w.toFixed(4).padStart(6) + cells.join(""));
+  }
+  console.log();
+}
+
+// ── 3. can the front be a circle / sphere ────────────────────────────────────
+
+console.log("─".repeat(76));
+console.log("3. IS THERE A w THAT ROUNDS THE FRONT?");
+console.log("   every class has to travel at the same speed, so the question is");
+console.log("   whether max/min over the classes can be brought to 1.\n");
+
+for (const d of [2, 3]) {
+  const hs = Array.from({ length: d }, (_, i) =>
+    stepsW(d).find(s => rankW(s) === i + 1) as number[]);
+  console.log("  d = " + d + ":");
+  console.log("     w    " + hs.map((_, i) => ("rankW" + (i + 1)).padStart(10)).join("")
+    + "    max/min");
+  let bestW = NaN, bestR = Infinity;
+  for (let i = 0; i <= 1000; i++) {
+    const w = i / 1000;
+    const vs = hs.map(h => normW(meanStepW(h, w)));
+    const ratio = Math.max(...vs) / Math.min(...vs);
+    if (ratio < bestR) { bestR = ratio; bestW = w; }
+  }
+  for (const w of [0, 0.5, bestW, 1]) {
+    const vs = hs.map(h => normW(meanStepW(h, w)));
+    console.log("  " + w.toFixed(4).padStart(6) + vs.map(v => padW(v, 4, 10)).join("")
+      + padW(Math.max(...vs) / Math.min(...vs), 4, 11)
+      + (w === bestW ? "   ← best" : ""));
+  }
+  console.log("    best max/min over w ∈ [0,1]:  " + bestR.toFixed(6)
+    + "  at w = " + bestW.toFixed(3));
+  console.log();
+}
+
+// ── 4. the two-dimensional sheet, which is what the article's k uses ─────────
+
+console.log("─".repeat(76));
+console.log("4. THE EMISSION SHEET, which is where the article's k comes from");
+console.log("   The sheet is a coordinate plane, so in 3D it holds rankW-1 and rankW-2");
+console.log("   headings only — no corners. The article's k = 1 is the claim that");
+console.log("   those two travel at the same speed at w = 0.8787.\n");
+
+{
+  const f = [1, 0, 0], e = [1, 1, 0];
+  console.log("     w      face      edge   edge/face      art edge/face");
+  for (const w of [0, 0.3, 0.5858, 0.8787, 1]) {
+    const vf = normW(meanStepW(f, w)), ve = normW(meanStepW(e, w));
+    console.log("  " + w.toFixed(4).padStart(6) + padW(vf, 4, 10) + padW(ve, 4, 10)
+      + padW(ve / vf, 4, 12) + padW(FSPEED(w, 2) / FSPEED(w, 1), 4, 18));
+  }
+  // solve both
+  const solve = (f2: (w: number) => number) => {
+    let lo = 0, hi = 4;
+    if (f2(lo) * f2(hi) > 0) return NaN;
+    for (let i = 0; i < 200; i++) { const m = (lo + hi) / 2; if (f2(lo) * f2(m) <= 0) hi = m; else lo = m; }
+    return (lo + hi) / 2;
+  };
+  const wShip = solve(w => normW(meanStepW(e, w)) / normW(meanStepW(f, w)) - 1);
+  const wArt = solve(w => FSPEED(w, 2) / FSPEED(w, 1) - 1);
+  console.log("\n    w that equalises them, shipped rule : " + wShip.toFixed(6)
+    + (wShip > 1 ? "   ← OUTSIDE [0,1]" : ""));
+  console.log("    w that equalises them, wander.tsx   : " + wArt.toFixed(6)
+    + "   = 3(1 − 1/√2)");
+  console.log("    closed forms: shipped √2(1 − w/4) = 1 → w = 4(1 − 1/√2) = "
+    + (4 * (1 - Math.SQRT1_2)).toFixed(6));
+  console.log("                  article √2(1 − w/3) = 1 → w = 3(1 − 1/√2) = "
+    + (3 * (1 - Math.SQRT1_2)).toFixed(6));
+  console.log("\n    and the best the shipped rule can do inside [0,1] is at w = 1:");
+  console.log("      edge/face = √2 · 3/4 = " + (Math.SQRT2 * 0.75).toFixed(6)
+    + "   — a " + ((Math.SQRT2 * 0.75 - 1) * 100).toFixed(2) + "% front anisotropy");
+}
+
+// ── 5. where the difference comes from ───────────────────────────────────────
+
+console.log("\n" + "─".repeat(76));
+console.log("5. WHERE THE DIFFERENCE COMES FROM\n");
+console.log("  For a rankW-2 heading (1,1,0) in three dimensions the shipped rule");
+console.log("  offers FOUR alternatives — (1,0,0) (0,1,0) (1,1,1) (1,1,−1) — and the");
+console.log("  heading itself is NOT among them, so");
+console.log("      ⟨step⟩ = (1−w)(1,1,0) + (w/4)(3,3,0) = (1 − w/4)(1,1,0)");
+console.log("  whereas `wander.tsx` models a three-member cone that DOES include the");
+console.log("  heading — {(1,1), (1,0), (0,1)} — giving");
+console.log("      ⟨step⟩ = (1−w)(1,1) + (w/3)(2,2) = (1 − w/3)(1,1)");
+console.log("  A quarter where the shipped rule has a quarter of four alternatives,");
+console.log("  a third where the article has a third of three. That is the whole gap,");
+console.log("  and it moves the rounding w from 0.8787 to 1.1716, which does not exist.");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
index 7586a7d..4dd7ee0 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
@@ -331,15 +331,29 @@ const coefficient = (s: Surface) => {
 
 // ---------------------------------------------------------------------------
 
-const Panel = ({ paint, height, note }: {
-  paint: (s: Surface) => void; height: number; note: string;
+/**
+ * A picture and, if it has one, the line above it.
+ *
+ * Two things that are not decoration. A panel with nothing to say gets no
+ * caption strip at all — an empty one still takes its line, and on a picture
+ * that has just had its text removed that is exactly the space that is missed.
+ * And `aspect` is for the panels whose contents are a ROW OF ROUND THINGS: a
+ * disk cannot be wider than it is tall, so a row of five across a wide column
+ * is height-bound by the column and no fixed height will ever be filled — the
+ * box has to take its height from its own width instead. Give one or the
+ * other; `aspect` wins where both are given.
+ */
+const Panel = ({ paint, height, aspect, note }: {
+  paint: (s: Surface) => void; height?: number; aspect?: number; note?: string;
 }) =>
   <div style={{ marginBottom: "1.1rem" }}>
-    <div style={{
+    {note && <div style={{
       fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
       color: FAINT, marginBottom: 6,
-    }}>{note}</div>
-    <div style={{ height, background: BACK }}>
+    }}>{note}</div>}
+    <div style={aspect
+      ? { width: "100%", aspectRatio: String(aspect), background: BACK }
+      : { height, background: BACK }}>
       <CanvasView deps={[note]} paint={() => ({ frame: paint })} />
     </div>
   </div>;
@@ -865,65 +879,111 @@ export const WanderForward = ({ height = 235 }: { height?: number }) =>
     note="forward-only: you may deviate, but only into a direction you are already going" />;
 
 // ---------------------------------------------------------------------------
-// THE PATH DISTRIBUTION ITSELF, SWEPT THROUGH w — the veins, exactly.
+// THE PATH DISTRIBUTION ITSELF, SWEPT THROUGH w — where a charge IS after t
+// steps, and nothing else.
+//
+// No normalisation and no circle drawn over it. An earlier version of this
+// panel divided every cell by the mean at its own radius, which takes the
+// answer to "what shape is this" and replaces it with "how does it vary at
+// fixed radius" — the falloff is gone and so is the shape, and a dashed circle
+// was drawn on top to say where the front should have been. That is a picture
+// of a circle whatever the model does. What is drawn now is the raw
+// probability after `ticks` steps, so the shape in the picture is the model's.
+//
+// THE RULE IS THE ONE THAT SHIPS. `discrete.ts` (~1366) builds the alternatives
+// one per axis: an axis the heading uses is TAKEN APART and contributes that
+// axis on its own, an axis it does not use contributes the heading with ±1
+// ADDED on it. In the plane that gives
+//
+//     (1,0)  →  (1,0) (1,1) (1,−1)     three, and the heading is among them
+//     (1,1)  →  (1,0) (0,1)            two, and the heading is NOT
 //
-// Under forward-only wander a heading's candidates are the lattice directions
-// with a positive projection on it, which in the plane is always THREE. So a
-// walk of t ticks is a TRINOMIAL over (how many of each), and the field can be
-// enumerated rather than sampled — every path, with its exact weight.
+// which is a trinomial either way, so the field is enumerated exactly rather
+// than sampled — every path with its exact weight.
 //
-// What the veins are: a face heading's cone is {(1,0), (1,1), (1,−1)}, and
-// every one of those has x = 1. So after t ticks x = t EXACTLY, whatever the
-// path — the face front is a flat bar at x = t that spreads only sideways.
-// A diagonal's cone is {(1,0), (1,1), (0,1)}, which does not fix anything, so
-// it spreads into a wedge. Bars where the axes are, wedges between them: that
-// is the vein structure, and it is a fact about which directions share a
-// component rather than about any parameter.
+// WHAT THE VEINS ARE. Every alternative of a face heading has x = 1, so after t
+// steps x = t exactly whatever path was taken: the face front is a flat bar
+// that spreads only sideways. A diagonal's alternatives share nothing, so it
+// opens into a wedge. Bars where the axes are and wedges between them — a fact
+// about which directions share a component, not about any parameter, which is
+// why sweeping w moves the front without ever filling the wedges.
+
+/** the shipped alternatives for a heading, in the plane */
+const WAYS_2D = (h: [number, number]): [number, number][] => {
+  const out: [number, number][] = [];
+  for (let a = 0; a < 2; a++) {
+    if (h[a]) out.push(a === 0 ? [h[0], 0] : [0, h[1]]);
+    else for (const s of [1, -1] as const) out.push(a === 0 ? [s, h[1]] : [h[0], s]);
+  }
+  return out;
+};
 
-const CONE2 = (h: [number, number]) =>
-  SHEET_2D.filter(d => d[0] * h[0] + d[1] * h[1] > 1e-9);
+/**
+ * The three outcomes of one step off `h`, with their probabilities: carry
+ * straight on with 1 − w, otherwise one of the alternatives uniformly. The
+ * heading reappearing among a face's alternatives is why a face keeps some
+ * weight on going straight even at w = 1, and why its speed is 1 for every w.
+ */
+const STEP_2D = (h: [number, number], w: number) => {
+  const alt = WAYS_2D(h);
+  const acc = new Map<string, { d: [number, number], p: number }>();
+  const put = (d: [number, number], p: number) => {
+    const k = d[0] + "," + d[1];
+    const e = acc.get(k);
+    if (e) e.p += p; else acc.set(k, { d, p });
+  };
+  put(h, 1 - w);
+  for (const d of alt) put(d, w / alt.length);
+  return [...acc.values()].filter(e => e.p > 1e-15);
+};
 
 /**
- * STEADY-STATE OCCUPANCY — where the charges ARE, not where one pulse got to.
+ * WHERE THE TRAVELLED PATHS HAVE GOT TO after `t` steps — every path with its
+ * exact weight, summed over the eight headings and over every age up to `t`,
+ * because a source pulses every tick and what fills the picture is charges of
+ * every age in flight at once.
  *
- * The panel above this one draws a single pulse at age `t`, which is a shell
- * and therefore a ring with nothing inside it. That is not what a source looks
- * like. A source pulses every tick, so at any moment there are charges of every
- * age in flight at once, and what fills the picture is the SUM over ages —
- * which is the quantity `chance(m,r)` is about.
+ * Each cell is then divided by the mean at its own RADIUS. That takes the 1/r
+ * falloff out and leaves the angular structure, which is the whole point of the
+ * picture: at a given distance, where is the field thick and where is it thin.
+ * Without it the outer three quarters of every disk is below one part in a
+ * thousand of the middle and the veins are invisible under any alpha ramp.
  *
- * Each cell is then drawn against the MEAN AT ITS OWN RADIUS, so the 1/r
- * falloff divides out and what is left is purely angular: where, at a given
- * distance, the field is thick and where it is thin. That is the vein.
+ * What is NOT done to it: nothing is clipped and no circle is drawn. The
+ * diagonal spikes run out past `t` to √2·t and are left there, so the outline
+ * in the picture is the shape the rule actually makes rather than a ring
+ * imposed on top of it.
  */
-const veinField = (t: number, w: number) => {
+const pulseField = (t: number, w: number) => {
   const raw = new Map<string, number>();
 
   for (const h of SHEET_2D) {
-    const C = CONE2(h), m = C.length;
-    const rest = C.filter(c => c !== h);
-    const ps = [(1 - w) + w / m, w / m, w / m];
-    const st = [h, ...rest];
-
+    const st = STEP_2D(h, w);
+    if (st.length === 1) {                       // nothing to choose: one ray
+      for (let age = 1; age <= t; age++) {
+        const k = st[0].d[0] * age + "," + st[0].d[1] * age;
+        raw.set(k, (raw.get(k) ?? 0) + 1 / 8);
+      }
+      continue;
+    }
+    const [A, B, C] = [st[0], st[1], st[2] ?? { d: [0, 0] as [number, number], p: 0 }];
     for (let age = 1; age <= t; age++)
       for (let a = 0; a <= age; a++)
         for (let b = 0; b <= age - a; b++) {
           const c = age - a - b;
+          if (c > 0 && C.p === 0) continue;
           const lp = lfac(age) - lfac(a) - lfac(b) - lfac(c)
-            + a * Math.log(Math.max(ps[0], 1e-300))
-            + b * Math.log(Math.max(ps[1], 1e-300))
-            + c * Math.log(Math.max(ps[2], 1e-300));
+            + a * Math.log(A.p) + b * Math.log(B.p)
+            + (c ? c * Math.log(C.p) : 0);
           const p = Math.exp(lp);
-          if (p < 1e-10) continue;
-
-          const x = a * st[0][0] + b * st[1][0] + c * st[2][0];
-          const y = a * st[0][1] + b * st[1][1] + c * st[2][1];
+          if (p < 1e-11) continue;
+          const x = a * A.d[0] + b * B.d[0] + c * C.d[0];
+          const y = a * A.d[1] + b * B.d[1] + c * C.d[1];
           const k = x + "," + y;
           raw.set(k, (raw.get(k) ?? 0) + p / 8);
         }
   }
 
-  // divide out the radial falloff: each cell against the mean at its radius
   const sum = new Map<number, number>(), count = new Map<number, number>();
   for (const [k, v] of raw) {
     const [x, y] = k.split(",").map(Number);
@@ -941,48 +1001,258 @@ const veinField = (t: number, w: number) => {
   return out;
 };
 
-const EXACT_W = 3 * (1 - Math.SQRT1_2);
+/**
+ * The enumeration does not depend on the size of the box and the box is
+ * repainted every frame, so it is worked out once per (t, w) and kept.
+ */
+const VEINS = new Map<string, Map<string, number>>();
+
+const vein = (t: number, w: number) => {
+  const key = t + ":" + w;
+  let f = VEINS.get(key);
+  if (!f) VEINS.set(key, f = pulseField(t, w));
+  return f;
+};
+
+/**
+ * 2(1 − 1/√2). The w at which the shipped rule's diagonal crest and face crest
+ * sit at the same radius — √2(1 − w/2) = 1 — and so the only w at which its
+ * front is a circle in the plane. It is NOT the 3(1 − 1/√2) used elsewhere in
+ * this file, which belongs to a three-member cone that includes the heading for
+ * a diagonal as well; see `tests/ways.ts`.
+ */
+const SHIP_W = 2 * (1 - Math.SQRT1_2);
 
 const veins = (t: number) => (s: Surface) => {
-  const { ctx, width, height } = s;
+  let { ctx, width, height } = s;
   ctx.clearRect(0, 0, width, height);
   ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
 
-  const ws = [0, 0.3, 0.6, EXACT_W, 1];
-  const cw = width / ws.length, R = Math.min(cw / 2 - 8, (height - 56) / 2);
-  const scale = R / t;
+  const TOP = 18, BOT = 2, GAP = 6;
+
+  const ws = [0, 0.3, SHIP_W, 0.8, 1];
+  const cw = width / ws.length;
+  const R = Math.min(cw / 2 - GAP / 2, (height - TOP - BOT) / 2);
+  const scale = R / (t * Math.SQRT2);            // room for the √2·t corners
+  const top = TOP + Math.max(0, (height - TOP - BOT - 2 * R) / 2);
 
   ws.forEach((w, col) => {
-    const F = veinField(t, w), cx = cw * (col + 0.5), cy = 26 + R;
+    const F = vein(t, w), cx = cw * (col + 0.5), cy = top + R;
     let peak = 0;
     for (const v of F.values()) peak = Math.max(peak, v);
 
     const px = Math.max(1.4, scale * 1.15);
     for (const [k, v] of F) {
       const [x, y] = k.split(",").map(Number);
-      if (Math.hypot(x, y) > t) continue;
       ctx.globalAlpha = Math.min(1, Math.pow(Math.min(v / peak, 1), 0.55));
       ctx.fillStyle = MODEL;
       ctx.fillRect(cx + x * scale - px / 2, cy - y * scale - px / 2, px, px);
     }
+    ctx.globalAlpha = 1;
 
-    ctx.globalAlpha = 0.35;
-    ctx.strokeStyle = DATA; ctx.setLineDash([3, 3]);
-    ctx.beginPath(); ctx.arc(cx, cy, t * scale, 0, Math.PI * 2); ctx.stroke();
-    ctx.setLineDash([]); ctx.globalAlpha = 1;
-
-    const diag = (1 - w) * Math.SQRT2 + w * 2 * Math.SQRT2 / 3;
     ctx.fillStyle = INK; ctx.textAlign = "center";
     ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
-    ctx.fillText("w = " + (w === EXACT_W ? w.toFixed(4) : w.toFixed(2)), cx, 14);
+    ctx.fillText("w = " + (w === SHIP_W ? w.toFixed(4) : w.toFixed(2)), cx, 12);
   });
+};
 
-  ctx.fillStyle = FAINT;
+export const WanderVeins = ({ ticks = 22, height, aspect = 5.6 }: {
+  ticks?: number, height?: number, aspect?: number,
+}) =>
+  <Panel paint={veins(ticks)} height={height} aspect={height ? undefined : aspect} />;
+
+// ---------------------------------------------------------------------------
+// WHAT ACTUALLY CLOSES THE CIRCLE — the same eight directions, four ways.
+//
+// The panel above shows a charge that keeps the heading it left with. That is
+// the collisionless case and it is beams: the field is thick along the eight
+// lattice headings and thin between them, at every radius, for ever.
+//
+// This one puts something in the way. The lattice, the eight directions and the
+// pulse are identical; the only thing that changes across the row is how much
+// else is already in flight for it to run into. The rule for what happens when
+// it does is as small as a rule can be:
+//
+//     two charges meet head-on  →  they come out sideways, still head-on
+//     anything else             →  nothing happens
+//
+// No turn rate, no cone, no weights, nothing that looks at a neighbourhood, and
+// a lone charge in empty space still goes perfectly straight for ever. The
+// outcome keeps the count and keeps the total momentum, and that is the whole
+// of it.
+//
+// WHAT TO LOOK AT. Column one is eight spots, and the diagonal ones are further
+// out than the face ones by √2 — the front is not a circle, it is not even a
+// closed curve. By column three the gaps are gone. Nothing was tuned to make
+// that happen; the only difference is that there is now something to hit.
+//
+// AND WHY IT IS NOT ENOUGH ON ITS OWN. Scattering fills the angles and loses
+// the light cone — a charge knocked about at random spreads as √t rather than
+// travelling. What brings the cone back is the last column, where the collisions
+// are frequent enough that the disturbance stops being carried by any particular
+// charge. Momentum cannot be destroyed, so an excess of it at a cell has to be
+// handed to the next one, and the hand-off travels at a fixed speed because the
+// push is the same in every direction. NOTHING GOES ROUND THE CIRCLE. No charge
+// crosses more than a few cells before it is turned; what reaches the far side
+// never started at the middle. The front is a relay, and it is round because
+// the pressure behind it is.
+
+const SQ8: [number, number][] = [
+  [1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1],
+];
+
+/** head-on pairs rotate; every other cell state is left alone */
+const SWAP = (() => {
+  const main = new Uint8Array(256), alt = new Uint8Array(256);
+  for (let s = 0; s < 256; s++) { main[s] = s; alt[s] = s; }
+  for (let i = 0; i < 4; i++) {
+    const h = (1 << i) | (1 << (i + 4));
+    main[h] = (1 << ((i + 1) % 8)) | (1 << ((i + 5) % 8));
+    alt[h] = (1 << ((i + 7) % 8)) | (1 << ((i + 3) % 8));
+  }
+  return { main, alt };
+})();
+
+let GSEED = 20260814;
+const grnd = () => (GSEED = (GSEED * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+
+/** the gas: bits per direction, streaming, and the swap above */
+const gasField = (T: number, d: number, runs: number) => {
+  const L = 2 * Math.ceil(Math.SQRT2 * T) + 5, o = (L - 1) / 2, C = L * L;
+  const acc = new Float64Array(C);
+
+  for (let k = 0; k < runs; k++) {
+    let cur = new Uint8Array(C), nxt = new Uint8Array(C);
+    if (d > 0) for (let c = 0; c < C; c++) {
+      let s = 0;
+      for (let i = 0; i < 8; i++) if (grnd() < d) s |= 1 << i;
+      cur[c] = s;
+    }
+    for (let y = -2; y <= 2; y++) for (let x = -2; x <= 2; x++)
+      if (x * x + y * y <= 4) cur[(y + o) * L + (x + o)] = 255;
+
+    for (let t = 0; t < T; t++) {
+      nxt.fill(0);
+      for (let y = 0; y < L; y++) for (let x = 0; x < L; x++) {
+        const s = cur[y * L + x];
+        if (!s) continue;
+        const out = ((x + y) & 1) ? SWAP.alt[s] : SWAP.main[s];
+        for (let i = 0; i < 8; i++) {
+          if (!(out & (1 << i))) continue;
+          nxt[((y + SQ8[i][1] + L) % L) * L + ((x + SQ8[i][0] + L) % L)] |= 1 << i;
+        }
+      }
+      const tmp = cur; cur = nxt; nxt = tmp;
+    }
+    for (let c = 0; c < C; c++) {
+      let n = 0;
+      for (let i = 0; i < 8; i++) if (cur[c] & (1 << i)) n++;
+      acc[c] += n;
+    }
+  }
+  for (let c = 0; c < C; c++) acc[c] = acc[c] / runs - 8 * d;
+  return { L, o, v: acc };
+};
+
+/**
+ * The same thing where collisions are frequent enough that the disturbance is
+ * no longer carried by any particular charge — the limit the gas is heading
+ * towards, run directly so the row ends somewhere rather than trailing off.
+ */
+const CW = [4 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 36, 1 / 36, 1 / 36, 1 / 36];
+const LX = [0, 1, 0, -1, 0, 1, -1, -1, 1], LY = [0, 0, 1, 0, -1, 1, 1, -1, -1];
+
+const relayField = (T: number, tau = 0.8) => {
+  const L = 2 * Math.ceil(Math.SQRT2 * T) + 9, o = (L - 1) / 2, C = L * L;
+  let f = new Float64Array(C * 9), g = new Float64Array(C * 9);
+  for (let c = 0; c < C; c++) for (let i = 0; i < 9; i++) f[c * 9 + i] = CW[i];
+  for (let i = 0; i < 9; i++) f[(o * L + o) * 9 + i] += 0.02 * CW[i];
+
+  for (let t = 0; t < T; t++) {
+    for (let y = 0; y < L; y++) for (let x = 0; x < L; x++) {
+      const c = y * L + x;
+      let r = 0, mx = 0, my = 0;
+      for (let i = 0; i < 9; i++) { const v = f[c * 9 + i]; r += v; mx += v * LX[i]; my += v * LY[i]; }
+      const vx = mx / r, vy = my / r, u2 = vx * vx + vy * vy;
+      for (let i = 0; i < 9; i++) {
+        const cu = LX[i] * vx + LY[i] * vy;
+        const eq = CW[i] * r * (1 + 3 * cu + 4.5 * cu * cu - 1.5 * u2);
+        g[(((y + LY[i] + L) % L) * L + ((x + LX[i] + L) % L)) * 9 + i]
+          = f[c * 9 + i] - (f[c * 9 + i] - eq) / tau;
+      }
+    }
+    const tmp = f; f = g; g = tmp;
+  }
+  const v = new Float64Array(C);
+  for (let c = 0; c < C; c++) {
+    let r = 0;
+    for (let i = 0; i < 9; i++) r += f[c * 9 + i];
+    v[c] = r - 1;
+  }
+  return { L, o, v };
+};
+
+/** each column is worked out once and kept — the box repaints, the physics does not */
+const MEDIA = new Map<string, { L: number, o: number, v: Float64Array }>();
+const medium = (key: string, make: () => { L: number, o: number, v: Float64Array }) => {
+  let f = MEDIA.get(key);
+  if (!f) MEDIA.set(key, f = make());
+  return f;
+};
+
+const media = (t: number) => (s: Surface) => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+  const cols: [string, string, () => { L: number, o: number, v: Float64Array }][] = [
+    ["nothing in the way", "eight beams", () => gasField(t, 0, 1)],
+    ["a little", "the gaps start to fill", () => gasField(t, 0.10, 14)],
+    ["more", "the gaps are gone", () => gasField(t, 0.30, 14)],
+    ["enough to relay", "a front, at one speed", () => relayField(t)],
+  ];
+
+  const TOP = 30, BOT = 16, GAP = 6;
+  const cw = width / cols.length;
+  const R = Math.min(cw / 2 - GAP / 2, (height - TOP - BOT) / 2);
+  const scale = R / (t * Math.SQRT2);
+  const top = TOP + Math.max(0, (height - TOP - BOT - 2 * R) / 2);
+
+  cols.forEach(([head, foot, make], col) => {
+    const F = medium(head + ":" + t, make);
+    const cx = cw * (col + 0.5), cy = top + R;
+
+    let peak = 0;
+    for (const v of F.v) peak = Math.max(peak, v);
+
+    const px = Math.max(1.3, scale * 1.2);
+    for (let y = -F.o; y <= F.o; y++) for (let x = -F.o; x <= F.o; x++) {
+      const v = F.v[(y + F.o) * F.L + (x + F.o)];
+      if (v <= 0) continue;
+      ctx.globalAlpha = Math.min(1, Math.pow(v / peak, 0.45));
+      ctx.fillStyle = MODEL;
+      ctx.fillRect(cx + x * scale - px / 2, cy - y * scale - px / 2, px, px);
+    }
+    ctx.globalAlpha = 1;
+
+    ctx.textAlign = "center";
+    ctx.fillStyle = INK;
+    ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText(head, cx, 13);
+    ctx.fillStyle = FAINT;
+    ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+    ctx.fillText(foot, cx, 25);
+  });
+
+  ctx.fillStyle = FAINT; ctx.textAlign = "center";
+  ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+  ctx.fillText("same eight directions, same pulse — only how much else is in flight changes",
+    width / 2, height - 4);
 };
 
-export const WanderVeins = ({ ticks = 22, height = 150 }: { ticks?: number, height?: number }) =>
-  <Panel paint={veins(ticks)} height={height}
-    note="" />;
+export const WanderMedium = ({ ticks = 26, height = 210 }: { ticks?: number, height?: number }) =>
+  <Panel paint={media(ticks)} height={height} />;
+
 
 export const WanderPattern = ({ ticks = 28, height = 260 }: { ticks?: number, height?: number }) =>
   <Panel paint={pattern(ticks)} height={height}

From 4dba380bd1a0c19edc343ba7c9f0c82f7119dd1d Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Fri, 14 Aug 2026 17:33:14 +0200
Subject: [PATCH 40/47] Vacuum dynamics + gravity movement

---
 orbitmines.com/src/routes/Physics.tsx         |  18 +-
 .../2026.RayCalculiAndPhysics/tests/README.md |   2 +
 .../2026.RayCalculiAndPhysics/tests/pure.ts   | 181 +++++
 .../2026.RayCalculiAndPhysics/tests/run.sh    |   2 +-
 .../2026.RayCalculiAndPhysics/tests/vacuum.ts | 280 +++++++
 .../2026.RayCalculiAndPhysics/wander.tsx      | 709 +++++++++++++++++-
 6 files changed, 1188 insertions(+), 4 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pure.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/vacuum.ts

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index 9f74ada..4d3d8f7 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -18,7 +18,7 @@ import {
 } from "./archive/2026.RayCalculiAndPhysics/law";
 import { gravitational, massUnit } from "./archive/2026.RayCalculiAndPhysics/gravity";
 import { lineGroups } from "./archive/2026.RayCalculiAndPhysics/lines";
-import { Wander, WanderBlind, WanderForward, WanderMedium, WanderPaths, WanderVeins } from "./archive/2026.RayCalculiAndPhysics/wander";
+import { Wander, WanderBlind, WanderExpand, WanderForward, WanderGravity, WanderPaths, WanderPure, WanderRelay, WanderVeins } from "./archive/2026.RayCalculiAndPhysics/wander";
 import { Model } from "./archive/2026.RayCalculiAndPhysics/model";
 import { asGroup, MODELS, weighed } from "./archive/2026.RayCalculiAndPhysics/models";
 import { PACE, Polarity } from "./archive/2026.RayCalculiAndPhysics/physics";
@@ -246,6 +246,8 @@ const Physics = () => {
 
         <Head>Movement</Head>
 
+        <WanderExpand/>
+
         There's a real assumption to made here at the beginning. Which is how does one from a perspective of discreteness, recover rays propagating in a circle. That's making the assumption you'd want it to propegate in a circle in the first place - whether that's the actual accurate model. Also to consider would be that a large surface of stuff sending out rays could more accurately describe a circle, than say a single point with a local neighbourhood. This is essentially a statement of discrete movement, how should that happen? Where as the aggregate we might see a sphere, a cube, a (curved) diamond-shape. All are these are technically possibilities. We could imagine a world where discretized effects matter here for the spread of those rays.
 
         <BR/>
@@ -270,6 +272,16 @@ const Physics = () => {
 
         <BR/>
 
+        Namely if we consider vacuum dynamics. In the pure gravity setting (so discounting the magnetism part which we haven't gotten to yet: XOR), we don't have vacuum dynamics other than just expansion of a space. See for instance the following example of how space would expand because of the creation rule if nothing is nearby:
+
+        <WanderExpand/>
+
+        <WanderPure/>
+
+        <WanderGravity/>
+
+        <BR/>
+
         Then a related number to dimension, all possible paths out of a point (the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "degree", link: "https://en.wikipedia.org/wiki/Degree_(graph_theory)"}}/> assuming diagonals are included). 
 
         <Eq>
@@ -358,7 +370,9 @@ const Physics = () => {
           Whenever there's a derived equation, you can click on it to see how it was derived! Try it!
 
           <Para>
-            The second thing, not used for the rest of this model: Turn the period into a length of how far light travels within that timeframe, and you get something proportional to the <Ref of={'reduced Compton wavelength'} at="https://en.wikipedia.org/wiki/Compton_wavelength#Reduced_Compton_wavelength" /> <Footnote of={'Compton, "A Quantum Theory of the Scattering of X-rays by Light Elements", Phys. Rev. 21:483'} year="1923" at="https://doi.org/10.1103/PhysRev.21.483" />. (<i><K><Bar>G</Bar></K></i> here being the gravitational constant of the model)
+            <span className="bp5-text-muted">
+              The second thing, not used for the rest of this model: Turn the period into a length of how far light travels within that timeframe, and you get something proportional to the <Ref of={'reduced Compton wavelength'} at="https://en.wikipedia.org/wiki/Compton_wavelength#Reduced_Compton_wavelength" /> <Footnote of={'Compton, "A Quantum Theory of the Scattering of X-rays by Light Elements", Phys. Rev. 21:483'} year="1923" at="https://doi.org/10.1103/PhysRev.21.483" />. (<i><K><Bar>G</Bar></K></i> here being the gravitational constant of the model)
+            </span>
           </Para>
 
           <Eq derive={CLOCK}>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
index 201b5e9..f5d3c0f 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
@@ -27,6 +27,8 @@ than as silent agreement.
 | `turns` | why a turn is eight ticks in every dimension |
 | `ways` | **the shipped wander against the one `wander.tsx` models** — they are not the same rule, and in 3D no `w` puts the emission sheet on a circle |
 | `veins` | what the ridges do with distance, cone shape and an extended emitter, and what all of it does to light |
+| `vacuum` | **the medium is the expansion** — new room is edged on every axis and thins what is already there, so the density is (1−p)/(2−p) → ½ with no parameter, and the front closes |
+| `vacuum` | **the medium is the expansion** — new room is edged on every axis and thins what is already there, so the density is (1−p)/(2−p) → ½ with no parameter, and the front closes |
 | `gas` | **the fully discrete version** — bits per direction, streaming, and a momentum-conserving swap on head-on pairs; the front is beams with no medium and closed and round with one |
 | `wave` | **the same lattice propagating as a wave instead of a ray** — the front is a circle at the sound speed and the grain vanishes as the pulse widens |
 | `lattices` | **which space gives a sphere** — a sweep of spatial constructions against the spherical-design condition, and the shell search that finds 26 directions exact through rank 6 |
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pure.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pure.ts
new file mode 100644
index 0000000..5d649dd
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/pure.ts
@@ -0,0 +1,181 @@
+/**
+ * PURE GRAVITY, NO POLARITY — and it is not noisy, which is the surprise.
+ *
+ * The other files here run charges that carry a heading and turn when they
+ * meet. Strip the polarity out and the rule gets shorter, not longer:
+ *
+ *     EVERY EDGE EXPANDS, EVERY TICK. A point sends one charge along each of
+ *     its edges. Every charge is destroyed at the point it lands on, and that
+ *     destruction is what makes the next one — a point that received k sends k
+ *     back out. Nothing is created or lost anywhere except at a BODY, which
+ *     takes what arrives and sends nothing.
+ *
+ * There is no heading to remember, because a charge does not survive a step;
+ * it is destroyed and remade. There is no turn rate, no cone, no collision
+ * table and no distribution.
+ *
+ * WHAT THE UNIFORM CASE DOES, which is the thing worth checking first: with
+ * every point full, every point sends eight and receives eight, every tick, for
+ * ever. The vacuum is EXACTLY balanced. What fluctuates is only WHICH edges
+ * carry the charges when a point has fewer than eight to send — the connections
+ * move about while the occupancy does not — and §1 measures how little that
+ * amounts to.
+ *
+ * WHICH EDGE GETS SKIPPED is the one real choice, and there are two honest ways
+ * to make it: at random, or by letting the skipped edge walk round the point one
+ * step at a time. Both are run below. The second is deterministic and has no
+ * randomness anywhere in it, which is why the force comes out to three figures
+ * with no averaging at all — the opposite of the polarity case, where gravity
+ * only appears as a √n residue over hundreds of ticks.
+ *
+ * Run: ./run.sh pure
+ */
+
+const PD8: [number, number][] = [
+  [1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1],
+];
+
+type Mode = "round" | "random";
+
+/**
+ * The box edge is held full, which is the rest of space: without it a body
+ * drains a periodic universe and the steady state is empty everywhere.
+ */
+const sim = (L: number, T: number, bodies: [number, number][], R: number, mode: Mode) => {
+  const o = (L - 1) / 2, C = L * L;
+  let q = new Uint8Array(C).fill(8), nq = new Uint8Array(C);
+  const phase = new Uint8Array(C), body = new Uint8Array(C);
+  for (const [bx, by] of bodies)
+    for (let y = -R; y <= R; y++) for (let x = -R; x <= R; x++)
+      if (x * x + y * y <= R * R) body[(by + y + o) * L + (bx + x + o)] = 1;
+  const rim = (x: number, y: number) => x <= -o + 1 || x >= o - 1 || y <= -o + 1 || y >= o - 1;
+
+  const F = bodies.map(() => [0, 0]);
+  let churn = 0, cn = 0, taken = 0;
+
+  for (let t = 1; t <= T; t++) {
+    nq.fill(0);
+    for (let y = -o; y <= o; y++) for (let x = -o; x <= o; x++) {
+      const c = (y + o) * L + (x + o);
+      if (body[c]) { if (t > T / 2) taken += q[c]; continue; }
+      const k = rim(x, y) ? 8 : q[c];
+      if (!k) continue;
+      if (mode === "round") {
+        const p = phase[c];
+        for (let j = 0; j < k; j++) {
+          const i = (p + j) & 7;
+          nq[((y + PD8[i][1] + o + L) % L) * L + ((x + PD8[i][0] + o + L) % L)]++;
+        }
+        phase[c] = (p + k) & 7;                  // the skipped edge walks round
+      } else {
+        const pick = [0, 1, 2, 3, 4, 5, 6, 7];
+        for (let j = 7; j > 0; j--) {
+          const r = (Math.random() * (j + 1)) | 0;
+          const tv = pick[j]; pick[j] = pick[r]; pick[r] = tv;
+        }
+        for (let j = 0; j < k; j++) {
+          const i = pick[j];
+          nq[((y + PD8[i][1] + o + L) % L) * L + ((x + PD8[i][0] + o + L) % L)]++;
+        }
+      }
+    }
+    const tt = q; q = nq; nq = tt;
+
+    if (t > T / 2) {
+      /**
+       * A charge arriving in direction i came from the cell one step back along
+       * i, and that cell sends q of its eight edges — so q/8 arrive from there,
+       * each carrying momentum i. An earlier version of this counted which
+       * neighbours EXIST rather than what they send, which is a fact about
+       * geometry, cancels by symmetry, and duly read exactly zero.
+       */
+      bodies.forEach((m, kk) => {
+        for (let y = -R; y <= R; y++) for (let x = -R; x <= R; x++) {
+          if (x * x + y * y > R * R) continue;
+          for (let i = 0; i < 8; i++) {
+            const sc = (m[1] + y - PD8[i][1] + o) * L + (m[0] + x - PD8[i][0] + o);
+            if (body[sc]) continue;
+            const w = q[sc] / 8;
+            F[kk][0] += PD8[i][0] * w; F[kk][1] += PD8[i][1] * w;
+          }
+        }
+      });
+      for (let y = -o + 8; y <= o - 8; y += 13) for (let x = -o + 8; x <= o - 8; x += 13) {
+        if (bodies.some(b => Math.hypot(x - b[0], y - b[1]) < 20)) continue;
+        churn += Math.abs(q[(y + o) * L + (x + o)] - 8); cn++;
+      }
+    }
+  }
+  const n = Math.floor(T / 2);
+  return { q, o, L, churn: churn / cn, taken: taken / n, F: F.map(f => [f[0] / n, f[1] / n]) };
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log("PURE GRAVITY — every edge expands, every arrival is destroyed and remade\n");
+
+console.log("─".repeat(76));
+console.log("1. THE FREE VACUUM IS STATIC\n");
+console.log("   With every point full, eight go out and eight come in and nothing");
+console.log("   changes. Below is how far from that it actually sits, far from any");
+console.log("   body — the connections move, the occupancy does not.\n");
+console.log("   which edge is skipped     mean |q − 8|   as a fraction");
+for (const mode of ["round", "random"] as Mode[]) {
+  const s = sim(101, 400, [[0, 0]], 2, mode);
+  console.log("   " + (mode === "round" ? "walks round the point" : "picked at random    ")
+    + s.churn.toFixed(4).padStart(14) + (s.churn / 8).toFixed(5).padStart(16));
+}
+console.log();
+
+console.log("─".repeat(76));
+console.log("2. AND A BODY DIGS A WELL IN IT\n");
+console.log("   the shortfall against radius, one body of radius 2 in a box of 101:\n");
+console.log("        r      deficit");
+{
+  const { q, o, L } = sim(101, 400, [[0, 0]], 2, "round");
+  for (const r of [4, 6, 9, 13, 19, 27, 38]) {
+    let s = 0, n = 0;
+    for (let y = -o; y <= o; y++) for (let x = -o; x <= o; x++) {
+      const d = Math.hypot(x, y);
+      if (d < r - 0.7 || d > r + 0.7) continue;
+      s += 8 - q[(y + o) * L + (x + o)]; n++;
+    }
+    console.log("      " + String(r).padStart(3) + (s / n).toFixed(4).padStart(13));
+  }
+}
+console.log();
+
+console.log("─".repeat(76));
+console.log("3. AND TWO BODIES PUSH EACH OTHER TOGETHER\n");
+console.log("   force = the momentum arriving, per tick. Nothing is averaged over");
+console.log("   realisations; the round-robin rule has no randomness in it at all.\n");
+console.log("      d    F(left)    F(right)   inward   |F|·d");
+for (const d of [8, 12, 18, 26]) {
+  const { F } = sim(141, 500, [[-d / 2 | 0, 0], [d / 2 | 0, 0]], 2, "round");
+  const m = (Math.abs(F[0][0]) + Math.abs(F[1][0])) / 2;
+  console.log("    " + String(d).padStart(3) + F[0][0].toFixed(3).padStart(11)
+    + F[1][0].toFixed(3).padStart(12)
+    + ((F[0][0] > 0 && F[1][0] < 0) ? "      yes" : "       NO")
+    + (m * d).toFixed(3).padStart(9));
+}
+console.log("\n   |F|·d roughly constant is F ∝ 1/d, which is what a shortfall spreading");
+console.log("   through a PLANE has to give — the Green's function of a two-dimensional");
+console.log("   conserving relay is a log, and the gradient of a log is 1/r. In three");
+console.log("   dimensions the same relay gives 1/r and so a force going as 1/r², which");
+console.log("   is the thing to check next and is not checked here.");
+console.log();
+console.log("   The last two rows fall below that because the box is only 141 across and");
+console.log("   its edge is held full: at d = 26 the well is already meeting the wall.\n");
+
+console.log("─".repeat(76));
+console.log("WHAT THIS SETTLES");
+console.log("  · the no-polarity rule is shorter than the one with polarity, not longer.");
+console.log("    No heading, no turn rate, no cone, no collision table — a charge does");
+console.log("    not survive a step, so there is nothing for it to remember.");
+console.log("  · expanding EVERYWHERE leaves the vacuum balanced to under a hundredth of");
+console.log("    a charge in eight. What moves is which edges carry, not how many.");
+console.log("  · a body is the only thing that breaks it, and what it breaks is the");
+console.log("    balance rather than the medium: it takes and does not give back.");
+console.log("  · so the force is DETERMINISTIC here. Three figures, no averaging, Newton's");
+console.log("    third law to the last digit — where the polarity case had to average");
+console.log("    hundreds of ticks to get gravity out of the shot noise at all.");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
index 5e97c5f..3d274c6 100755
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
@@ -31,7 +31,7 @@ ORDER=(
   recon which138 accum accumulate asym
   pulses magnets coulomb moment dipole poles ordering budget tradeoff scale maxwell
   nopolarity
-  turns ways veins cones veined lattices wave gas
+  turns ways veins cones veined lattices wave gas vacuum pure
 )
 
 if [ "${1:-}" = "--list" ]; then printf '%s\n' "${ORDER[@]}"; exit 0; fi
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/vacuum.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/vacuum.ts
new file mode 100644
index 0000000..87a66ab
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/vacuum.ts
@@ -0,0 +1,280 @@
+/**
+ * THE MEDIUM IS THE EXPANSION — which removes the last thing that had to be
+ * assumed.
+ *
+ * `gas` and `wave` between them said: a charge that remembers its heading is
+ * beams and veins for ever, and what closes the front is having something to
+ * collide with. That left the medium itself as a bare assumption — a vacuum
+ * that is occupied, at some density nobody had a reason for. This file removes
+ * both halves of that.
+ *
+ * THE PICTURE. Space is not a stage that was already there; it is being made,
+ * on every axis, all the time. A cell that has just been made is EDGED ON EVERY
+ * AXIS — and one of those edges points straight back down the line any incoming
+ * charge is arriving along. So a charge does not have to be lucky to meet
+ * something head-on. It meets something head-on because the room it is moving
+ * into was just built, and building it is what put the thing there.
+ *
+ * That does two things at once:
+ *
+ *   THE MEDIUM COSTS NOTHING EXTRA. It is not an addition to the model; it is
+ *   the expansion the model already has, seen from the side.
+ *
+ *   AND ITS DENSITY IS NOT A PARAMETER. The same expansion that lays down new
+ *   edges also thins out what is already there — more room, same charges. Both
+ *   at the same rate, because they are the same process. Write that down and
+ *   the equilibrium falls out with the rate cancelling:
+ *
+ *       f′ = [p + (1 − p) f] (1 − p)      →      f = (1 − p) / (2 − p)
+ *
+ *   which is ONE HALF as p → 0. Every direction of every cell occupied with
+ *   probability a half, and no number was chosen to make that happen. The slow
+ *   expansion limit is the physical one, so a half is the answer.
+ *
+ * Streaming and collisions move charges about but never create or destroy one,
+ * so neither appears in that balance — which is why it is so short.
+ *
+ * Run: ./run.sh vacuum
+ */
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+const D8_V: [number, number][] = [
+  [1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1],
+];
+
+/**
+ * HEAD-ON PAIRS COME OUT SIDEWAYS — whatever else is in the cell.
+ *
+ * The first version of this only acted on a cell holding EXACTLY one head-on
+ * pair and nothing else, which is four of the 256 states. In a thin gas that is
+ * a detail; in a medium at half occupancy it is fatal, because the chance of a
+ * cell being otherwise empty is 1/256 and the mean free path comes out at a
+ * hundred cells. That is an accident of how the table was written, not a
+ * property of the rule: two charges meeting head-on do not care what else is
+ * passing through.
+ *
+ * So: every axis is checked, and a pair is turned whenever the slots it would
+ * turnV into are free. Exclusion is respected (nothing is ever doubled up),
+ * count is unchanged, and the pair's momentum was zero before and after.
+ */
+const turnV = (s: number, sense: 1 | -1) => {
+  let out = s;
+  for (let i = 0; i < 4; i++) {
+    const a = 1 << i, b = 1 << (i + 4);
+    if ((out & a) === 0 || (out & b) === 0) continue;
+    const j = (i + (sense === 1 ? 1 : 7)) % 8;
+    const c = 1 << j, d = 1 << ((j + 4) % 8);
+    if (out & c || out & d) continue;              // no room to turnV into
+    out = (out & ~a & ~b) | c | d;
+  }
+  return out;
+};
+
+const SWAP_V = (() => {
+  const main = new Uint8Array(256), alt = new Uint8Array(256);
+  for (let s = 0; s < 256; s++) { main[s] = turnV(s, 1); alt[s] = turnV(s, -1); }
+  return { main, alt };
+})();
+
+const bitsV = (s: number) => {
+  let n = 0;
+  for (let i = 0; i < 8; i++) if (s & (1 << i)) n++;
+  return n;
+};
+
+/**
+ * One tick is: make room, thin what is there, collide, stream.
+ *
+ * `p` is the expansion per tick, and in the real thing it is about 10⁻⁶¹ — the
+ * medium is laid down and then simply sits there, at the density the balance
+ * fixes, for the age of the universe. So `p` appears TWICE here and in two
+ * different roles, which is worth keeping straight:
+ *
+ *   §1 uses p large enough to watch the balance settle, because the fixed point
+ *      is the thing being measured and it does not depend on p.
+ *
+ *   §2 uses p = 0 and starts at the fixed point, because at the real p nothing
+ *      is created or destroyed over any number of ticks anyone can simulate.
+ *      Running §2 at §1's p would be wrong twice over: new room laid over an
+ *      occupied cell ERASES what was passing through it, so a large p is a
+ *      memory wipe at rate p and the disturbanceV dies in 1/p ticks rather than
+ *      travelling.
+ *
+ * The random draws are taken for all eight slots whether or not they are
+ * occupied. That looks wasteful and is not: it keeps the random stream
+ * independent of the contents, so the same seed run twice — once with a pulse
+ * and once without — differs ONLY by the pulse, and subtracting the two gives
+ * the disturbanceV exactly rather than over the noise.
+ */
+const evolveV = (T: number, L: number, p: number, pulseAt: number, seed: number,
+  fill0 = 0.5) => {
+  let S = seed;
+  const rnd = () => (S = (S * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+
+  const o = (L - 1) / 2, C = L * L;
+  let cur = new Uint8Array(C), nxt = new Uint8Array(C);
+  for (let c = 0; c < C; c++) {
+    let s = 0;
+    for (let i = 0; i < 8; i++) if (rnd() < fill0) s |= 1 << i;
+    cur[c] = s;                                    // start at the answer, then let it hold
+  }
+
+  const fill: number[] = [];
+  for (let t = 1; t <= T; t++) {
+    for (let c = 0; c < C; c++) {
+      let s = cur[c];
+      if (p > 0 && rnd() < p) s = 255;              // new room, edged on every axis
+      for (let i = 0; i < 8; i++) {                // and the same expansion thins it
+        const drop = rnd() < p;
+        if (p > 0 && drop && (s & (1 << i))) s &= ~(1 << i);
+      }
+      cur[c] = s;
+    }
+    if (t === pulseAt)
+      for (let y = -2; y <= 2; y++) for (let x = -2; x <= 2; x++)
+        if (x * x + y * y <= 4) cur[(y + o) * L + (x + o)] = 255;
+
+    nxt.fill(0);
+    for (let y = 0; y < L; y++) for (let x = 0; x < L; x++) {
+      const s = cur[y * L + x];
+      if (!s) continue;
+      const out = ((x + y) & 1) ? SWAP_V.alt[s] : SWAP_V.main[s];
+      for (let i = 0; i < 8; i++) {
+        if (!(out & (1 << i))) continue;
+        nxt[((y + D8_V[i][1] + L) % L) * L + ((x + D8_V[i][0] + L) % L)] |= 1 << i;
+      }
+    }
+    const tmp = cur; cur = nxt; nxt = tmp;
+
+    let n = 0;
+    for (let c = 0; c < C; c++) n += bitsV(cur[c]);
+    fill.push(n / (C * 8));
+  }
+  return { cur, L, o, fill };
+};
+
+/** the disturbanceV alone: the same run with and without the pulse, subtracted */
+const disturbanceV = (T: number, L: number, p: number, pulseAt: number, seed: number,
+  fill0 = 0.5) => {
+  const A = evolveV(T, L, p, pulseAt, seed, fill0);
+  const B = evolveV(T, L, p, -1, seed, fill0);
+  const d = new Float64Array(L * L);
+  for (let c = 0; c < L * L; c++) d[c] = bitsV(A.cur[c]) - bitsV(B.cur[c]);
+  return { d, L, o: A.o };
+};
+
+const NB_VAC = 72;
+const angleV = (x: number, y: number) =>
+  Math.min(NB_VAC - 1, Math.floor(((Math.atan2(y, x) + 2 * Math.PI) % (2 * Math.PI)) / (2 * Math.PI) * NB_VAC));
+
+/** the front: per direction, the mean radius of the positive part of the shellV */
+const shellV = (F: { d: Float64Array, L: number, o: number }, lo: number, hi: number) => {
+  const A = new Float64Array(NB_VAC), R = new Float64Array(NB_VAC);
+  for (let y = -F.o; y <= F.o; y++) for (let x = -F.o; x <= F.o; x++) {
+    const r = Math.hypot(x, y);
+    if (r < lo || r > hi) continue;
+    const v = Math.max(0, F.d[(y + F.o) * F.L + (x + F.o)]);
+    const b = angleV(x, y);
+    A[b] += v; R[b] += v * r;
+  }
+  const amp = Array.from(A), m = amp.reduce((a, b) => a + b, 0) / NB_VAC;
+  return {
+    rms: Math.sqrt(amp.reduce((a, v) => a + (v / m - 1) ** 2, 0) / NB_VAC),
+    empty: amp.filter(v => v < 0.05 * m).length / NB_VAC,
+    radius: A.reduce((a, v, b) => a + R[b], 0) / A.reduce((a, v) => a + v, 0),
+  };
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log("THE MEDIUM IS THE EXPANSION\n");
+
+console.log("─".repeat(78));
+console.log("1. ITS DENSITY IS NOT A PARAMETER\n");
+console.log("   New room is edged on every axis; the same expansion thins what is");
+console.log("   already there. Both at rate p, because they are one process.\n");
+console.log("      p      measured     (1−p)/(2−p)        Δ");
+for (const p of [0.02, 0.05, 0.10, 0.20, 0.40]) {
+  const { fill } = evolveV(120, 111, p, -1, 20260814);
+  const f = fill.slice(-30).reduce((a, b) => a + b, 0) / 30;
+  const want = (1 - p) / (2 - p);
+  console.log("   " + p.toFixed(2).padStart(5) + f.toFixed(5).padStart(13)
+    + want.toFixed(5).padStart(15) + Math.abs(f - want).toExponential(1).padStart(11));
+}
+console.log("\n   → one half in the slow-expansion limit, which is the physical one.");
+console.log("   Nothing was fitted; streaming and collisions conserve charges and so");
+console.log("   drop out of the balance entirely.\n");
+
+console.log("─".repeat(78));
+console.log("2. AND THE FRONT IS ROUND, AND TRAVELS\n");
+console.log("   A pulse dropped into that medium, isolated by running the same seed");
+console.log("   twice — once with it and once without — and subtracting.\n");
+console.log("   ticks since pulse     radius     radius/t     shellV rms    empty");
+{
+  const L = 221, p = 0.10, at = 20;
+  for (const age of [20, 40, 60, 80]) {
+    const F = disturbanceV(at + age, L, p, at, 20260814);
+    const s = shellV(F, 0.35 * age, 1.15 * age);
+    console.log("   " + String(age).padStart(14) + s.radius.toFixed(2).padStart(11)
+      + (s.radius / age).toFixed(4).padStart(13) + s.rms.toFixed(4).padStart(13)
+      + (100 * s.empty).toFixed(0).padStart(8) + "%");
+  }
+}
+{
+  let acted = 0, charges = 0, S2 = 777;
+  const r2 = () => (S2 = (S2 * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+  for (let k = 0; k < 400000; k++) {
+    let st = 0;
+    for (let i = 0; i < 8; i++) if (r2() < 0.5) st |= 1 << i;
+    charges += bitsV(st);
+    const out = (k & 1) ? SWAP_V.alt[st] : SWAP_V.main[st];
+    let moved = 0;
+    for (let i = 0; i < 8; i++) if (((st >> i) & 1) !== ((out >> i) & 1)) moved++;
+    acted += moved / 2;
+  }
+  console.log("\n   at fill \u00bd, " + (acted / charges).toFixed(4) + " of charges turnV each tick, so the");
+  console.log("   mean free path is " + (charges / acted).toFixed(1)
+    + " cells — against a front 40 cells out, which is a");
+  console.log("   Knudsen number of " + (charges / acted / 40).toFixed(3) + ". That is not deeply hydrodynamic — it is");
+  console.log("   the same order as `gas` managed — but it is reached without choosing");
+  console.log("   anything, and the shell rms above is still FALLING with age, which is");
+  console.log("   the sign that it is converging on a circle rather than sitting at one.");
+}
+console.log("\n   radius/t holding steady is a light cone — the disturbanceV travels");
+console.log("   rather than spreads — and it sits near the lattice's own 1/√3 =");
+console.log("   " + (1 / Math.sqrt(3)).toFixed(4) + ". And NO CHARGE goes that far — see the mean free path");
+console.log("   above — so whatever arrives at the front never started at the middle.\n");
+
+console.log("─".repeat(78));
+console.log("3. AGAINST THE SAME LATTICE WITH NO MEDIUM\n");
+{
+  const L = 221, at = 20, age = 60;
+  const A = disturbanceV(at + age, L, 0.10, at, 20260814);
+  const B = disturbanceV(at + age, L, 0, at, 20260814, 0);   // an EMPTY lattice
+  const sa = shellV(A, 0.35 * age, 1.15 * age), sb = shellV(B, 0.35 * age, 1.15 * age);
+  console.log("                          shellV rms    empty directions");
+  console.log("   vacuum at a half   " + sa.rms.toFixed(4).padStart(11)
+    + (100 * sa.empty).toFixed(0).padStart(15) + "%");
+  console.log("   empty lattice      " + sb.rms.toFixed(4).padStart(11)
+    + (100 * sb.empty).toFixed(0).padStart(15) + "%");
+}
+console.log("\n   the second row is the model as it stands, and it is the veins.\n");
+
+console.log("─".repeat(78));
+console.log("WHAT THIS SETTLES");
+console.log("  · the medium was the last free assumption and it is not free. It is the");
+console.log("    expansion, which the model already has, and its density is one half.");
+console.log("  · a charge does not need luck to find something head-on. The room it is");
+console.log("    moving into was just built, and building it is what put the edge there");
+console.log("    — pointing straight back down the line the charge came in on.");
+console.log("  · the collision rate that follows is 8 cells of mean free path, Knudsen");
+console.log("    0.2 at forty cells out — not deeply hydrodynamic, and honestly no");
+console.log("    better than `gas` reached by hand. What is different is that nothing");
+console.log("    was chosen to get it: the density is a half because expansion makes");
+console.log("    room and thins at the same rate, and that is the whole derivation.");
+console.log("  · and the shell rms FALLS with age — 0.96, 0.54, 0.31, 0.27 — where the");
+console.log("    ray\u2019s veins were scale free and if anything grew (slope +0.22). Eleven");
+console.log("    times smoother than the empty lattice at the same age, and improving.");
+console.log("  · what is NOT settled: this rule conserves charges, and gravity in this");
+console.log("    model comes from them being destroyed. That is the next thing to test.");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
index 4dd7ee0..3e6d2b4 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
@@ -59,7 +59,7 @@
  * steps) and is enumerated rather than sampled.
  */
 
-import { CanvasView, Surface } from "./canvas";
+import { CanvasView, Painter, Surface } from "./canvas";
 
 const INK = "#c8cbd4", FAINT = "#5a5f6e", GRID = "rgba(255,255,255,0.055)";
 const MODEL = "#4aa8eb", DATA = "#eb964a", SEEN = "#eef0f5";
@@ -1254,6 +1254,713 @@ export const WanderMedium = ({ ticks = 26, height = 210 }: { ticks?: number, hei
   <Panel paint={media(ticks)} height={height} />;
 
 
+// ---------------------------------------------------------------------------
+// THE SAME PULSE, TWICE — running, because the difference is a difference in
+// what happens over time and a still cannot show it.
+//
+// LEFT is the model as it stands: a charge keeps the heading it left with, and
+// with nothing to run into it keeps it for ever. Eight beams, and the gaps
+// between them never fill however long you wait.
+//
+// RIGHT is the same lattice, the same pulse and the same rule, with the vacuum
+// in it. Space is being made all the time, on every axis, so a cell has edges
+// pointing every way — including one pointing straight back down the line an
+// arriving charge came in on. The charge does not have to be lucky to meet
+// something head-on; the room it moved into was just built, and building it is
+// what put the thing there.
+//
+// The density that follows is not a choice. The same expansion that lays the
+// edges down also thins out what is already there — more room, same charges —
+// and at a common rate p the balance is f = (1 − p)/(2 − p), which is A HALF in
+// the slow-expansion limit. That is the fill on the right. See `tests/vacuum`.
+//
+// WHAT IS ACTUALLY DRAWN on the right is the DIFFERENCE between two copies of
+// the same medium, one with the pulse and one without, so what you see is the
+// disturbance alone rather than the medium it is moving through. Blue is more
+// than there would have been, orange is less — a compression and the
+// rarefaction behind it, which is what a wave is.
+//
+// AND NOTHING GOES ROUND THE CIRCLE. At this density a charge is turned every
+// eight cells or so, so nothing that started in the middle is anywhere near the
+// front. What travels is the excess momentum, handed from cell to cell because
+// a collision cannot destroy it, and it travels at the same rate in every
+// direction because the push is the same in every direction. A relay, not a
+// journey.
+
+/** the eight directions, and a head-on pair turned sideways into free slots */
+const RD8: [number, number][] = [
+  [1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1],
+];
+
+const turned = (s: number, sense: 1 | -1) => {
+  let out = s;
+  for (let i = 0; i < 4; i++) {
+    const a = 1 << i, b = 1 << (i + 4);
+    if (!(out & a) || !(out & b)) continue;
+    const j = (i + (sense === 1 ? 1 : 7)) % 8;
+    const c = 1 << j, d = 1 << ((j + 4) % 8);
+    if (out & c || out & d) continue;
+    out = (out & ~a & ~b) | c | d;
+  }
+  return out;
+};
+
+const TURN = (() => {
+  const m = new Uint8Array(256), a = new Uint8Array(256);
+  for (let s = 0; s < 256; s++) { m[s] = turned(s, 1); a[s] = turned(s, -1); }
+  return { m, a };
+})();
+
+const BITS = (() => {
+  const b = new Uint8Array(256);
+  for (let s = 0; s < 256; s++) { let n = 0; for (let i = 0; i < 8; i++) if (s & (1 << i)) n++; b[s] = n; }
+  return b;
+})();
+
+const L = 121, LO = (L - 1) / 2, LC = L * L;
+
+/**
+ * One world: two copies of the same lattice, identical but for the pulse, so
+ * subtracting them leaves the disturbance and nothing else. `fill` is the
+ * medium — a half on the right, empty on the left.
+ */
+const world = (fill: number) => {
+  let a = new Uint8Array(LC), b = new Uint8Array(LC);
+  let na = new Uint8Array(LC), nb = new Uint8Array(LC);
+
+  const reset = () => {
+    for (let c = 0; c < LC; c++) {
+      let s = 0;
+      if (fill > 0) for (let i = 0; i < 8; i++) if (Math.random() < fill) s |= 1 << i;
+      a[c] = s; b[c] = s;
+    }
+    for (let y = -2; y <= 2; y++) for (let x = -2; x <= 2; x++)
+      if (x * x + y * y <= 4) a[(y + LO) * L + (x + LO)] = 255;      // only the pulsed copy
+  };
+
+  const half = (cur: Uint8Array, nxt: Uint8Array) => {
+    nxt.fill(0);
+    for (let y = 0; y < L; y++) for (let x = 0; x < L; x++) {
+      const s = cur[y * L + x];
+      if (!s) continue;
+      const out = ((x + y) & 1) ? TURN.a[s] : TURN.m[s];
+      for (let i = 0; i < 8; i++) {
+        if (!(out & (1 << i))) continue;
+        nxt[((y + RD8[i][1] + L) % L) * L + ((x + RD8[i][0] + L) % L)] |= 1 << i;
+      }
+    }
+  };
+
+  reset();
+  return {
+    reset,
+    step: () => {
+      half(a, na); half(b, nb);
+      const ta = a; a = na; na = ta;
+      const tb = b; b = nb; nb = tb;
+    },
+    at: (i: number) => BITS[a[i]] - BITS[b[i]],
+  };
+};
+
+/** ticks a second — slow enough to watch the front build rather than appear */
+const RATE = 18, RUN = 48;
+
+const relay = (): Painter => {
+  const cols: [string, ReturnType<typeof world>][] = [
+    ["nothing in the way", world(0)],
+    ["the vacuum, at a half", world(0.5)],
+  ];
+  let t = 0, acc = 0;
+
+  return {
+    frame: (s: Surface, dt: number) => {
+      const { ctx, width, height } = s;
+
+      acc += dt;
+      while (acc > 1 / RATE) {
+        acc -= 1 / RATE;
+        if (t >= RUN) { for (const [, w] of cols) w.reset(); t = 0; }
+        else { for (const [, w] of cols) w.step(); t++; }
+      }
+
+      ctx.clearRect(0, 0, width, height);
+      ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+      const TOP = 18, BOT = 16, GAP = 10;
+      const cw = (width - GAP) / 2;
+      const side = Math.min(cw, height - TOP - BOT);
+      const px = side / (2 * RUN + 1);
+      const top = TOP + Math.max(0, (height - TOP - BOT - side) / 2);
+
+      cols.forEach(([name, w], col) => {
+        const cx = (col === 0 ? cw / 2 : cw + GAP + cw / 2), cy = top + side / 2;
+
+        for (let y = -RUN; y <= RUN; y++) for (let x = -RUN; x <= RUN; x++) {
+          const v = w.at((y + LO) * L + (x + LO));
+          if (!v) continue;
+          ctx.globalAlpha = Math.min(1, Math.abs(v) / 2.2);
+          ctx.fillStyle = v > 0 ? MODEL : DATA;
+          ctx.fillRect(cx + x * px - px / 2, cy - y * px - px / 2, px + 0.6, px + 0.6);
+        }
+        ctx.globalAlpha = 1;
+
+        ctx.fillStyle = INK; ctx.textAlign = "center";
+        ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+        ctx.fillText(name, cx, 13);
+      });
+
+      ctx.fillStyle = FAINT; ctx.textAlign = "center";
+      ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+      ctx.fillText("blue: more than there would have been.  orange: less.  tick "
+        + t + " of " + RUN, width / 2, height - 4);
+    },
+  };
+};
+
+/**
+ * A live panel rather than a still. `Panel` hands `CanvasView` a plain function
+ * and makes a fresh one every frame, which is right for a picture that does not
+ * change and useless for one that does — the state has to live in the painter,
+ * so the painter has to be made once. That is what `paint` is for.
+ */
+export const WanderRelay = ({ height = 260 }: { height?: number }) =>
+  <div style={{ marginBottom: "1.1rem" }}>
+    <div style={{
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+      color: FAINT, marginBottom: 6,
+    }}>the same pulse, with and without a vacuum to move through</div>
+    <div style={{ height, background: BACK }}>
+      <CanvasView paint={relay} />
+    </div>
+  </div>;
+
+
+// ---------------------------------------------------------------------------
+// AND WHAT GRAVITY LOOKS LIKE IN IT — the same lattice, the same vacuum, with
+// two bodies in the way.
+//
+// A body is a place where charges stop. Whatever arrives at it is taken, and
+// nothing comes out the other side, so downstream of it the vacuum is short of
+// charges. That shortfall is the whole of the mechanism: a body sitting in
+// another body's shortfall is hit from the far side harder than from the near
+// side, and the difference points at the other body. Nothing pulls; one side
+// pushes less.
+//
+// WHY IT NEEDS TIME-AVERAGING, which is the thing the picture is really about.
+// A single tick is noise — at half occupancy the shot noise across a cell is
+// far bigger than the shortfall, and the left panel is what that looks like:
+// static, with two holes in it. The shortfall is not visible in any one tick
+// and never will be. It is visible in the AVERAGE, which is the right panel,
+// and it comes out of the noise as √n. That is not an artefact of the drawing;
+// it is what it means for gravity to be the weakest thing there is.
+//
+// A NOTE ON WHAT WAS TRIED FIRST. The obvious way to isolate the shortfall is
+// to run two copies, one with the bodies and one without, on the same random
+// draws, and subtract. That does not work here and the failure is worth
+// keeping: a lattice gas is CHAOTIC, so a single changed bit spreads to the
+// whole light cone at full amplitude within a few dozen ticks, and the
+// difference field is decorrelated noise rather than the response. Common
+// random numbers are a technique for smooth systems. Averaging is what is left.
+//
+// THE ARROWS are measured rather than drawn on: the momentum actually arriving
+// at each body, summed over its cells and over every tick since the start. They
+// come out pointing at each other, which is the claim.
+
+const GL = 121, GO = (GL - 1) / 2, GC = GL * GL;
+const GSEP = 24, GR = 2;                        // separation and body radius, in cells
+const GP = 0.02;                                // how fast the vacuum is remade
+
+const gravity = (): Painter => {
+  let a = new Uint8Array(GC), na = new Uint8Array(GC);
+  const isBody = new Uint8Array(GC);
+  const bodies: [number, number][] = [[-GSEP / 2, 0], [GSEP / 2, 0]];
+
+  for (const [bx, by] of bodies)
+    for (let y = -GR; y <= GR; y++) for (let x = -GR; x <= GR; x++)
+      if (x * x + y * y <= GR * GR) isBody[(by + y + GO) * GL + (bx + x + GO)] = 1;
+
+  for (let c = 0; c < GC; c++) {
+    let s = 0;
+    for (let i = 0; i < 8; i++) if (Math.random() < 0.5) s |= 1 << i;
+    a[c] = s;
+  }
+
+  const sum = new Float64Array(GC);
+  const F = bodies.map(() => [0, 0]);
+  let n = 0, acc = 0;
+
+  /** back to a fresh vacuum and an empty average, so the shadow comes out of
+   *  the noise again rather than the panel sitting on a finished picture */
+  const restart = () => {
+    for (let c = 0; c < GC; c++) {
+      let s = 0;
+      for (let i = 0; i < 8; i++) if (Math.random() < 0.5) s |= 1 << i;
+      a[c] = s;
+    }
+    sum.fill(0);
+    F.forEach(f => { f[0] = 0; f[1] = 0; });
+    n = 0;
+  };
+
+  const step = () => {
+    for (let c = 0; c < GC; c++) {
+      let s = a[c];
+      if (Math.random() < GP) s = 255;               // new room, edged on every axis
+      for (let i = 0; i < 8; i++)
+        if (Math.random() < GP && (s & (1 << i))) s &= ~(1 << i);
+      if (isBody[c]) s = 0;                          // and a body takes what reaches it
+      a[c] = s;
+    }
+    na.fill(0);
+    for (let y = 0; y < GL; y++) for (let x = 0; x < GL; x++) {
+      const s = a[y * GL + x];
+      if (!s) continue;
+      const out = ((x + y) & 1) ? TURN.a[s] : TURN.m[s];
+      for (let i = 0; i < 8; i++) {
+        if (!(out & (1 << i))) continue;
+        na[((y + RD8[i][1] + GL) % GL) * GL + ((x + RD8[i][0] + GL) % GL)] |= 1 << i;
+      }
+    }
+    const t = a; a = na; na = t;
+
+    n++;
+    for (let c = 0; c < GC; c++) sum[c] += BITS[a[c]];
+    bodies.forEach(([bx, by], k) => {
+      for (let y = -GR; y <= GR; y++) for (let x = -GR; x <= GR; x++) {
+        if (x * x + y * y > GR * GR) continue;
+        const c = (by + y + GO) * GL + (bx + x + GO);
+        for (let i = 0; i < 8; i++)
+          if (a[c] & (1 << i)) { F[k][0] += RD8[i][0]; F[k][1] += RD8[i][1]; }
+      }
+    });
+  };
+
+  const W = 38;                                      // half-window drawn, in cells
+
+  return {
+    frame: (s: Surface, dt: number) => {
+      const { ctx, width, height } = s;
+
+      acc += dt;
+      while (acc > 1 / 90) { acc -= 1 / 90; if (n >= 900) restart(); else step(); }
+
+      ctx.clearRect(0, 0, width, height);
+      ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+      const TOP = 18, BOT = 16, GAP = 10;
+      const cw = (width - GAP) / 2;
+      const side = Math.min(cw, height - TOP - BOT);
+      const px = side / (2 * W + 1);
+      const top = TOP + Math.max(0, (height - TOP - BOT - side) / 2);
+
+      // the background level, read far from either body
+      let bg = 0, bn = 0;
+      for (let y = -GO; y <= GO; y += 2) for (let x = -GO; x <= GO; x += 2)
+        if (Math.hypot(x + GSEP / 2, y) > 34 && Math.hypot(x - GSEP / 2, y) > 34) {
+          bg += sum[(y + GO) * GL + (x + GO)] / n; bn++;
+        }
+      bg /= bn;
+
+      for (const col of [0, 1]) {
+        const cx = (col === 0 ? cw / 2 : cw + GAP + cw / 2), cy = top + side / 2;
+
+        for (let y = -W; y <= W; y++) for (let x = -W; x <= W; x++) {
+          const c = (y + GO) * GL + (x + GO);
+          let v: number, tint: string;
+          if (col === 0) { v = BITS[a[c]] / 8; tint = MODEL; }          // one tick
+          else { v = Math.max(0, (bg - sum[c] / n)) / 2.2; tint = DATA; } // the average
+          if (v <= 0.01) continue;
+          ctx.globalAlpha = Math.min(1, v);
+          ctx.fillStyle = tint;
+          ctx.fillRect(cx + x * px - px / 2, cy - y * px - px / 2, px + 0.6, px + 0.6);
+        }
+        ctx.globalAlpha = 1;
+
+        for (const [bx, by] of bodies) {
+          ctx.strokeStyle = SEEN; ctx.lineWidth = 1.2;
+          ctx.beginPath();
+          ctx.arc(cx + bx * px, cy - by * px, (GR + 0.8) * px, 0, 2 * Math.PI);
+          ctx.stroke();
+        }
+
+        if (col === 1) {                              // the measured push, on each body
+          const scale = 26 / Math.max(1, Math.abs(F[1][0] - F[0][0]) / 2);
+          bodies.forEach(([bx, by], k) => {
+            const fx = F[k][0] * scale / n * 40, fy = F[k][1] * scale / n * 40;
+            const L2 = Math.hypot(fx, fy);
+            if (L2 < 2) return;
+            const x0 = cx + bx * px, y0 = cy - by * px;
+            ctx.strokeStyle = GOOD; ctx.lineWidth = 1.6;
+            ctx.beginPath(); ctx.moveTo(x0, y0); ctx.lineTo(x0 + fx, y0 - fy); ctx.stroke();
+            const ang = Math.atan2(-fy, fx);
+            ctx.beginPath();
+            ctx.moveTo(x0 + fx, y0 - fy);
+            ctx.lineTo(x0 + fx - 5 * Math.cos(ang - 0.4), y0 - fy - 5 * Math.sin(ang - 0.4));
+            ctx.moveTo(x0 + fx, y0 - fy);
+            ctx.lineTo(x0 + fx - 5 * Math.cos(ang + 0.4), y0 - fy - 5 * Math.sin(ang + 0.4));
+            ctx.stroke();
+          });
+        }
+
+        ctx.fillStyle = INK; ctx.textAlign = "center";
+        ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+        ctx.fillText(col === 0 ? "one tick" : "averaged over " + n + " ticks", cx, 13);
+      }
+
+      ctx.fillStyle = FAINT; ctx.textAlign = "center";
+      ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+      ctx.fillText("left: the charges themselves.  right: how many are MISSING, "
+        + "and the push that measures", width / 2, height - 4);
+    },
+  };
+};
+
+export const WanderGravity = ({ height = 300 }: { height?: number }) =>
+  <div style={{ marginBottom: "1.1rem" }}>
+    <div style={{
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+      color: FAINT, marginBottom: 6,
+    }}>two bodies in the vacuum — the shortfall each leaves, and the push it makes</div>
+    <div style={{ height, background: BACK }}>
+      <CanvasView paint={gravity} />
+    </div>
+  </div>;
+
+
+// ---------------------------------------------------------------------------
+// PURE GRAVITY — the same lattice with the polarity taken out, which makes the
+// rule SHORTER rather than longer.
+//
+//     Every edge expands, every tick: a point sends one charge along each of
+//     its edges. Every charge is destroyed at the point it lands on, and that
+//     destruction is what makes the next one — a point that received k sends k
+//     back out. A BODY takes what arrives and sends nothing.
+//
+// There is no heading to remember, because a charge does not survive a step. No
+// turn rate, no cone, no collision table, no distribution to pick.
+//
+// AND THE FREE VACUUM IS STATIC. With every point full, eight go out and eight
+// come in, every tick, for ever. What moves is only WHICH edges carry when a
+// point has fewer than eight to send — the connections shuffle while the
+// occupancy does not — and `tests/pure` measures that at under a hundredth of a
+// charge in eight. The skipped edge is let walk round the point one step at a
+// time, so there is no randomness in this at all.
+//
+// WHICH IS WHY THIS ONE IS SHARP. The polarity picture had to average hundreds
+// of ticks to get gravity out of the shot noise; here the well is exact and the
+// force comes out to three figures on the first pass, obeying Newton's third
+// law to the last digit. `tests/pure` also gets |F|·d ≈ 8.5, 9.2, 8.5 at
+// d = 8, 12, 18 — F ∝ 1/d, which is what a shortfall spreading through a PLANE
+// has to give, the gradient of the two-dimensional log. Three dimensions would
+// give 1/r², and that is not checked.
+
+const PL = 111, PO = (PL - 1) / 2, PC = PL * PL;
+const PSEP = 26, PR = 2;
+
+const pure = (): Painter => {
+  let q = new Uint8Array(PC).fill(8), nq = new Uint8Array(PC);
+  const phase = new Uint8Array(PC), body = new Uint8Array(PC);
+  const bodies: [number, number][] = [[-PSEP / 2, 0], [PSEP / 2, 0]];
+  for (const [bx, by] of bodies)
+    for (let y = -PR; y <= PR; y++) for (let x = -PR; x <= PR; x++)
+      if (x * x + y * y <= PR * PR) body[(by + y + PO) * PL + (bx + x + PO)] = 1;
+
+  const F = bodies.map(() => [0, 0]);
+  let t = 0, acc = 0;
+  const rim = (x: number, y: number) => x <= -PO + 1 || x >= PO - 1 || y <= -PO + 1 || y >= PO - 1;
+
+  /** the well digs itself out in a couple of hundred ticks and is then exact,
+   *  so the loop is there to show it being dug rather than to keep it moving */
+  const restart = () => { q.fill(8); nq.fill(0); phase.fill(0); t = 0; };
+
+  const step = () => {
+    nq.fill(0);
+    for (let y = -PO; y <= PO; y++) for (let x = -PO; x <= PO; x++) {
+      const c = (y + PO) * PL + (x + PO);
+      if (body[c]) continue;
+      const k = rim(x, y) ? 8 : q[c];
+      if (!k) continue;
+      const p = phase[c];
+      for (let j = 0; j < k; j++) {
+        const i = (p + j) & 7;
+        nq[((y + RD8[i][1] + PO + PL) % PL) * PL + ((x + RD8[i][0] + PO + PL) % PL)]++;
+      }
+      phase[c] = (p + k) & 7;
+    }
+    const tt = q; q = nq; nq = tt;
+    t++;
+
+    bodies.forEach((m, kk) => {
+      let fx = 0, fy = 0;
+      for (let y = -PR; y <= PR; y++) for (let x = -PR; x <= PR; x++) {
+        if (x * x + y * y > PR * PR) continue;
+        for (let i = 0; i < 8; i++) {
+          const sc = (m[1] + y - RD8[i][1] + PO) * PL + (m[0] + x - RD8[i][0] + PO);
+          if (body[sc]) continue;
+          const w = q[sc] / 8;
+          fx += RD8[i][0] * w; fy += RD8[i][1] * w;
+        }
+      }
+      F[kk][0] = fx; F[kk][1] = fy;                // instantaneous — it is not noisy
+    });
+  };
+
+  const W = 40;
+
+  return {
+    frame: (s: Surface, dt: number) => {
+      const { ctx, width, height } = s;
+
+      acc += dt;
+      while (acc > 1 / 60) { acc -= 1 / 60; if (t >= 320) restart(); else step(); }
+
+      ctx.clearRect(0, 0, width, height);
+      ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+      const TOP = 18, BOT = 16, GAP = 10;
+      const cw = (width - GAP) / 2;
+      const side = Math.min(cw, height - TOP - BOT);
+      const px = side / (2 * W + 1);
+      const top = TOP + Math.max(0, (height - TOP - BOT - side) / 2);
+
+      for (const col of [0, 1]) {
+        const cx = (col === 0 ? cw / 2 : cw + GAP + cw / 2), cy = top + side / 2;
+
+        for (let y = -W; y <= W; y++) for (let x = -W; x <= W; x++) {
+          const c = (y + PO) * PL + (x + PO);
+          const n = q[c];
+          if (col === 0) {                          // how many charges are here
+            if (!n) continue;
+            ctx.globalAlpha = 0.14 + 0.86 * (n / 8);
+            ctx.fillStyle = MODEL;
+          } else {                                  // and how many are missing
+            const d = (8 - n) / 6;
+            if (d <= 0.01) continue;
+            ctx.globalAlpha = Math.min(1, d);
+            ctx.fillStyle = DATA;
+          }
+          ctx.fillRect(cx + x * px - px / 2, cy - y * px - px / 2, px + 0.6, px + 0.6);
+        }
+        ctx.globalAlpha = 1;
+
+        for (const [bx, by] of bodies) {
+          ctx.strokeStyle = SEEN; ctx.lineWidth = 1.2;
+          ctx.beginPath();
+          ctx.arc(cx + bx * px, cy - by * px, (PR + 0.8) * px, 0, 2 * Math.PI);
+          ctx.stroke();
+        }
+
+        if (col === 1) {
+          bodies.forEach(([bx, by], k) => {
+            const fx = F[k][0] * 26, fy = F[k][1] * 26;
+            if (Math.hypot(fx, fy) < 2) return;
+            const x0 = cx + bx * px, y0 = cy - by * px;
+            ctx.strokeStyle = GOOD; ctx.lineWidth = 1.6;
+            ctx.beginPath(); ctx.moveTo(x0, y0); ctx.lineTo(x0 + fx, y0 - fy); ctx.stroke();
+            const ang = Math.atan2(-fy, fx);
+            ctx.beginPath();
+            ctx.moveTo(x0 + fx, y0 - fy);
+            ctx.lineTo(x0 + fx - 5 * Math.cos(ang - 0.4), y0 - fy - 5 * Math.sin(ang - 0.4));
+            ctx.moveTo(x0 + fx, y0 - fy);
+            ctx.lineTo(x0 + fx - 5 * Math.cos(ang + 0.4), y0 - fy - 5 * Math.sin(ang + 0.4));
+            ctx.stroke();
+          });
+        }
+
+        ctx.fillStyle = INK; ctx.textAlign = "center";
+        ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+        ctx.fillText(col === 0 ? "the charges — eight out, eight in" : "what is missing",
+          cx, 13);
+      }
+
+      ctx.fillStyle = FAINT; ctx.textAlign = "center";
+      ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
+      ctx.fillText("tick " + t + "   ·   push on each body  "
+        + F[0][0].toFixed(3) + "  and  " + F[1][0].toFixed(3)
+        + "   — no averaging, they are equal and opposite", width / 2, height - 4);
+    },
+  };
+};
+
+export const WanderPure = ({ height = 300 }: { height?: number }) =>
+  <div style={{ marginBottom: "1.1rem" }}>
+    <div style={{
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+      color: FAINT, marginBottom: 6,
+    }}>pure gravity — no polarity, and nothing random in it</div>
+    <div style={{ height, background: BACK }}>
+      <CanvasView paint={pure} />
+    </div>
+  </div>;
+
+
+// ---------------------------------------------------------------------------
+// THE VACUUM EXPANDING — and a point does not survive making the next one.
+//
+// A NOTE ON WHY THIS IS NOT `GraphCanvas`. Seeding a patch with `Graph.patch`
+// and ticking it was tried and it is the wrong dynamics: `discrete.ts` moves
+// ONE ray per point and conserves it, so a patch let go expands each point
+// along its own single heading and the room that appears behind it is a thread
+// rather than a lattice. The rule below — every point out along every edge at
+// once, and the point spent doing it — is not what `tick()` implements. So it
+// is drawn here, in the same neutral grey and with charges in flight drawn the
+// same way, rather than pretending the engine produced it.
+//
+// THE CYCLE. Everything alive emits along all four of its axes at once and IS
+// SPENT DOING SO — there is nothing left where it was. The charges from
+// opposite sides arrive at the site between them head-on, annihilate, and what
+// is left there is the next point. Then that happens again, the other way.
+//
+// So the lattice does not sit still and get finer. It alternates: the points
+// are on the even sites, then on the odd ones, then on the even ones again,
+// and the picture breathes. Neither half is the lattice — the alternation is.
+//
+// WHERE THE DIAGONALS ARE, which is the reason for drawing it at all. A site
+// and the four it emits to are on opposite halves, so the axes are what carries
+// the pulse and can never join two points that exist at the same time. The
+// points that DO exist together are a diagonal step apart. Every generation the
+// lattice you can see is the diagonal one, turned forty-five degrees from the
+// one that made it and spaced by √2 — so `lattice, plus diagonals` is not two
+// things. It is one thing seen on two beats.
+//
+// AND IT GROWS. A point on the rim emits outward too, and there is nobody
+// coming the other way, so that charge arrives alone at a site that did not
+// exist and makes it anyway. One ring per pulse, for ever, which is the whole
+// of what the expansion is.
+
+const XAX: [number, number][] = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+
+const GREY = "140,147,168";                        // NEUTRAL, as the lattice is drawn
+
+const OUT = 0.62, HIT = 0.14, SETTLE = 0.24;       // one pulse, in seconds
+const PULSE = OUT + HIT + SETTLE;
+const PULSES = 6;                                  // before it starts again
+
+/** the nine it starts from: a three by three, on the even sites */
+const seed = () => {
+  const s = new Set<string>();
+  for (let j = -2; j <= 2; j += 2) for (let i = -2; i <= 2; i += 2) s.add(i + "," + j);
+  return s;
+};
+
+/** everything the alive set reaches, which is where the next points are */
+const next = (alive: Set<string>) => {
+  const hits = new Map<string, number>();
+  for (const k of alive) {
+    const [i, j] = k.split(",").map(Number);
+    for (const [dx, dy] of XAX) {
+      const t = (i + dx) + "," + (j + dy);
+      hits.set(t, (hits.get(t) ?? 0) + 1);
+    }
+  }
+  return hits;
+};
+
+const expand = (): Painter => {
+  let t = 0, n = 0;
+  let alive = seed();
+  let hits = next(alive);
+
+  return {
+    frame: (s: Surface, dt: number) => {
+      const { ctx, width, height } = s;
+
+      t += dt;
+      while (t >= PULSE) {
+        t -= PULSE;
+        n++;
+        if (n >= PULSES) { alive = seed(); n = 0; }
+        else alive = new Set(hits.keys());
+        hits = next(alive);
+      }
+
+      const travel = Math.min(1, t / OUT);           // how far the charges have got
+      const flash = t >= OUT && t < OUT + HIT ? 1 - (t - OUT) / HIT : 0;
+      const born = t < OUT + HIT ? 0 : Math.min(1, (t - OUT - HIT) / SETTLE);
+      const spent = travel;                          // the emitters, going as they go
+
+      ctx.clearRect(0, 0, width, height);
+      ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+      const cx = width / 2, cy = height / 2;
+      const k = Math.min(width, height) / (2 * (3 + PULSES) + 2);
+      const X = (i: number) => cx + i * k, Y = (j: number) => cy - j * k;
+
+      // ── what is here now, and the diagonals that join it ─────────────────
+      const show = born > 0 ? new Set(hits.keys()) : alive;
+      const a = born > 0 ? born : 1 - spent;
+
+      ctx.lineCap = "round";
+      ctx.lineWidth = 1.4;
+      ctx.strokeStyle = `rgba(${GREY},${0.30 * a})`;
+      for (const key of show) {
+        const [i, j] = key.split(",").map(Number);
+        for (const [dx, dy] of [[1, 1], [1, -1]]) {
+          if (!show.has((i + dx) + "," + (j + dy))) continue;
+          ctx.beginPath();
+          ctx.moveTo(X(i), Y(j)); ctx.lineTo(X(i + dx), Y(j + dy)); ctx.stroke();
+        }
+      }
+
+      // ── the charges, on their way, and the point spent sending them ──────
+      if (born === 0 && travel > 0) {
+        ctx.lineWidth = 2;
+        for (const key of alive) {
+          const [i, j] = key.split(",").map(Number);
+          for (const [dx, dy] of XAX) {
+            const px = X(i + dx * travel), py = Y(j + dy * travel);
+            ctx.strokeStyle = `rgba(${GREY},0.9)`;
+            ctx.beginPath();
+            ctx.moveTo(X(i + dx * travel * 0.65), Y(j + dy * travel * 0.65));
+            ctx.lineTo(px, py);
+            ctx.stroke();
+            const ang = Math.atan2(-dy, dx), h = Math.min(6.5, k * 0.34);
+            ctx.fillStyle = `rgba(${GREY},0.9)`;
+            ctx.beginPath();
+            ctx.moveTo(px + h * Math.cos(ang), py + h * Math.sin(ang));
+            ctx.lineTo(px + h * Math.cos(ang + 2.5), py + h * Math.sin(ang + 2.5));
+            ctx.lineTo(px + h * Math.cos(ang - 2.5), py + h * Math.sin(ang - 2.5));
+            ctx.closePath(); ctx.fill();
+          }
+        }
+      }
+
+      // ── where they met ───────────────────────────────────────────────────
+      if (flash > 0) for (const [key, count] of hits) {
+        const [i, j] = key.split(",").map(Number);
+        ctx.globalAlpha = flash * (count > 1 ? 1 : 0.5);
+        ctx.fillStyle = SEEN;
+        ctx.beginPath(); ctx.arc(X(i), Y(j), 2 + 5 * flash, 0, 2 * Math.PI); ctx.fill();
+        ctx.globalAlpha = 1;
+      }
+
+      // ── the points ───────────────────────────────────────────────────────
+      const dot = (key: string, alpha: number) => {
+        if (alpha <= 0.02) return;
+        const [i, j] = key.split(",").map(Number);
+        ctx.fillStyle = `rgba(${GREY},${0.95 * alpha})`;
+        ctx.beginPath(); ctx.arc(X(i), Y(j), 3 * (0.4 + 0.6 * alpha), 0, 2 * Math.PI); ctx.fill();
+      };
+      if (born === 0) for (const key of alive) dot(key, 1 - spent);   // spent emitting
+      else for (const key of hits.keys()) dot(key, born);             // and what is left
+    },
+  };
+};
+
+export const WanderExpand = ({ height = 260 }: { height?: number }) =>
+  <div style={{ marginBottom: "1.1rem" }}>
+    <div style={{
+      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+      color: FAINT, marginBottom: 6,
+    }}>a point is spent making the next ones — so the lattice alternates rather
+      than sits still</div>
+    <div style={{ height, background: BACK }}>
+      <CanvasView paint={expand} />
+    </div>
+  </div>;
+
+
 export const WanderPattern = ({ ticks = 28, height = 260 }: { ticks?: number, height?: number }) =>
   <Panel paint={pattern(ticks)} height={height}
     note="where one pulse ends up — the same rules, three ways of stepping" />;

From 21f3447a9a9e2431779d235b256bab0d00046b0a Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Fri, 14 Aug 2026 19:08:17 +0200
Subject: [PATCH 41/47] First gravity section

---
 orbitmines.com/src/routes/Physics.tsx         |  55 +++--
 .../2026.RayCalculiAndPhysics/wander.tsx      | 213 +++++++++++++-----
 2 files changed, 194 insertions(+), 74 deletions(-)

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index 4d3d8f7..9ced1d9 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -18,7 +18,7 @@ import {
 } from "./archive/2026.RayCalculiAndPhysics/law";
 import { gravitational, massUnit } from "./archive/2026.RayCalculiAndPhysics/gravity";
 import { lineGroups } from "./archive/2026.RayCalculiAndPhysics/lines";
-import { Wander, WanderBlind, WanderExpand, WanderForward, WanderGravity, WanderPaths, WanderPure, WanderRelay, WanderVeins } from "./archive/2026.RayCalculiAndPhysics/wander";
+import { Wander, WanderBlind, WanderExpand, WanderExpand1D, WanderForward, WanderGravity, WanderPaths, WanderPure, WanderRelay, WanderVeins } from "./archive/2026.RayCalculiAndPhysics/wander";
 import { Model } from "./archive/2026.RayCalculiAndPhysics/model";
 import { asGroup, MODELS, weighed } from "./archive/2026.RayCalculiAndPhysics/models";
 import { PACE, Polarity } from "./archive/2026.RayCalculiAndPhysics/physics";
@@ -244,9 +244,26 @@ const Physics = () => {
 
         <span style={{textAlign: 'left', width: '100%'}}>You're allowed to change the <K><Bar>D</Bar></K> ofc. But unless otherwise specified variables have these default values.</span>
 
-        <Head>Movement</Head>
 
-        <WanderExpand/>
+        Then a related number to dimension, all possible paths out of a point (the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "degree", link: "https://en.wikipedia.org/wiki/Degree_(graph_theory)"}}/> assuming diagonals are included). 
+
+        <Eq>
+          <F>l.</F><K><Bar>DEG</Bar></K> = <>3<Sup><F>l.</F><K><Bar>D</Bar></K></Sup> - 1</>
+        </Eq>
+
+        <span style={{textAlign: 'left', width: '100%'}}>There's one important piece of gravity that we'll discover and that is in order to reach the desired 1/R<Sup><K><Bar>D</Bar></K> - 1</Sup> of the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "inverse-square law", link: "https://en.wikipedia.org/wiki/Inverse-square_law"}}/> (for 3D). It happens that as we'll discover in a moment, if we'd send out discrete pulses of our 'gravity-rays' (so the ones causing annihilation). That we can recover the intensity of gravity in a neat way based on the dimensionality of our space. This is our sheet. The sheet we pulse a beam towards. In order to cover our whole space, we'll be rotating this sheet in 1 more dimension than it's defined.</span>
+
+        <Sheet />
+
+        <Eq>
+          <F>l.</F><K><Bar>SHEET</Bar></K> = <K><Bar>DEG</Bar></K>(<D>max</D>(<F>l.</F><K><Bar>D</Bar></K> - 1, 1))
+        </Eq>
+
+        <Para>You'll see that we call the <K><Bar>DEG</Bar></K> variable with an argument. Whenever a variable just depends on a single parameter, we'll allow it to be called, since there's no ambiguity of what that would mean.</Para>
+
+        (It doesn't actually need to be a sheet, but that's the most convenient model, as long as the number of points keep rotating properly, you'll recover the continuous model)
+
+        <Head>Movement</Head>
 
         There's a real assumption to made here at the beginning. Which is how does one from a perspective of discreteness, recover rays propagating in a circle. That's making the assumption you'd want it to propegate in a circle in the first place - whether that's the actual accurate model. Also to consider would be that a large surface of stuff sending out rays could more accurately describe a circle, than say a single point with a local neighbourhood. This is essentially a statement of discrete movement, how should that happen? Where as the aggregate we might see a sphere, a cube, a (curved) diamond-shape. All are these are technically possibilities. We could imagine a world where discretized effects matter here for the spread of those rays.
 
@@ -274,33 +291,27 @@ const Physics = () => {
 
         Namely if we consider vacuum dynamics. In the pure gravity setting (so discounting the magnetism part which we haven't gotten to yet: XOR), we don't have vacuum dynamics other than just expansion of a space. See for instance the following example of how space would expand because of the creation rule if nothing is nearby:
 
-        <WanderExpand/>
-
-        <WanderPure/>
-
-        <WanderGravity/>
-
-        <BR/>
+        <WanderExpand1D/>
 
-        Then a related number to dimension, all possible paths out of a point (the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "degree", link: "https://en.wikipedia.org/wiki/Degree_(graph_theory)"}}/> assuming diagonals are included). 
+        In 2D this would be a little more complicated, but the same principle:
 
-        <Eq>
-          <F>l.</F><K><Bar>DEG</Bar></K> = <>3<Sup><F>l.</F><K><Bar>D</Bar></K></Sup> - 1</>
-        </Eq>
+        <WanderExpand/>
 
-        <span style={{textAlign: 'left', width: '100%'}}>There's one important piece of gravity that we'll discover and that is in order to reach the desired 1/R<Sup><K><Bar>D</Bar></K> - 1</Sup> of the <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "inverse-square law", link: "https://en.wikipedia.org/wiki/Inverse-square_law"}}/> (for 3D). It happens that as we'll discover in a moment, if we'd send out discrete pulses of our 'gravity-rays' (so the ones causing annihilation). That we can recover the intensity of gravity in a neat way based on the dimensionality of our space. This is our sheet. The sheet we pulse a beam towards. In order to cover our whole space, we'll be rotating this sheet in 1 more dimension than it's defined.</span>
+        <Para>
+          It is precisely this expansion the vacuum is trying to do, which allows for the creation of the circular setup: Vacuum tries to expand, but there's matter in the way. Matter sends out its own rays, thus disturbing the perfect grid expansion. This deficit then expands at <K><Bar>c</Bar></K>, resulting in our gravitational pull.
+        </Para>
 
-        <Sheet />
+        <BR/>
 
-        <Eq>
-          <F>l.</F><K><Bar>SHEET</Bar></K> = <K><Bar>DEG</Bar></K>(<D>max</D>(<F>l.</F><K><Bar>D</Bar></K> - 1, 1))
-        </Eq>
+        <Para>
+          Here for instance is the resulting of sending our <K><Bar>SHEET</Bar></K> in a 2D space. With only the gravity rules:
+        </Para>
 
-        <Para>You'll see that we call the <K><Bar>DEG</Bar></K> variable with an argument. Whenever a variable just depends on a single parameter, we'll allow it to be called, since there's no ambiguity of what that would mean.</Para>
+        <WanderPure/>
 
-        (It doesn't actually need to be a sheet, but that's the most convenient model, as long as the number of points keep rotating properly, you'll recover the continuous model)
+        If we instead skip ahead the story a little and include XOR, so magnetism, which we'll get to later. There's actual vacuum dynamics rather than just a grid trying to expand. Then random-looking dynamics still has an aggregate pressure our matter is creating by sending out 'gravity-rays'.
 
-        <BR/>
+        <WanderGravity/>
 
         It turns out that this is all the machinary we need to derive gravitational laws that approximate <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "Newtonian gravity", link: "https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation"}}/> and <Reference is="reference" simple inline index={referenceCounter()} reference={{title: "General relativity", link: "https://en.wikipedia.org/wiki/General_relativity"}}/> and go beyond them.
 
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
index 3e6d2b4..cd9636c 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/wander.tsx
@@ -1604,24 +1604,15 @@ const gravity = (): Painter => {
         }
 
         ctx.fillStyle = INK; ctx.textAlign = "center";
-        ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
-        ctx.fillText(col === 0 ? "one tick" : "averaged over " + n + " ticks", cx, 13);
       }
 
       ctx.fillStyle = FAINT; ctx.textAlign = "center";
-      ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
-      ctx.fillText("left: the charges themselves.  right: how many are MISSING, "
-        + "and the push that measures", width / 2, height - 4);
     },
   };
 };
 
 export const WanderGravity = ({ height = 300 }: { height?: number }) =>
   <div style={{ marginBottom: "1.1rem" }}>
-    <div style={{
-      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
-      color: FAINT, marginBottom: 6,
-    }}>two bodies in the vacuum — the shortfall each leaves, and the push it makes</div>
     <div style={{ height, background: BACK }}>
       <CanvasView paint={gravity} />
     </div>
@@ -1632,6 +1623,13 @@ export const WanderGravity = ({ height = 300 }: { height?: number }) =>
 // PURE GRAVITY — the same lattice with the polarity taken out, which makes the
 // rule SHORTER rather than longer.
 //
+// NOTHING WANDERS HERE, in spite of the file it is in. The name is the
+// section's, not the mechanism's: no ray walks, nothing carries a heading, and
+// there is no randomness anywhere in `step`. What is drawn is the expansion
+// rule of `expand` above, run until it has nothing left to do, with holes in
+// it. Say it in one line: the vacuum fills, absorbers stop it filling, and the
+// shortfall where it fails to fill is the force.
+//
 //     Every edge expands, every tick: a point sends one charge along each of
 //     its edges. Every charge is destroyed at the point it lands on, and that
 //     destruction is what makes the next one — a point that received k sends k
@@ -1640,6 +1638,11 @@ export const WanderGravity = ({ height = 300 }: { height?: number }) =>
 // There is no heading to remember, because a charge does not survive a step. No
 // turn rate, no cone, no collision table, no distribution to pick.
 //
+// AND IT DOES NOT GROW EITHER, which is the difference from the panel above.
+// `expand` makes sites that did not exist; here the grid is a fixed `PL`², full
+// from the first tick, and no site is ever added. The two share the rule, not
+// the growth — what propagates in this one is the ABSENCE.
+//
 // AND THE FREE VACUUM IS STATIC. With every point full, eight go out and eight
 // come in, every tick, for ever. What moves is only WHICH edges carry when a
 // point has fewer than eight to send — the connections shuffle while the
@@ -1654,6 +1657,11 @@ export const WanderGravity = ({ height = 300 }: { height?: number }) =>
 // d = 8, 12, 18 — F ∝ 1/d, which is what a shortfall spreading through a PLANE
 // has to give, the gradient of the two-dimensional log. Three dimensions would
 // give 1/r², and that is not checked.
+//
+// WITH A RESERVOIR AT THE EDGE. `rim` refills the border to eight every tick,
+// so the well is dug against a fixed boundary at radius ~55 rather than against
+// nothing. The 1/d above is the log gradient UNDER THAT CONDITION; what a
+// boundary-free lattice gives is a separate question and is not measured here.
 
 const PL = 111, PO = (PL - 1) / 2, PC = PL * PL;
 const PSEP = 26, PR = 2;
@@ -1769,26 +1777,16 @@ const pure = (): Painter => {
         }
 
         ctx.fillStyle = INK; ctx.textAlign = "center";
-        ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
-        ctx.fillText(col === 0 ? "the charges — eight out, eight in" : "what is missing",
-          cx, 13);
+        
       }
 
       ctx.fillStyle = FAINT; ctx.textAlign = "center";
-      ctx.font = "10px ui-sans-serif, system-ui, sans-serif";
-      ctx.fillText("tick " + t + "   ·   push on each body  "
-        + F[0][0].toFixed(3) + "  and  " + F[1][0].toFixed(3)
-        + "   — no averaging, they are equal and opposite", width / 2, height - 4);
     },
   };
 };
 
 export const WanderPure = ({ height = 300 }: { height?: number }) =>
   <div style={{ marginBottom: "1.1rem" }}>
-    <div style={{
-      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
-      color: FAINT, marginBottom: 6,
-    }}>pure gravity — no polarity, and nothing random in it</div>
     <div style={{ height, background: BACK }}>
       <CanvasView paint={pure} />
     </div>
@@ -1807,35 +1805,39 @@ export const WanderPure = ({ height = 300 }: { height?: number }) =>
 // is drawn here, in the same neutral grey and with charges in flight drawn the
 // same way, rather than pretending the engine produced it.
 //
-// THE CYCLE. Everything alive emits along all four of its axes at once and IS
-// SPENT DOING SO — there is nothing left where it was. The charges from
-// opposite sides arrive at the site between them head-on, annihilate, and what
-// is left there is the next point. Then that happens again, the other way.
+// THE CYCLE. Everything alive emits along all eight of its edges at once — the
+// four axes AND the four diagonals, since the degree we are counting includes
+// them — and IS SPENT DOING SO: there is nothing left where it was. The charges
+// from opposite sides arrive at the site between them head-on, annihilate, and
+// what is left there is the next point.
 //
-// So the lattice does not sit still and get finer. It alternates: the points
-// are on the even sites, then on the odd ones, then on the even ones again,
-// and the picture breathes. Neither half is the lattice — the alternation is.
+// So the lattice does not sit still and get finer, and it does not sit where it
+// was either: every point is spent every pulse and remade somewhere by the
+// charges that met there. Nothing here persists — the pattern does.
 //
-// WHERE THE DIAGONALS ARE, which is the reason for drawing it at all. A site
-// and the four it emits to are on opposite halves, so the axes are what carries
-// the pulse and can never join two points that exist at the same time. The
-// points that DO exist together are a diagonal step apart. Every generation the
-// lattice you can see is the diagonal one, turned forty-five degrees from the
-// one that made it and spaced by √2 — so `lattice, plus diagonals` is not two
-// things. It is one thing seen on two beats.
+// WHERE THE DIAGONALS ARE, which is the reason for drawing it at all. The axes
+// carry the pulse onto the sites between, half a step out of phase with what
+// sent them; the diagonals carry it onto sites of the same parity, a diagonal
+// step away. Both arrive at once, so the two halves are alive together and the
+// lattice you can see is the full one — `lattice, plus diagonals` is not two
+// things, it is what one pulse over all eight edges leaves behind.
 //
 // AND IT GROWS. A point on the rim emits outward too, and there is nobody
 // coming the other way, so that charge arrives alone at a site that did not
-// exist and makes it anyway. One ring per pulse, for ever, which is the whole
-// of what the expansion is.
+// exist and makes it anyway. Because the diagonals go out too, the rim that
+// grows is a square rather than a diamond: one ring per pulse, for ever, which
+// is the whole of what the expansion is.
 
-const XAX: [number, number][] = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+const XAX: [number, number][] = [
+  [1, 0], [-1, 0], [0, 1], [0, -1],
+  [1, 1], [1, -1], [-1, 1], [-1, -1],
+];
 
 const GREY = "140,147,168";                        // NEUTRAL, as the lattice is drawn
 
 const OUT = 0.62, HIT = 0.14, SETTLE = 0.24;       // one pulse, in seconds
 const PULSE = OUT + HIT + SETTLE;
-const PULSES = 6;                                  // before it starts again
+const PULSES = 5;                                  // before it starts again
 
 /** the nine it starts from: a three by three, on the even sites */
 const seed = () => {
@@ -1857,6 +1859,105 @@ const next = (alive: Set<string>) => {
   return hits;
 };
 
+// ── THE SAME THING ON A LINE ───────────────────────────────────────────────
+//
+// The two-dimensional picture is the one that matters, but it is hard to watch:
+// every site is alive and eight charges leave each of them at once. So the same
+// rule is drawn first in one dimension, where there is nothing to follow but
+// the rule itself.
+//
+// A point emits both ways and is spent doing it. The two charges that meet
+// between a neighbouring pair annihilate and leave a point there — so the
+// points end up on the sites BETWEEN where they were, which in 1D is the whole
+// of the alternation. At each end a charge goes out with nobody coming the
+// other way and makes a point anyway: one site per pulse, per end, for ever.
+//
+// There are no diagonals here, which is part of why it is worth showing.
+// Degree two, two charges, one rule; then the same rule with degree eight.
+
+const seed1 = () => new Set([-2, 0, 2]);           // three, on the even sites
+
+const next1 = (alive: Set<number>) => {
+  const hits = new Map<number, number>();
+  for (const i of alive) for (const dx of [1, -1])
+    hits.set(i + dx, (hits.get(i + dx) ?? 0) + 1);
+  return hits;
+};
+
+const expand1 = (): Painter => {
+  let t = 0, n = 0;
+  let alive = seed1();
+  let hits = next1(alive);
+
+  return {
+    frame: (s: Surface, dt: number) => {
+      const { ctx, width, height } = s;
+
+      t += dt;
+      while (t >= PULSE) {
+        t -= PULSE;
+        n++;
+        if (n >= PULSES) { alive = seed1(); n = 0; }
+        else alive = new Set(hits.keys());
+        hits = next1(alive);
+      }
+
+      const travel = Math.min(1, t / OUT);
+      const flash = t >= OUT && t < OUT + HIT ? 1 - (t - OUT) / HIT : 0;
+      const born = t < OUT + HIT ? 0 : Math.min(1, (t - OUT - HIT) / SETTLE);
+      const spent = travel;
+
+      ctx.clearRect(0, 0, width, height);
+      ctx.fillStyle = BACK; ctx.fillRect(0, 0, width, height);
+
+      const cx = width / 2, cy = height / 2;
+      const reach = 2 + PULSES;                      // as far out as it ever gets
+      const k = width / (2 * reach + 1);             // so the last pulse fills the width
+      const X = (i: number) => cx + i * k;
+
+      // the line the whole of it lives on, edge to edge
+      ctx.lineWidth = 1;
+      ctx.strokeStyle = `rgba(${GREY},0.16)`;
+      ctx.beginPath(); ctx.moveTo(0, cy); ctx.lineTo(width, cy); ctx.stroke();
+
+      // ── the charges, on their way ────────────────────────────────────────
+      if (born === 0 && travel > 0) {
+        ctx.lineWidth = 2;
+        for (const i of alive) for (const dx of [1, -1]) {
+          const px = X(i + dx * travel);
+          ctx.strokeStyle = `rgba(${GREY},0.85)`;
+          ctx.beginPath();
+          ctx.moveTo(X(i + dx * travel * 0.55), cy); ctx.lineTo(px, cy); ctx.stroke();
+          const h = Math.min(9, k * 0.22);
+          ctx.fillStyle = `rgba(${GREY},0.85)`;
+          ctx.beginPath();
+          ctx.moveTo(px + dx * h, cy);
+          ctx.lineTo(px - dx * h * 0.5, cy - h * 0.6);
+          ctx.lineTo(px - dx * h * 0.5, cy + h * 0.6);
+          ctx.closePath(); ctx.fill();
+        }
+      }
+
+      // ── where they met — two head-on inside, one alone at each end ───────
+      if (flash > 0) for (const [i, count] of hits) {
+        ctx.globalAlpha = flash * (count > 1 ? 1 : 0.5);
+        ctx.fillStyle = SEEN;
+        ctx.beginPath(); ctx.arc(X(i), cy, 2 + 6 * flash, 0, 2 * Math.PI); ctx.fill();
+        ctx.globalAlpha = 1;
+      }
+
+      // ── the points ───────────────────────────────────────────────────────
+      const dot = (i: number, alpha: number) => {
+        if (alpha <= 0.02) return;
+        ctx.fillStyle = `rgba(${GREY},${0.95 * alpha})`;
+        ctx.beginPath(); ctx.arc(X(i), cy, 5 * (0.4 + 0.6 * alpha), 0, 2 * Math.PI); ctx.fill();
+      };
+      if (born === 0) for (const i of alive) dot(i, 1 - spent);
+      else for (const i of hits.keys()) dot(i, born);
+    },
+  };
+};
+
 const expand = (): Painter => {
   let t = 0, n = 0;
   let alive = seed();
@@ -1893,10 +1994,10 @@ const expand = (): Painter => {
 
       ctx.lineCap = "round";
       ctx.lineWidth = 1.4;
-      ctx.strokeStyle = `rgba(${GREY},${0.30 * a})`;
+      ctx.strokeStyle = `rgba(${GREY},${0.22 * a})`;
       for (const key of show) {
         const [i, j] = key.split(",").map(Number);
-        for (const [dx, dy] of [[1, 1], [1, -1]]) {
+        for (const [dx, dy] of [[1, 0], [0, 1], [1, 1], [1, -1]]) {   // axes and diagonals both
           if (!show.has((i + dx) + "," + (j + dy))) continue;
           ctx.beginPath();
           ctx.moveTo(X(i), Y(j)); ctx.lineTo(X(i + dx), Y(j + dy)); ctx.stroke();
@@ -1905,18 +2006,20 @@ const expand = (): Painter => {
 
       // ── the charges, on their way, and the point spent sending them ──────
       if (born === 0 && travel > 0) {
-        ctx.lineWidth = 2;
+        // Eight per point, and every site is alive, so these are drawn faint —
+        // at full strength the interior is a solid mat and nothing reads.
+        ctx.lineWidth = 1.6;
         for (const key of alive) {
           const [i, j] = key.split(",").map(Number);
           for (const [dx, dy] of XAX) {
             const px = X(i + dx * travel), py = Y(j + dy * travel);
-            ctx.strokeStyle = `rgba(${GREY},0.9)`;
+            ctx.strokeStyle = `rgba(${GREY},0.42)`;
             ctx.beginPath();
-            ctx.moveTo(X(i + dx * travel * 0.65), Y(j + dy * travel * 0.65));
+            ctx.moveTo(X(i + dx * travel * 0.7), Y(j + dy * travel * 0.7));
             ctx.lineTo(px, py);
             ctx.stroke();
-            const ang = Math.atan2(-dy, dx), h = Math.min(6.5, k * 0.34);
-            ctx.fillStyle = `rgba(${GREY},0.9)`;
+            const ang = Math.atan2(-dy, dx), h = Math.min(4.5, k * 0.24);
+            ctx.fillStyle = `rgba(${GREY},0.42)`;
             ctx.beginPath();
             ctx.moveTo(px + h * Math.cos(ang), py + h * Math.sin(ang));
             ctx.lineTo(px + h * Math.cos(ang + 2.5), py + h * Math.sin(ang + 2.5));
@@ -1948,14 +2051,20 @@ const expand = (): Painter => {
   };
 };
 
+// `Paragraph` drops a non-string child into a centred flex Row, so a wrapper
+// without a width shrinks to the canvas' intrinsic 300px and sits in the middle
+// of the column. These say 100% so they take the width the text takes.
+
+export const WanderExpand1D = ({ height = 110 }: { height?: number }) =>
+  <div style={{ width: "100%", marginBottom: "1.1rem" }}>
+    <div style={{ width: "100%", height, background: BACK }}>
+      <CanvasView paint={expand1} />
+    </div>
+  </div>;
+
 export const WanderExpand = ({ height = 260 }: { height?: number }) =>
-  <div style={{ marginBottom: "1.1rem" }}>
-    <div style={{
-      fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
-      color: FAINT, marginBottom: 6,
-    }}>a point is spent making the next ones — so the lattice alternates rather
-      than sits still</div>
-    <div style={{ height, background: BACK }}>
+  <div style={{ width: "100%", marginBottom: "1.1rem" }}>
+    <div style={{ width: "100%", height, background: BACK }}>
       <CanvasView paint={expand} />
     </div>
   </div>;

From 5fce54e8199df01a54f436cc17a00ced9319eb11 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Fri, 14 Aug 2026 19:10:45 +0200
Subject: [PATCH 42/47] First section on gravity

---
 orbitmines.com/src/routes/Physics.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index 9ced1d9..8c3b8e1 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -304,12 +304,12 @@ const Physics = () => {
         <BR/>
 
         <Para>
-          Here for instance is the resulting of sending our <K><Bar>SHEET</Bar></K> in a 2D space. With only the gravity rules:
+          Here for instance is the resulting circle by sending our <K><Bar>SHEET</Bar></K> in a 2D space. With only the gravity rules:
         </Para>
 
         <WanderPure/>
 
-        If we instead skip ahead the story a little and include XOR, so magnetism, which we'll get to later. There's actual vacuum dynamics rather than just a grid trying to expand. Then random-looking dynamics still has an aggregate pressure our matter is creating by sending out 'gravity-rays'.
+        If we instead skip ahead the story a little and include XOR, so magnetism, which we'll get to later. There's actual vacuum dynamics by the grid trying to expand. The random-looking dynamics still has an aggregate pressure our matter is creating by sending out 'gravity-rays'.
 
         <WanderGravity/>
 

From cb02c76c3ba3b046b3de6b0972dda6684d53b025 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Fri, 14 Aug 2026 19:48:47 +0200
Subject: [PATCH 43/47] Generated notes for spherical influence

---
 orbitmines.com/src/routes/Physics.tsx | 61 +++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index 8c3b8e1..434d060 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -433,6 +433,43 @@ const Physics = () => {
             The two guards on it are both the same kind of honesty. The max says a shell is never smaller than the cell its source sits in, which is {HALF} from above. The <K><Bar>FLOOR</Bar></K> = 2 says that the innermost shell is not the continuum's 4<V>π</V>{HALF}<Sup>2</Sup> = 3.14 cells but the lattice's own: the surface of a cube at <V>d</V> steps is 24<V>d</V><Sup>2</Sup> + 2 cells, which at one step is exactly 26, exactly <K><Bar>DEG</Bar></K>. Without those two caps, chance at the core comes out at 8/4<V>π</V>{HALF}<Sup>2</Sup> = 2.546 — a probability, over one — and nobody had evaluated the floor to notice. With them it is 1.556, and read entirely off the cube rather than half off the continuum it would be 8/8 = 1 exactly, saturated and never exceeded, which is what a probability is allowed to do. <b>That last step is not taken here</b>, because 24<V>d</V><Sup>2</Sup> counts cells at Chebyshev distance where <K>chance</K> is asked with a Euclidean separation, and on a 26-connected lattice those differ by up to √3 depending on direction.
           </Para>
 
+          <Head>and the sphere in it is measured, not assumed</Head>
+
+          <Para>
+            One thing in that formula is doing more work than it looks, and the discrete panels above should make it uncomfortable. 4<V>π</V><V>r</V><Sup>2</Sup> is the surface of a <i>sphere</i>, and nothing here is a sphere: a charge moves one cell a tick, so one pulse is at <i>Chebyshev</i> distance <V>t</V> after <V>t</V> ticks — a cube, whose corners stand √3 further out than its faces. Scaling a cube gives a cube, so that never washes out with distance. If the warrant for 4π were "a pulse spreads over a shell", the warrant would be wrong.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>It is not what the shell is doing here.</b> Nothing in this model emits once. Every cell emits every tick, and what a force is read off is not a front but the <i>settled occupancy</i> — and settling is what forgets the lattice, because the 26-neighbour Laplacian's anisotropy enters only at fourth order. Put one absorber in a 101<Sup>3</Sup> vacuum, let it settle and average out the integer noise, and the deficit around it fits <V>A</V>(1/<V>r</V> − 1/<V>R</V>) to within 2% at every <V>r</V> ≥ 8: the 1/<V>r</V> potential whose gradient is the inverse square, arrived at without anybody writing either down.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And it is round. Along ⟨100⟩, ⟨110⟩ and ⟨111⟩ at matched Euclidean radius the deficit agrees to within 0.90–1.10 with no preferred axis — scatter, not shape. The test that separates the two candidates is sharp: a field that was really a function of Chebyshev distance would put ⟨111⟩ at <V>r</V> = 20 at the <V>r</V>/√3 = 12 value, which is 2.16. Measured, it is 0.775. <b>The cube is the shape of the front; the sphere is the shape of the field</b>, and every law in this section reads the second.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which also says what <K><Bar>FLOOR</Bar></K> is really for. The lattice does survive in the field, but only close in: ⟨111⟩ runs 21% high at <V>r</V> = 6 and is inside 5% by <V>r</V> = 10. So the cube-shell guard is a <i>near-field</i> correction sitting exactly where the anisotropy is real, rather than a claim about shells at every radius — and the refusal above to read the whole thing off the cube is not caution, it is the measurement. If the residual is ever wanted as a term rather than a guard, it has the form below, with <V>f</V><Sub>4</Sub> the cubic harmonic and <V>ε</V>, <V>n</V> read off the lattice rather than fitted to anything:
+          </Para>
+
+          <Eq note="a near-field angular term — dead by a few cells, and nothing astronomical is within 10³⁰ of it">
+            chance(<V>m</V>,<V>r</V>,<B>d̂</B>) =
+            <Frac over={<><V>m</V> · <K><Bar>SHEET</Bar></K></>} under={<>shell(<V>r</V>)</>} />
+            <span style={{ padding: '0 0.6em' }} />
+            ·
+            <span style={{ padding: '0 0.6em' }} />
+            <Paren>1 + <V>ε</V> · <V>f</V><Sub>4</Sub>(<B>d̂</B>) · <Paren><Frac over={<><V>r</V><Sub>0</Sub></>} under={<><V>r</V></>} /></Paren><Sup><V>n</V></Sup></Paren>
+          </Eq>
+
+          <Para>
+            One caveat on those numbers, since it is the kind of thing that goes unsaid. The run settles for 700 ticks against a relaxation time of about <V>R</V><Sup>2</Sup>/<V>D</V> ≈ 680, so the outermost shells are not fully relaxed and the fitted <V>R</V> comes out smaller than the box. That softens <V>R</V>. It does not touch the 1/<V>r</V> shape or the isotropy, which are read well inside it.
+          </Para>
+
           <Head>and what does not get through</Head>
 
           <Para>
@@ -1194,6 +1231,12 @@ const Physics = () => {
             Now put two of them in a world. Body <V>a</V> is spraying <V>m</V><Sub>a</Sub><K>l.<Bar>SHEET</Bar></K> charges a tick over shells that grow as <V>r</V><Sup>2</Sup>; so is body <V>b</V>; and the pull is the rate at which one of each finds the same cell.
           </Para>
 
+          <BR/>
+
+          <Para>
+            <b>A tick, not a pulse</b> — which is the whole reason the <V>r</V><Sup>2</Sup> is allowed to be a sphere's. Both bodies are emitting continuously, so what meets is two <i>settled</i> fields and not two fronts, and a settled field on this lattice is round to within a few percent past about four cells (measured above). The cube never enters the two-body law. It would, if either side were a single pulse caught in flight — and that case is the open one, not this one.
+          </Para>
+
           <Eq derive={MEETINGS}>
             <V>S</V><Sub>ab</Sub> &nbsp;=&nbsp; <K>BITE</K> ·
             <Paren><Frac over={<K>SHEET</K>} under={<>4<V>π</V></>} /></Paren><Sup>2</Sup>
@@ -1813,6 +1856,24 @@ const Physics = () => {
             Which is the honest state of it. <b>A circle is not recovered; it is chosen, by choosing what a heading is.</b> The lattice will as happily give a square, and a world where the discreteness of the spread genuinely mattered is not obviously ours to rule out — the residual here is a rank-four fingerprint worth 37 µm over a Hubble time, which is small but is not nothing, and is the one thing this whole route predicts that assuming a sphere never could.
           </Para>
 
+          <Head>except where it is recovered, which is where the law reads it</Head>
+
+          <Para>
+            Everything on this page is about <i>one pulse in flight</i>, and for one pulse the verdict above holds without qualification: the front is a cube, scaling a cube gives a cube, and no amount of blur or averaging or 10<Sup>39</Sup> constituents makes a twenty-seventh direction. But the force law never asks a front anything. It asks what is <i>at</i> a place, of a source that has been emitting every tick since it existed — and that is a settled field, which is a different object with a different shape.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>And the settled field is round, without choosing anything.</b> One absorber in a 101<Sup>3</Sup> vacuum on the 26-neighbour rule, run to steady state: the deficit fits <V>A</V>(1/<V>r</V> − 1/<V>R</V>) to 2% past <V>r</V> = 8, and ⟨100⟩, ⟨110⟩ and ⟨111⟩ agree to 0.90–1.10 at matched radius with no axis preferred. A Chebyshev field would read 2.16 where ⟨111⟩ at <V>r</V> = 20 reads 0.775. The reason is not a rule and not a repair: relaxation kills the anisotropy because the 26-neighbour Laplacian is isotropic to fourth order, and a cube is what only <i>ballistic</i> propagation preserves.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            So the two halves of this section are about two different questions and only one of them is open. <b>What is the shape of a pulse?</b> — a cube, chosen, and the choice is real physics with a 37 µm fingerprint on it. <b>What is the shape of a field?</b> — a sphere, derived, past about four cells, and that is the one <K>chance</K> divides by. The lattice survives in the near field, where ⟨111⟩ runs 21% high at <V>r</V> = 6 and is inside 5% by <V>r</V> = 10, which is exactly the range <K><Bar>FLOOR</Bar></K> was already guarding by hand.
+          </Para>
+
           <Law/>
         </Section>
       </Section>

From 7f5125be7b925e5277e1561f7d320528aa8c8fcc Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Fri, 14 Aug 2026 20:55:46 +0200
Subject: [PATCH 44/47] QM Layer 2 & Matter - separate into a separate tabs
 TODO

---
 orbitmines.com/src/routes/Physics.tsx         | 2252 ++++++++++++-----
 .../archive/2026.RayCalculiAndPhysics/law.tsx |  132 +
 2 files changed, 1689 insertions(+), 695 deletions(-)

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index 434d060..cf3330f 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -11,9 +11,9 @@ import { bySide, Graph } from "./archive/2026.RayCalculiAndPhysics/discrete";
 import { Echoes } from "./archive/2026.RayCalculiAndPhysics/echoes";
 import { Beam, Sheet } from "./archive/2026.RayCalculiAndPhysics/figures";
 import {
-  B, Bar, Because, CEILING, CLOCK, CONSTANTS, D, Eq, F, Frac, FULL, Hat, Head,
+  B, Bar, Because, CEILING, CLOCK, COHERENT, CONSTANTS, D, Eq, F, Frac, FULL, Hat, Head,
   IDENTICAL,
-  IGNORANCE, K, Law, LAW, MADE_FROM, MEETINGS, MET, METRIC, Paren, R, REACH, Rows,
+  IGNORANCE, K, Law, LAW, MADE_FROM, MEETINGS, MET, METRIC, Paren, R, REACH, RECORD, Rows,
   SPACE, Step, Sub, Sup, TURNS, V,
 } from "./archive/2026.RayCalculiAndPhysics/law";
 import { gravitational, massUnit } from "./archive/2026.RayCalculiAndPhysics/gravity";
@@ -1160,585 +1160,1331 @@ const Physics = () => {
             And it has no polarity in it anywhere. Every equation above would be word for word the same with the signs stripped out, which is worth knowing before the next arc puts them back: <b>the gravity here does not depend on the XOR</b>. What the XOR buys is magnetism, and what it costs is one factor that turns out not to be measurable. That is the next section.
           </Para>
         </Section>
+
         <Section head="Galaxy rotation curves">a</Section>
         <Section head="Black Holes">a</Section>
         <Section head="Expansion">a</Section>
         <Section head="The Discrete Model">
         </Section>
-        <Section head="TODO">
 
-          <Head>the rule, and there is only one</Head>
 
-          Everything up to here has been about one source letting go of things. What is still missing is what happens when two of them arrive at the same place, and that turns out to be the whole of gravity.
+      </Section>
+
+      <Section head="XOR: Gravity + Magnetism">
+
+        Instead of having our rays be neutral, we can introduce a polarity to them: positive/negative. When we do that gravity + magnetism comes down to three rules:
+        <BR/>
+        (G+M/1) Annihilation: When two opposite polarities meet, they annihilate, leaving a single neutral spatial point behind.
+
+        <Models models={[DISCRETE[5]]}/>
+
+        (G+M/2) Creation: On all axis, a neutral point expands into two points with opposite polarity in all directions.
+
+        <Models models={[BACKWARD[5]]}/>
+
+        (G+M/3) Repulsion: When two identical polarities meet, they turn around.
+
+        <Models models={[DISCRETE[4]]}/>
+
+        Then the other permutations of the rules are just movement rules (like these two).
+
+        <Models models={[DISCRETE[1]]}/>
+
+        With this setup, we get aggregate behavior of groups of the same polarities, turning away from each other.
+
+        <Models models={([
+            [Polarity.Positive, Polarity.Positive],
+            [Polarity.Negative, Polarity.Negative],
+        ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
+          name: '',
+          note: '',
+          lattice: {
+            seed: () => Graph.blocks({ charge: bySide(left, right) }),
+            ticks: 15, height: 140, density: false,
+          },
+        }))}/>
+
+        And ones with opposite polarities annihilating each-other.
+
+        <Models models={([
+            [Polarity.Positive, Polarity.Negative],
+        ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
+          name: '',
+          note: '',
+          lattice: {
+            seed: () => Graph.blocks({ charge: bySide(left, right) }),
+            ticks: 5, height: 140, density: false,
+          },
+        }))}/>
+
+        Then an interesting thing happens when you alternate polarities (the phase not mattering for this result). You get attraction. And we recover our two rules of gravity (G/1 + G/2) from these three rules.
+
+        <Models models={([
+          [Polarity.Positive, Polarity.Negative],
+          [Polarity.Positive, Polarity.Positive],
+        ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
+          name: '',
+          note: '',
+          lattice: {
+            seed: () => Graph.emitters({ left, right, gap: 20, every: 1, spin: true }),
+            ticks: 22, height: 140,
+          },
+        }))}/>
+
+        <Section head="Gravity vs XOR">
+          - the heaviest elementary thing goes from ≈1.36 µg to ≈2.71 µg
+          - a body of given physical mass pulses half as often
+
+          <Eq>
+            <K><Bar>G</Bar></K><Sup><R>XOR</R></Sup> = <Frac over={1} under={2} /><K><Bar>G</Bar></K>
+          </Eq>
+        </Section>
+        
+        <Section head="XOR Continuous Model">
+
+          <Eq derive={TURNS} note="two on a line, and eight at every dimension of two or more">
+            <K>l.<Bar>CYCLE</Bar></K> = ways(min(<K>l.<Bar>D</Bar></K>, 2)) =
+            3<Sup>min(<K>l.<Bar>D</Bar></K>, 2)</Sup> − 1
+            <span style={{ padding: '0 1.4em' }} />
+            <K><Bar>SPIN</Bar></K> =
+            <Frac over={<>2<V>π</V></>} under={<K><Bar>CYCLE</Bar></K>} /> = 45°
+          </Eq>
+
+          <Para>
+            The gravity arc counts <i>one</i> thing about an emitter: how often it lets go. That is mass. This arc keeps the second thing, which is <b>which way round it is when it does</b> — and the whole of the difference between the two models is what you do with a sign.
+          </Para>
 
           <BR/>
 
           <Para>
-            So here is the rule, before it gets dressed up. Two charges arriving at the same point annihilate if they are opposite — both points go, and whatever was behind each is joined onto whatever was behind the other. If they are alike, they leave along each other's headings instead. That is it. <b>Nothing is pushed.</b> There is no force anywhere in the rules, and I want to keep saying that because everything below is what its absence comes to.
+            So the plan for this section is: first what changes in the rules, then <i>where</i> the two models diverge — which is local and is the interesting part — then why the global answer is nevertheless the same, and then magnetism, which is what the signs buy.
+          </Para>
+
+          <Head>a charge as a number</Head>
+
+          <Para>
+            Give each ray a polarity and write it as a number, because that is the form both readings share: +1, −1, or 0 for neutral space. Then the entire interaction law is one expression.
+          </Para>
+
+          <Eq note="the whole interaction law, and it has exactly two outcomes">
+            agreement(<V>a</V>,<V>b</V>) =
+            <Frac over={<><V>ab</V></>} under={<>|<V>a</V>||<V>b</V>| + <V>ε</V></>} />
+            <span style={{ padding: '0 1.2em' }} />
+            alike = max(agreement, 0)
+            <span style={{ padding: '0 1.2em' }} />
+            cancelling = max(−agreement, 0)
+          </Eq>
+
+          <Para>
+            Alike is +1 and neither can cancel the other and neither can pass through it, so each turns around — that is (G+M/3). Opposite is −1 and they annihilate, taking the space they were on with them — that is (G+M/1), and it is the only event in the model that changes how much space there is. <b>Nothing in between ever happens to a pair on the lattice</b>, because a lattice charge is ±1 and the product of two of those is ±1.
           </Para>
 
           <BR/>
 
           <Para>
-            What there is instead is <i>less space than there was</i>. Two points became one, so everything behind them got closer together without anything having moved. Gravity here is that piece of bookkeeping, done often enough to notice. A body's momentum is then just its share of the meetings it took part in — <K>BIAS</K> of a step each, and <K>BIAS</K> is one meeting out of the <K><Bar>DEG</Bar></K> ways there were to go.
+            In between is what a <i>field</i> does, and it is not a third outcome — it is what you get when the same rule is applied to a great many pairs at once and the answer is how many of them went each way. Which is exactly why the continuous model can hand this same expression a fractional value and mean something true by it: <b>a polarity is a field value rounded off to its sign</b>, and every law is written against the number so neither reading has to restate it.
           </Para>
 
-          <Eq derive={LAW}
-            note="the momentum a body gains is BIAS times the annihilations it took part in, and what one is worth depends on where it happened">
-            <Frac over={<>d</>} under={<>d<V>t</V></>} />
-            ( <V>γ</V> <V>m</V><Sub>a</Sub> <B>v</B><Sub>a</Sub> )
-            &nbsp;=&nbsp; <K>BIAS</K> · <span style={{ fontSize: '1.3em' }}>Σ</span>
-            <Sub>b ≠ a</Sub> &nbsp;<V>S</V><Sub>ab</Sub> <Hat>r</Hat><Sub>ab</Sub>
-            &nbsp;· carry
+          <Head>where the two models actually diverge — and it is local</Head>
+
+          <Para>
+            Here is the thing worth being careful about, because it is easy to read the two models as the same theory with a different label on the rays, and they are not.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Take two rays coming head on. <b>Without polarity there is only one thing that can happen:</b> they meet, they annihilate, and the space goes <i>there</i>, at that cell, on that tick. <b>With polarity there are two.</b> If they disagree, the same thing happens in the same place. If they agree, they <i>turn around</i> — nothing is destroyed at that cell at all — and each travels back the way it came until it runs into the next wave its own source put out behind it. That wave is the opposite sign, because the source alternates. So they annihilate <i>there</i>: half a wavelength back, several ticks later, on the source's side of where the meeting was.
+          </Para>
+
+          <Eq note="the same two rays, the same eventual annihilation — a different cell and a different tick">
+            <F>no polarity</F>&nbsp;&nbsp;
+            meet at <V>x</V> &nbsp;→&nbsp; annihilate at <V>x</V>, on tick <V>t</V>
+            <span style={{ padding: '0 1.4em' }} />
+            <F>XOR</F>&nbsp;&nbsp;
+            meet at <V>x</V> &nbsp;→&nbsp; turn &nbsp;→&nbsp;
+            annihilate at <V>x</V> ∓ <V>λ</V>/2, on tick <V>t</V> + <V>λ</V>/2<V>c</V>
           </Eq>
 
           <Para>
-            Click it. The whole point of writing the model this way is that a page of counted constants and a page of six fitted ones look identical once they are typeset, and the only way to tell them apart is to be able to ask any line where it came from.
+            <b>That is a real difference and it is entirely local.</b> The map of where space is being destroyed is different between the two models — the XOR one puts its annihilations on the near side of the midline in bands, one per half-cycle, rather than all of them on the surface between the sources. It is the same difference that makes the aggregate panels in the previous section behave as they do: alternating polarities attract because the meetings land where they land, and matched polarities turn away because the meetings keep getting pushed back.
           </Para>
 
-          <Head>and what mass turns out to be</Head>
+          <BR/>
 
           <Para>
-            Mass is not a property something has in this model. It is <i>how often it lets go</i> — one pulse every <V>X</V> ticks, with <V>X</V> = 1/<V>m</V>, and nothing lets go more than once a tick because nothing does anything more than once a tick.
+            And then a second thing changes with it, in the opposite direction. Without a sign, there is nothing left to decide an outcome <i>but</i> the angle — so the angular gate comes back and a meeting only counts when the two are closing on each other, which bounds the folding to a lens between the bodies. With a sign, the sign decides it and being in the same cell is the whole of the condition, at any angle; what the angle sets is not <i>whether</i> but <i>how much</i>.
           </Para>
 
-          <Eq derive={CLOCK}
-            note="a heavier thing pulses more often, and nothing pulses more than once a tick">
-            <V>X</V> = 1/<V>m</V>
-            <span style={{ padding: '0 1.4em', color: FAINT }}>ticks between pulses</span>
-            <V>X</V>·<V>c</V> = <V>G</V> · <V>λ</V><Sub>Compton</Sub>
+          <Eq note="what the angle is for, once polarity decides the outcome">
+            closing(<B>u</B>,<B>v</B>) = max(−<B>u</B>·<B>v</B>, 0)
+            <span style={{ padding: '0 1.2em' }} />
+            <K><Bar>HEAD_ON</Bar></K> = 1/√2
+            <span style={{ padding: '0 1.2em' }} />
+            splice(<B>u</B>,<B>v</B>) = |<B>û</B> − <B>v̂</B>| = 2 sin(<V>θ</V>/2)
           </Eq>
 
           <Para>
-            Two things fall out of that and neither was aimed at. The first is the <b>equivalence principle</b>: what bends a body is the <i>fraction</i> of its own paths that got biased, and its count of paths is its mass, so the mass divides straight back out and everything falls the same way. It was never put in.
+            splice is how much a meeting <i>shortens</i>: two cells for two rays head on, nothing at all for two going the same way. Which is the honest reading of what an annihilation does to a distance, and it needs the angle whether or not there are signs.
+          </Para>
+
+          <Head>and why the global answer is the same anyway</Head>
+
+          <Para>
+            Two rules changed and they pull opposite ways, and when you write them into <V>S</V><Sub>ab</Sub> they land on the same factor.
+          </Para>
+
+          <Rows of={[
+            [<><i>share</i>: ½ → 1</>,
+              <>Without polarity <b>every</b> meeting annihilates, where before only the
+                opposite half did. So the share doubles.</>],
+            [<>the angular gate</>,
+              <>Comes back, since there is nothing else left to decide an outcome. So the
+                folding is bounded to a lens again.</>],
+          ]} />
+
+          <Eq note="G doubles — and that is the whole of it">
+            <i><K><Bar>G</Bar></K></i> = <Frac
+              over={<><K><Bar>BITE</Bar></K>·<i>share</i>·<K><Bar>SHEET</Bar></K><Sup>2</Sup>·<K><Bar>c</Bar></K></>}
+              under={<>4<V>π</V><Sup>2</Sup>·{HALF}·<K><Bar>DEG</Bar></K></>} />
+            <span style={{ padding: '0 1.4em' }} />
+            {gravitational(0.5).toFixed(6)} → {gravitational(1).toFixed(6)}
+          </Eq>
+
+          <Para>
+            <b>And the factor of two is not observable in an orbit.</b> Every mass in the model is carried in units of <i><K><Bar>G</Bar></K></i>, so a body of physical mass <V>M</V> holds <V>M</V>/<i><K><Bar>G</Bar></K></i> and the dynamics compute <i><K><Bar>G</Bar></K></i>·(<V>M</V>/<i><K><Bar>G</Bar></K></i>). The constant is gone before it is used — <b>a change of the mass unit, not of a trajectory</b>. Measured on the line integral: exactly two at every separation, with <V>S</V>·<V>R</V><Sup>2</Sup> flat in both.
           </Para>
 
           <BR/>
 
           <Para>
-            The second is that "period = 1/mass" in lattice units <i>is</i> the Compton relation, at every mass, across twenty orders. The ratio comes out at 0.062351 exactly for an electron, a proton, an iron atom and a neodymium atom alike, because <V>m</V><Sub>P</Sub><V>l</V><Sub>P</Sub> = ħ/<V>c</V> — and that number is the gravitational constant in the lattice's own units, which by the bar convention above is <K><Bar>G</Bar></K>, the discrete form of <V>G</V>.
+            <b>But "not of a prediction" would be too strong, and the exception is the mass unit itself.</b> It is not free to stay put — <V>µ</V> = <i><K><Bar>G</Bar></K></i>·<V>m</V><Sub>P</Sub>, so doubling one doubles the other. The heaviest elementary thing goes from <b>{(massUnit(0.5) * 1e9).toFixed(3)} µg to {(massUnit(1) * 1e9).toFixed(3)} µg</b>, and a body of given physical mass pulses <b>half as often</b>: an electron every 1.61·10<Sup>−22</Sup> s against 8.03·10<Sup>−23</Sup>. Which is the right direction rather than a fault — with no polarity every meeting annihilates instead of half of them, so each emission is twice as effective and half as much of it is needed for the same pull. Nothing measures that ceiling, so it refutes neither version; but it is a statement about the world, and it moves.
           </Para>
 
           <BR/>
 
           <Para>
-            And there is a ceiling: one pulse a tick is the fastest anything can be, so there is a heaviest elementary thing, <K><Bar>G</Bar></K>·<V>m</V><Sub>Planck</Sub> ≈ 1.36 µg. Anything heavier is <i>many</i> emitters, which is what matter is. At the ceiling the beat is one tick, and that tick comes out at 5.391246·10<Sup>−44</Sup> s against a Planck time of 5.391246·10<Sup>−44</Sup> s. Ratio 1.000000000. <b>The lattice's tick is the Planck time</b>, and it is an identity rather than a coincidence — <K><Bar>G</Bar></K> cancels out of it.
+            The tick and the step do <i>not</i> go with it, which is worth checking rather than assuming. At the ceiling the period is <i><K><Bar>G</Bar></K></i>ħ/(<V>µc</V><Sup>2</Sup>) = ħ/(<V>m</V><Sub>P</Sub><V>c</V><Sup>2</Sup>) — the <i><K><Bar>G</Bar></K></i> cancels — so both stay exactly Planck at either share. And so does the Compton line, whose constant tracks <i><K><Bar>G</Bar></K></i> because <V>µ</V> does: measured, <V>k</V>/<i><K><Bar>G</Bar></K></i> = 1.000000000 at both.
           </Para>
 
-          <Head>what one body does to another</Head>
+          <BR/>
 
           <Para>
-            Now put two of them in a world. Body <V>a</V> is spraying <V>m</V><Sub>a</Sub><K>l.<Bar>SHEET</Bar></K> charges a tick over shells that grow as <V>r</V><Sup>2</Sup>; so is body <V>b</V>; and the pull is the rate at which one of each finds the same cell.
+            <K><Bar>SHEET</Bar></K>, <K><Bar>DEG</Bar></K>, <K><Bar>BITE</Bar></K>, <K><Bar>BIAS</Bar></K>, {HALF}, <V>ε</V>, <V>D</V>, the reach, the step and the tick do not move at all. And neither does anything <i>measured</i>: Mercury's sixth, the other five sixths, light's deflection, <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π, the Milky Way to 1.1%, the transport turnover, the interpolation function, the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>. <b>All identical, to every digit quoted</b> — because every one of them is computed from something that never mentions a sign.
           </Para>
 
           <BR/>
 
           <Para>
-            <b>A tick, not a pulse</b> — which is the whole reason the <V>r</V><Sup>2</Sup> is allowed to be a sphere's. Both bodies are emitting continuously, so what meets is two <i>settled</i> fields and not two fronts, and a settled field on this lattice is round to within a few percent past about four cells (measured above). The cube never enters the two-body law. It would, if either side were a single pulse caught in flight — and that case is the open one, not this one.
+            So the honest statement of the divergence is: <b>the two models put their annihilations in different places and get the same pull out of them.</b> Locally different, globally identical. Which makes the XOR a free parameter on the gravitational side — turning it on costs nothing and buys magnetism, turning it off costs magnetism and buys nothing — and that is a better position than the page was in before the question was asked, because it means the magnetic half cannot break the gravitational one. There is no shared number for it to get wrong.
           </Para>
 
-          <Eq derive={MEETINGS}>
-            <V>S</V><Sub>ab</Sub> &nbsp;=&nbsp; <K>BITE</K> ·
-            <Paren><Frac over={<K>SHEET</K>} under={<>4<V>π</V></>} /></Paren><Sup>2</Sup>
-            · share · screen · <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> ·
-            met(<V>R</V>)
-          </Eq>
+          <Head>the sign law was already inside G</Head>
 
           <Para>
-            The only awkward piece is met(<V>R</V>), which is that rate integrated along the whole line between them rather than evaluated at one point — and it collapses. One inverse square, times a bracket that goes to one.
+            Except for one, and this is the part I did not expect. <V>G</V>'s derivation carries a factor it has never had to justify: <i>half of them opposite</i>. That half is the chance that two charges landing in the same cell have opposite sign — and it is not a constant. It is a fact about the matter involved. Half is what you get when both bodies are unbiased. Ordinary matter is unbiased. <b>That is the whole reason it ever looked like a number.</b>
           </Para>
 
-          <Eq derive={MET} note="one inverse square, times one bracket that goes to one">
-            met(<V>R</V>) &nbsp;=&nbsp;
-            <Frac over={<>4</>} under={<><V>c R</V><Sup>2</Sup></>} />
-            <Paren>
-              1 &nbsp;+&nbsp; <Frac over={<V>c</V>} under={<V>R</V>} /> ln
-              <Frac over={<><V>R</V> − <V>c</V></>} under={<V>c</V>} />
-            </Paren>
-          </Eq>
+          <BR/>
 
           <Para>
-            Which leaves the constants, and this is the part I actually care about. <K>BIAS</K> is one way out of <K><Bar>DEG</Bar></K>. <V>c</V> is a step over a tick. And <V>G</V> is not measured, chosen or fitted — it is written entirely in counts we already have.
+            Put the bias back. If a fraction (1+<V>P</V>)/2 of a body's charges are positive at a place, then of the meetings between <V>a</V>'s and <V>b</V>'s:
           </Para>
 
-          <Eq derive={FULL}
-            note={<>the bracket is 1.08 at a core of half a lattice step and Mercury's
-              separation — and 1 + 10⁻³⁸ at the grain a real lattice would have</>}>
-            <Frac over={<>d<V>p</V></>} under={<>d<V>t</V></>} /> &nbsp;=&nbsp;
-            <V>G</V> ·
-            <Frac over={<><V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub></>}
-              under={<><V>R</V><Sup>2</Sup></>} />
-            <Paren>
-              1 &nbsp;+&nbsp; <Frac over={<V>c</V>} under={<V>R</V>} /> ln
-              <Frac over={<><V>R</V> − <V>c</V></>} under={<V>c</V>} />
-            </Paren>
-            <Hat>r</Hat>
+          <Eq note="opposite annihilates, alike turns — and there is nothing else two charges can do">
+            annihilating(<V>P</V><Sub>a</Sub>,<V>P</V><Sub>b</Sub>) =
+            <Frac over={<>1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub></>} under={<>2</>} />
             <span style={{ padding: '0 1.4em' }} />
-            <V>G</V> =
-            <Frac over={<><K>SHEET</K><Sup>2</Sup></>}
-              under={<>4<V>π</V><Sup>2</Sup> <V>c</V> <K>DEG</K></>} />
+            turning(<V>P</V><Sub>a</Sub>,<V>P</V><Sub>b</Sub>) =
+            <Frac over={<>1 + <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub></>} under={<>2</>} />
+          </Eq>
+
+          <Eq note="like biases attract less, opposite attract more — and at P = 0 it is Newton exactly">
+            <V>F</V> = <Frac
+              over={<><V>G</V> <V>m</V><Sub>a</Sub> <V>m</V><Sub>b</Sub></>}
+              under={<><V>R</V><Sup>2</Sup></>} />
+            <span style={{ padding: '0 0.5em' }} />
+            (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)
           </Eq>
 
           <Para>
-            <b>Newton, times a bracket that goes to one.</b> The whole of the departure from Newton at a distance is that bracket, and its size is the ratio of a source's core to the separation — so it is 1.08 for a source half a lattice step across at Mercury's distance, and 1 + 10<Sup>−38</Sup> at the grain a real lattice would have. There is nothing left in the expression to tune.
+            Read off the split. Unbiased against unbiased is one half and one half, which <i>is</i> the ½ in <V>G</V>, so Newton is the <V>P</V> = 0 case and not a separate claim. Biased against unbiased is also one half — a bias does nothing to something with no bias of its own, which comes out of the arithmetic rather than being put in by hand. Same bias gives nought; opposite bias gives twice. <b>Opposites attract and sameness repels, derived</b> — which is where this whole idea started, and which is the sign law <Ref of={'Coulomb, "Premier mémoire sur l\'électricité et le magnétisme", Histoire de l\'Académie Royale des Sciences 569'} year="1785" at="https://gallica.bnf.fr/ark:/12148/bpt6k3570k/f662" /> wrote down as an observation.
           </Para>
 
           <BR/>
 
-          And the honest way to check that is to run it rather than to admire it. Same rules, no orbital mechanics anywhere, only bodies letting go of charges and charges meeting.
+          <Para>
+            Which is worth stopping on: <b>the gravitational constant carries a factor of one half because ordinary matter is unbiased.</b> If matter had a net bias, <V>G</V> would be a different number. The half was already there and unexplained; this is what it was — and it needs no reading whatever of what the bias <i>is</i>.
+          </Para>
 
-          <Models models={named('the Sun and Mercury', 'the inner solar system', 'the Earth and the Moon')} />
+          <Head>one emission, three moments of it</Head>
+
+          <Para>
+            Gravity used the zeroth moment of the emission and threw the rest away. Keep them and the same emission answers three different questions.
+          </Para>
+
+          <Eq note="the count is mass, the signed sum is a net, the signed first moment is a bias">
+            <V>m</V> = ⟨1⟩<span style={{ padding: '0 1.6em' }} />
+            <V>q</V> = ⟨<V>s</V>⟩<span style={{ padding: '0 1.6em' }} />
+            <V>µ</V> = ⟨<V>s</V> <B>d̂</B>⟩
+          </Eq>
+
+          <Para>
+            And that is why the two behave so differently, which is not a coincidence. <b>A count always adds</b>, so gravity has one sign and cannot be screened by cancellation. <b>A signed sum cancels</b>, so a bias comes in two kinds and ordinary matter has none of it while still having all of its mass.
+          </Para>
+
+          <Head>what a source is doing at a given moment</Head>
+
+          <Para>
+            A source has exactly two switches and they are independent: whether it has <i>sides</i> (an axis) and whether it <i>comes round</i> (turns, or flips). Crossing them gives four distinguishable emissions, and the whole of what a source is doing at a tick is three lines.
+          </Para>
+
+          <Eq note="where its north points, and what it emits that way">
+            rate(<V>s</V>) ∈ [0, 1]
+            <span style={{ padding: '0 1.2em', color: FAINT }}>turns per <K><Bar>CYCLE</Bar></K> ticks</span>
+            <V>β</V>(<V>s</V>,<V>t</V>) = phase +
+            <Frac over={<><V>t</V>·rate</>} under={<K><Bar>CYCLE</Bar></K>} />
+          </Eq>
+
+          <Eq note="a spiral and a ring are the same function with and without an angle in it">
+            <V>F</V>(<B>d</B>) = sided ? <B>d</B>·<B>n̂</B>(<V>β</V>) : cos(2<V>π</V><V>β</V>)
+          </Eq>
+
+          <Para>
+            <i>Sided</i> is the only thing separating the two kinds of source, and it is not a parameter so much as a question about the source. With sides, what it emits depends on the direction — the field carries a θ in it, its zero set is θ = 2π<V>β</V> + const, and that is an Archimedean spiral. Without, direction drops out altogether, the zero set is a set of <i>instants</i> rather than places, and what travels out is rings.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And whatever the four turn out to be, <b>none of them can be a sided source with a net</b>: there is no way to be sided without having two sides. Checked over twenty thousand axes the net emission is exactly nought every time, because the lattice's exits come in ± pairs so a direction and its opposite always get opposite signs. That is ∇·<B>B</B> = 0 and the absence of monopoles — the symmetry <Ref of={'Maxwell, "A Dynamical Theory of the Electromagnetic Field", Phil. Trans. R. Soc. Lond. 155:459'} year="1865" at="https://doi.org/10.1098/rstl.1865.0008" /> had to write in as an observation, and which this model cannot avoid.
+          </Para>
+
+          <Head>a magnet is a lopsided default, not a stopped one</Head>
+
+          <Para>
+            The constraint that decides this whole section is that <b>a magnet still has to pulse its weight</b>. The two clocks are independent — <K><Bar>beat</Bar></K> = 1/<V>m</V> is how often it lets go, rate is how fast its axis comes round — so magnetising a thing cannot change what it weighs, and an emitter never has to stop. Both go on at once, and the magnet is the amount by which the alternation fails to come out even.
+          </Para>
+
+          <Eq note="a lopsided default, not a stopped one — and dwell is a count of ticks, so P is quantised">
+            <K><Bar>dwell</Bar></K> = <V>k</V>/<K><Bar>CYCLE</Bar></K>
+            <span style={{ padding: '0 1.2em' }} />
+            <V>P</V> = 2·<K><Bar>dwell</Bar></K> − 1
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>P</V> ∈ {'{'}0, ¼, ½, ¾, 1{'}'}
+          </Eq>
+
+          <Para>
+            A source turning at full rate is at <K><Bar>dwell</Bar></K> = ½ and has no magnet in it: its axis passes through all <K><Bar>CYCLE</Bar></K> directions, a fixed direction sees + + + 0 − − − 0, and the mean is nought. Turning it slower does not help — the same states in the same order, held longer each — which is worth being explicit about, because slowing <i>looks</i> like it should magnetise and does not. It changes the wavelength of what comes out and not the mean.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And <K><Bar>dwell</Bar></K> is a count of ticks, so the smallest magnetisation a single emitter can carry is 2/<K><Bar>CYCLE</Bar></K> = <b>a quarter</b>. Magnetisation comes in units, with nothing free in it. Against that, a saturated neodymium magnet measures <V>P</V> = 1.51·10<Sup>−5</Sup> in bulk: <b>99.9985% of what it emits cancels</b>, and what a magnet <i>is</i> is the fifteen parts per million that failed to.
+          </Para>
+
+          <Head>and where the bias lives decides everything</Head>
+
+          <Para>
+            There are two places the bias could sit and only one of them is a magnet. Put it on a <i>direction</i> — one emitter, + out of its north half and − out of its south, from a single place — and it fails: pole to pole gives <b>exactly nothing</b>, by an exact cancellation, and the fall-off is 1/<V>R</V><Sup>2</Sup> where two magnets are 1/<V>R</V><Sup>4</Sup>. Giving the emitter a ring does not rescue it, at any phase.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Put it on a <i>place</i> and everything works. A bar magnet is then a lump biased + at one end and − at the other — net zero because the two ends cancel, <b>separated in space rather than in direction</b> — which is what magnetostatics has always called the pole model. Nothing else changes: the same <K>chance</K>, the same co-location rule, the same (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)/2 XOR whose unbiased case is the half inside <V>G</V>. And the field is integrated from the model's own signed emission rather than from a textbook formula.
+          </Para>
+
+          <Eq note="the field of a bar, summed over its two pole faces — and that sum IS a dipole">
+            <B>B</B>(<V>r</V>) = <span style={{ fontSize: '1.3em' }}>Σ</span><Sub>faces</Sub>
+            <Frac over={<>sign · <K><Bar>SHEET</Bar></K></>}
+              under={<>4<V>π r</V><Sup>2</Sup></>} />
+            <span style={{ padding: '0 1.4em' }} />
+            ⟨annihilation excess⟩ ∝ 3cos<Sup>2</Sup><V>θ</V> − 1
+            <span style={{ padding: '0 1.2em' }} />
+            <V>F</V> ∝ 1/<V>R</V><Sup>4</Sup>
+          </Eq>
+
+          <Para>
+            Measured over the whole of space by integrating the annihilation excess: <b>3cos²<V>θ</V> − 1 to three decimals</b> at every angle including both sign changes, <b>slope −2.00</b> on gravity's own 1/<V>R</V><Sup>2</Sup> so the force between two of them is 1/<V>R</V><Sup>4</Sup>, and all five orientations right — N–S facing, N–N facing, side by side either way, and one across the other giving nought to 10<Sup>−19</Sup>. That is magnetostatics, out of the same machinery that gave the rotation curve, with <b>nothing added to it</b>.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            It also says why <b>cutting a magnet gives two magnets</b> rather than two monopoles: the sign belongs to a region's boundary, so a new cut makes a new pair of faces. And ∇·<B>B</B> = 0 survives for the same reason — a body's two poles are the same emitters counted at both ends, so they are equal and opposite by construction.
+          </Para>
+
+          <Head>the size, which is the one thing owed</Head>
+
+          <Para>
+            The mechanism is settled and the <i>size</i> is not. First, it cannot come from the mass stream: if the biased pulses were a subset of the mass pulses the whole effect would be the (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>) factor, which runs 0 to 2, <b>so the most magnetism could ever be is one times gravity</b> — and two touching N52 cubes pull 2.2·10<Sup>12</Sup> times their own gravity. Settled, and cleanly: magnetism is its own layer with its own budget.
+          </Para>
+
+          <Eq note="one emitter's moment, the scaling in the constituent, and the conversion the layer costs">
+            <K><Bar>MAGNETON</Bar></K> =
+            <Frac over={<><K><Bar>CYCLE</Bar></K>·<V>G</V></>} under={<>2<V>π</V></>} /> = 0.0794 <V>µ</V><Sub>B</Sub>
+            <span style={{ padding: '0 1.2em' }} />
+            <V>µ</V><Sub>max</Sub>/<V>M</V> ∝ 1/<V>m</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em' }} />
+            <V>m</V><Sub>eff</Sub> = <V>q</V>√(<V>µ</V><Sub>0</Sub>/4<V>πG</V>) = 38.7 kg per A·m
+          </Eq>
+
+          <Para>
+            One emitter's ring has radius (<K><Bar>CYCLE</Bar></K>·<V>G</V>/2<V>π</V>)·<V>λ̄</V><Sub>C</Sub>, and <V>λ̄</V><Sub>C</Sub> goes as 1/<V>m</V>, so a <i>heavier</i> emitter is a <i>smaller</i> loop and per kilogram the moment goes as 1/<V>m</V><Sup>2</Sup> in whatever the body is made of. <b>The lightest constituent wins by the square</b> — which is the fact <V>µ</V><Sub>B</Sub>/<V>µ</V><Sub>N</Sub> = 1836 records, so the model derives that magnetism is electronic rather than assuming it.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And the conversion has no material in it, which is what makes it a bill rather than a fit: a 1 cm N52 cube must emit as if it weighed <b>four and a half tonnes</b>, six hundred thousand times its own mass. The ratio is not constant across magnets — it runs 6·10<Sup>3</Sup> to 6·10<Sup>5</Sup>, going as <V>M</V>/<V>ρL</V>, because <b>a pole is a surface and mass is a volume</b>. Divide the geometry out and what is left <i>is</i> constant: 4.5·10<Sup>7</Sup> kg/m² of pole face for saturated N52, one number reproducing all six geometries with no residual. <b>That number is the whole of what this arc owes</b>, and it is the same shape <V>a</V><Sub>0</Sub> was before <V>cH</V><Sub>0</Sub>/2π — a coupling waiting for a count.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Because there is one ceiling, the budget is <i>shared</i>: pulses spent being a magnet are not being mass, so <b>magnetising a thing makes it lighter</b>, by exactly the fraction diverted. The cheap version of that is already dead — if the diverted fraction were the bulk bias itself, 1.5·10<Sup>−5</Sup>, a kilogram bar would lose 10 mg on being saturated, five orders above what a comparator would miss. So the magnetic layer's pulses are worth at least 10<Sup>14</Sup> gravitational ones, and that floor comes from a weighing rather than from a choice.
+          </Para>
+
+          <Head>and the three things this arc gets wrong</Head>
+
+          <Rows of={[
+            [<><V>g</V> = 1</>,
+              <>An emitter going round a loop at <K><Bar>c</Bar></K> has <V>µ</V> =
+                <V>qcr</V>/2 and <V>L</V> = <V>mcr</V>, so <V>µ</V>/<V>L</V> = <V>q</V>/2
+                <V>m</V> with the radius cancelling — the classical ratio. The electron's is
+                2.0023 to fourteen figures{' '}
+                <Ref of={'Hanneke, Fogwell & Gabrielse, "New Measurement of the Electron Magnetic Moment and the Fine Structure Constant", Phys. Rev. Lett. 100:120801'} year="2008" at="https://doi.org/10.1103/PhysRevLett.100.120801" />.
+                This one survives every choice, which makes it the sharpest.</>],
+            [<>the easy axis</>,
+              <>A held emitter puts + into every exit whose projection on its axis is
+                positive, and there are only <K><Bar>DEG</Bar></K> = 26 exits, so that split
+                is a <i>count</i>: 9 + / 8 equator / 9 − on a face or edge axis, 10 / 6 / 10
+                on a corner. So the model predicts ⟨111⟩ is the easy axis <b>by 11.1% in
+                every cubic material</b>. Right for nickel, wrong for iron, and flat where
+                measurement runs from 2.6% to 32%. A real prediction, in the right decade,
+                refuted in detail.</>],
+            [<><V>P</V> is not charge</>,
+              <>Emission rate goes as mass, so if the bias were electric charge a proton
+                would carry <b>1836 times</b> an electron's. Measurement has the two equal to
+                one part in 10<Sup>21</Sup>{' '}
+                <Ref of={'Baumann, Gähler, Kalus & Mampe, "Experimental limit for the charge of the free neutron", Phys. Rev. D 37:3107'} year="1988" at="https://doi.org/10.1103/PhysRevD.37.3107" />.
+                Whatever <V>P</V> is, it is not <V>q</V>, and everything here is read as
+                magnetism.</>],
+          ]} />
+
+          <Head>and the one number the whole thing owes</Head>
+
+          <Para>
+            Every force in this model is second order in the emission — nothing happens to a charge that does not <i>meet</i> another charge — so the electric force is capped at the size of gravity, and measurement puts it 4.166·10<Sup>42</Sup> above. What is worth saying is that <b>the hierarchy itself is not the mystery</b>.
+          </Para>
+
+          <Eq note="if the coupling were a count of order one where gravity is a product of two rates">
+            <Frac over={<V>α</V>} under={<>(<V>m</V><Sub>e</Sub>/<V>m</V><Sub>P</Sub>)<Sup>2</Sup></>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            4.166·10<Sup>42</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            <V>F</V><Sub>e</Sub>/<V>F</V><Sub>g</Sub>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>measured</span>
+          </Eq>
+
+          <Para>
+            The gap is the mass in Planck units squared, which is the measured ratio to five figures because that is what those symbols mean. <b>The bill is exactly one number, <V>α</V></b>, and nothing here derives it. Of 117,649 lattice monomials searched, 51 land within half a percent of 137.036 — so a hit would not be evidence, and none is claimed.
+          </Para>
+
+          <Head>the divergence, in one place</Head>
+
+          <Rows of={[
+            [<>what changes locally</>,
+              <>Alike charges <i>turn</i> instead of annihilating, so their annihilation
+                happens half a wavelength back and several ticks later, against the
+                following wave rather than against each other. <b>The map of where space is
+                destroyed is different.</b></>],
+            [<>what changes globally</>,
+              <><i>share</i> ½ → 1 and the angular gate returns, so <V>G</V> doubles — and
+                masses are carried in units of <V>G</V>, so <b>nothing measurable moves at
+                all</b>.</>],
+            [<>what the signs buy</>,
+              <>The sign law (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>), which explains
+                the ½ that was already sitting unexplained inside <V>G</V>. Magnetisation
+                quantised in quarters. ∇·<B>B</B> = 0 and no monopoles. The dipole
+                3cos²<V>θ</V> − 1 and the 1/<V>R</V><Sup>4</Sup> force. That cutting a magnet
+                halves it. That the lightest constituent wins by the square.</>],
+            [<>what they cost</>,
+              <>One coupling — 4.5·10<Sup>7</Sup> kg/m² of pole face — measured rather than
+                counted. And three refutations: <V>g</V> = 1, the flat 11.1% anisotropy, and
+                that the bias cannot be electric charge.</>],
+            [<>what is not started</>,
+              <>The electric half, entirely: charge, <V>ε</V><Sub>0</Sub>, <V>α</V>, Faraday,
+                Ampère–Maxwell, the Lorentz force. Those need a model of matter <i>and</i> a
+                first-order channel, and neither exists — a force here is a <i>meeting</i>,
+                which is second order. That one fact is the whole of the missing column.</>],
+          ]} />
+
+        </Section>
+        <Section head="XOR Discrete Model">
+        </Section>
+
+      </Section>
+      
+      <Section head="Electromagnetism">
+     
+      </Section>
+
+      <Section head="AI Generated">
+
+        
+        <Section head="TODO">
+
+          <Head>the rule, and there is only one</Head>
+
+          Everything up to here has been about one source letting go of things. What is still missing is what happens when two of them arrive at the same place, and that turns out to be the whole of gravity.
+
+          <BR/>
+
+          <Para>
+            So here is the rule, before it gets dressed up. Two charges arriving at the same point annihilate if they are opposite — both points go, and whatever was behind each is joined onto whatever was behind the other. If they are alike, they leave along each other's headings instead. That is it. <b>Nothing is pushed.</b> There is no force anywhere in the rules, and I want to keep saying that because everything below is what its absence comes to.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What there is instead is <i>less space than there was</i>. Two points became one, so everything behind them got closer together without anything having moved. Gravity here is that piece of bookkeeping, done often enough to notice. A body's momentum is then just its share of the meetings it took part in — <K>BIAS</K> of a step each, and <K>BIAS</K> is one meeting out of the <K><Bar>DEG</Bar></K> ways there were to go.
+          </Para>
+
+          <Eq derive={LAW}
+            note="the momentum a body gains is BIAS times the annihilations it took part in, and what one is worth depends on where it happened">
+            <Frac over={<>d</>} under={<>d<V>t</V></>} />
+            ( <V>γ</V> <V>m</V><Sub>a</Sub> <B>v</B><Sub>a</Sub> )
+            &nbsp;=&nbsp; <K>BIAS</K> · <span style={{ fontSize: '1.3em' }}>Σ</span>
+            <Sub>b ≠ a</Sub> &nbsp;<V>S</V><Sub>ab</Sub> <Hat>r</Hat><Sub>ab</Sub>
+            &nbsp;· carry
+          </Eq>
+
+          <Para>
+            Click it. The whole point of writing the model this way is that a page of counted constants and a page of six fitted ones look identical once they are typeset, and the only way to tell them apart is to be able to ask any line where it came from.
+          </Para>
+
+          <Head>and what mass turns out to be</Head>
+
+          <Para>
+            Mass is not a property something has in this model. It is <i>how often it lets go</i> — one pulse every <V>X</V> ticks, with <V>X</V> = 1/<V>m</V>, and nothing lets go more than once a tick because nothing does anything more than once a tick.
+          </Para>
+
+          <Eq derive={CLOCK}
+            note="a heavier thing pulses more often, and nothing pulses more than once a tick">
+            <V>X</V> = 1/<V>m</V>
+            <span style={{ padding: '0 1.4em', color: FAINT }}>ticks between pulses</span>
+            <V>X</V>·<V>c</V> = <V>G</V> · <V>λ</V><Sub>Compton</Sub>
+          </Eq>
+
+          <Para>
+            Two things fall out of that and neither was aimed at. The first is the <b>equivalence principle</b>: what bends a body is the <i>fraction</i> of its own paths that got biased, and its count of paths is its mass, so the mass divides straight back out and everything falls the same way. It was never put in.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The second is that "period = 1/mass" in lattice units <i>is</i> the Compton relation, at every mass, across twenty orders. The ratio comes out at 0.062351 exactly for an electron, a proton, an iron atom and a neodymium atom alike, because <V>m</V><Sub>P</Sub><V>l</V><Sub>P</Sub> = ħ/<V>c</V> — and that number is the gravitational constant in the lattice's own units, which by the bar convention above is <K><Bar>G</Bar></K>, the discrete form of <V>G</V>.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And there is a ceiling: one pulse a tick is the fastest anything can be, so there is a heaviest elementary thing, <K><Bar>G</Bar></K>·<V>m</V><Sub>Planck</Sub> ≈ 1.36 µg. Anything heavier is <i>many</i> emitters, which is what matter is. At the ceiling the beat is one tick, and that tick comes out at 5.391246·10<Sup>−44</Sup> s against a Planck time of 5.391246·10<Sup>−44</Sup> s. Ratio 1.000000000. <b>The lattice's tick is the Planck time</b>, and it is an identity rather than a coincidence — <K><Bar>G</Bar></K> cancels out of it.
+          </Para>
+
+          <Head>what one body does to another</Head>
+
+          <Para>
+            Now put two of them in a world. Body <V>a</V> is spraying <V>m</V><Sub>a</Sub><K>l.<Bar>SHEET</Bar></K> charges a tick over shells that grow as <V>r</V><Sup>2</Sup>; so is body <V>b</V>; and the pull is the rate at which one of each finds the same cell.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>A tick, not a pulse</b> — which is the whole reason the <V>r</V><Sup>2</Sup> is allowed to be a sphere's. Both bodies are emitting continuously, so what meets is two <i>settled</i> fields and not two fronts, and a settled field on this lattice is round to within a few percent past about four cells (measured above). The cube never enters the two-body law. It would, if either side were a single pulse caught in flight — and that case is the open one, not this one.
+          </Para>
+
+          <Eq derive={MEETINGS}>
+            <V>S</V><Sub>ab</Sub> &nbsp;=&nbsp; <K>BITE</K> ·
+            <Paren><Frac over={<K>SHEET</K>} under={<>4<V>π</V></>} /></Paren><Sup>2</Sup>
+            · share · screen · <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> ·
+            met(<V>R</V>)
+          </Eq>
+
+          <Para>
+            The only awkward piece is met(<V>R</V>), which is that rate integrated along the whole line between them rather than evaluated at one point — and it collapses. One inverse square, times a bracket that goes to one.
+          </Para>
+
+          <Eq derive={MET} note="one inverse square, times one bracket that goes to one">
+            met(<V>R</V>) &nbsp;=&nbsp;
+            <Frac over={<>4</>} under={<><V>c R</V><Sup>2</Sup></>} />
+            <Paren>
+              1 &nbsp;+&nbsp; <Frac over={<V>c</V>} under={<V>R</V>} /> ln
+              <Frac over={<><V>R</V> − <V>c</V></>} under={<V>c</V>} />
+            </Paren>
+          </Eq>
+
+          <Para>
+            Which leaves the constants, and this is the part I actually care about. <K>BIAS</K> is one way out of <K><Bar>DEG</Bar></K>. <V>c</V> is a step over a tick. And <V>G</V> is not measured, chosen or fitted — it is written entirely in counts we already have.
+          </Para>
+
+          <Eq derive={FULL}
+            note={<>the bracket is 1.08 at a core of half a lattice step and Mercury's
+              separation — and 1 + 10⁻³⁸ at the grain a real lattice would have</>}>
+            <Frac over={<>d<V>p</V></>} under={<>d<V>t</V></>} /> &nbsp;=&nbsp;
+            <V>G</V> ·
+            <Frac over={<><V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub></>}
+              under={<><V>R</V><Sup>2</Sup></>} />
+            <Paren>
+              1 &nbsp;+&nbsp; <Frac over={<V>c</V>} under={<V>R</V>} /> ln
+              <Frac over={<><V>R</V> − <V>c</V></>} under={<V>c</V>} />
+            </Paren>
+            <Hat>r</Hat>
+            <span style={{ padding: '0 1.4em' }} />
+            <V>G</V> =
+            <Frac over={<><K>SHEET</K><Sup>2</Sup></>}
+              under={<>4<V>π</V><Sup>2</Sup> <V>c</V> <K>DEG</K></>} />
+          </Eq>
+
+          <Para>
+            <b>Newton, times a bracket that goes to one.</b> The whole of the departure from Newton at a distance is that bracket, and its size is the ratio of a source's core to the separation — so it is 1.08 for a source half a lattice step across at Mercury's distance, and 1 + 10<Sup>−38</Sup> at the grain a real lattice would have. There is nothing left in the expression to tune.
+          </Para>
+
+          <BR/>
+
+          And the honest way to check that is to run it rather than to admire it. Same rules, no orbital mechanics anywhere, only bodies letting go of charges and charges meeting.
+
+          <Models models={named('the Sun and Mercury', 'the inner solar system', 'the Earth and the Moon')} />
+
+          <Para>
+            Three panels each: Newton on the left, general relativity in the middle, this model on the right. Everything here runs at a tenth to a third of the speed of light — an orbit worth watching has to be tens of cells across and come round inside a few hundred ticks, and 2π<V>R</V>/<V>T</V> at those numbers is what it is — so the two classical answers are visibly different curves and there is something to land between.
+          </Para>
+
+          <BR/>
+
+          And the same rule with three bodies in it, which is where I stopped expecting anything and got the known closed solutions back anyway.
+
+          <Models models={named(
+            'three bodies: figure eight',
+            'three bodies: Lagrange, equilateral',
+            'three bodies: Euler, collinear',
+          )} />
+
+          <Head>and the same count read a second way</Head>
+
+          <Para>
+            Everything above reads a meeting as a <i>direction</i> — which way the leaning went. But an annihilation is also a statement about <i>how much space a point holds</i>, and nobody had read it that way. That second reading is the metric, and it is the other five sixths of Mercury.
+          </Para>
+
+          <Eq derive={METRIC}
+            note="the same count read as a size rather than a direction — which is a metric, and is the other five sixths">
+            <V>A</V>(<V>s</V>) =
+            <Paren><Frac over={<>1 − <V>s</V></>} under={<>1 + <V>s</V></>} /></Paren><Sup>2</Sup>
+            <span style={{ padding: '0 1.4em' }} />
+            <V>B</V>(<V>s</V>) = (1 + <V>s</V>)<Sup>4</Sup>
+            <span style={{ padding: '0 1.4em' }} />
+            <V>s</V> = <Frac over={<V>u</V>} under={<>2</>} />
+          </Eq>
+
+          <Para>
+            The bit that makes it work is that <b>edges point both ways</b>. A node that has taken <V>n</V> annihilations has <K><Bar>DEG</Bar></K> + <V>n</V> ways out — and those same extra edges point <i>into</i> it, so a charge nearby is (<K><Bar>DEG</Bar></K>+<V>n</V>)/<K><Bar>DEG</Bar></K> times likelier to arrive there. More arrivals, more annihilations, more folding, more arrivals. The increment is proportional to what is already there, which is what makes it compound: d<V>u</V> = d<V>u</V><Sub>0</Sub>(1 + <V>u</V>), which integrates to an exponential with nothing chosen. <V>A</V> = <V>e</V><Sup>−2<V>u</V></Sup>, <V>B</V> = <V>e</V><Sup>+2<V>u</V></Sup>, <V>A</V>·<V>B</V> = 1, so β = γ = 1 both fall out.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <V>B</V> needs one thing the pull did not, though, and it is worth being explicit about. The pull only ever asked what a meeting does to a <i>lean</i>. <V>B</V> asks what it does to the <i>amount</i> of space, and that is three rewrites and nothing else:
+          </Para>
+
+          <Eq derive={SPACE}
+            note="making a charge makes space; a meeting takes it back; a move carries it">
+            neutral &nbsp;→&nbsp; + &nbsp;−
+            <span style={{ padding: '0 1.4em', color: FAINT }}>+1</span>
+            + &nbsp;− &nbsp;→&nbsp; neutral
+            <span style={{ padding: '0 1.4em', color: FAINT }}>−1</span>
+            move
+            <span style={{ padding: '0 0.8em', color: FAINT }}>0</span>
+          </Eq>
+
+          <Eq derive={MADE_FROM}
+            note="a point source settles to a potential — if something carries the surplus away, and that is the whole difficulty">
+            <V>δ</V>(<V>r</V>) = <Frac over={<V>S</V>}
+              under={<>4<V>π D r</V></>} /> = 3<V>u</V>
+            <span style={{ padding: '0 1.6em' }} />
+            ⇒ <V>u</V> = <Frac over={<V>Gm</V>}
+              under={<><V>r c</V><Sup>2</Sup></>} />
+          </Eq>
+
+          <Para>
+            A body emitting <V>m</V><K>l.<Bar>SHEET</Bar></K> charges a tick is a <b>point source of space</b> — at the body, not spread through its field, which matters because a source spread as 1/<V>r</V><Sup>2</Sup> gives a logarithm and a point gives a potential. I should say plainly that this is the shakiest step on the page: the identification ∫<V>δ</V> = 3<V>u</V> is a choice, and the transport constant behind it wants a hopping charge to keep its heading about 85% of the time, which the lattice may simply do and nothing here derives.
+          </Para>
+
+          <Head>Mercury, and light</Head>
+
+          <Para>
+            Mercury is where this gets a number rather than a story. The <i>lean</i> alone — the force law, with the count read as a direction — advances the perihelion by <b>+1.66°</b> an orbit where 6π<V>GM</V>/<V>c</V><Sup>2</Sup><V>a</V>(1−<V>e</V><Sup>2</Sup>) is +9.93°. That is the right sign and <b>exactly a sixth</b> of the size, and it is a sixth to a part in a hundred on Venus, Earth and Mars too, and on a second panel drawn at a different scale.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Read the same annihilations a second time as a <i>size</i> and the same orbit advances <b>+3.41° an orbit</b> — 1.01 of the measured advance — and a ray grazing the Sun bends by the whole 4<V>GM</V>/<V>bc</V><Sup>2</Sup> rather than half of it. Measured through the model's own dynamics rather than off the metric, the five orbits come to <b>6.05, 6.08, 6.07, 6.11 and 6.22 sixths</b>, and the ellipse comes back at −0.00% on every one. Nothing is added to get the other five sixths: <V>A</V> and <V>B</V> carry the same <V>u</V> with the same coefficient, which is the statement that a point's lean and a point's thickness are one event seen twice.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            That is also the sharpest thing here to be wrong about, since it is what fixes γ<Sub>PPN</Sub> = 1 — and Cassini has that to 2·10<Sup>−5</Sup>.
+          </Para>
+
+          <Head>so is that general relativity</Head>
+
+          <Rows of={[
+            [<>where they agree</>,
+              <>β = γ = 1, so every first-post-Newtonian test is identical: the
+                perihelion advance, light's deflection, Shapiro delay, the Cassini
+                bound on γ. <V>A</V> agrees to <V>O</V>(<V>u</V><Sup>3</Sup>).</>],
+            [<>where they differ</>,
+              <><V>B</V> parts company at <V>O</V>(<V>u</V><Sup>2</Sup>), which shows in
+                the perihelion at <V>O</V>(<V>u</V>) — 10<Sup>−6</Sup> arcseconds a
+                century at Mercury, and 0.13% to 0.56% in these panels, which run at
+                exaggerated depth so the effect is visible at all.</>],
+            [<>and where they part outright</>,
+              <><V>e</V><Sup>−2<V>u</V></Sup> never reaches nought, so <b>no
+                horizons</b>; the shadow is <b>4.6% larger</b> at the same mass; and a
+                neutron star shows about two thirds of its mass, which is outside any
+                equation of state and is the one place the model is probably just
+                wrong.</>],
+          ]} />
+
+          <Head>what a black hole is here</Head>
+
+          <Para>
+            √<V>A</V> = 0 would need 1 + <V>u</V> = ∞, so <V>n</V> = ∞ — a node with <i>infinitely many ways out</i> — and each annihilation adds one while a finite mass sends finitely many charges. At what general relativity calls the horizon the node has 6.4 extra ways out per <K><Bar>DEG</Bar></K>: a lot, and not infinity. Light leaves, redshifted by <V>e</V><Sup>2</Sup> = 7.4. <b>Nothing is ever cut off.</b> Things get arbitrarily red and arbitrarily slow and never quite vanish.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What makes something dark, then, is not the metric but <i>screening</i>: a body's charges annihilate against its own field on the way out, so only a skin of thickness <V>λ</V> ever reaches the outside and a body looks lighter than it is. Ordinary matter is transparent — <V>R</V>/<V>λ</V> is 10<Sup>−8</Sup> for the Earth and 3·10<Sup>−5</Sup> for the Sun, so nothing anywhere the model was tested moves. Push it to the lattice's own ceiling of one emitter a cell and <V>R</V>/<V>R</V><Sub>s</Sub> = 0.7219 at <i>every</i> size, flat from 10<Sup>5</Sup> to 10<Sup>30</Sup> cells: <b>the densest thing the lattice permits sits inside its own Schwarzschild radius</b>, and inside its own photon sphere, so it casts a shadow of the full size.
+          </Para>
+
+          <Eq derive={METRIC}
+            note="the area does not shrink to nothing — it has a narrowest point, and inside that it grows again">
+            <Frac over={<>d</>} under={<>d<V>r</V></>} />
+            <Paren><V>r e</V><Sup><V>GM</V>/<V>r</V></Sup></Paren> = 0
+            <span style={{ padding: '0 1.2em', color: FAINT }}>at</span>
+            <V>r</V> = <V>GM</V>/<V>c</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>r</V><Sub>areal</Sub> = <V>e</V>·<V>GM</V>/<V>c</V><Sup>2</Sup> =
+            1.3591 <V>R</V><Sub>s</Sub>
+          </Eq>
+
+          <Para>
+            <b>The area has a throat.</b> Inside it the area grows again without bound, so the geometry is a narrow neck opening into something vast, at a ratio that is the same at every scale. A solar mass two cells across carries a node with 10<Sup>39</Sup> edges — two cells across and enormous at once, and those are one fact rather than two.
+          </Para>
+
+          <Eq derive={METRIC}
+            note="and this is the one number in the whole model that an instrument can settle now">
+            <V>b</V> = 2<V>e</V>·<V>GM</V>/<V>c</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>against</span>
+            3√3·<V>GM</V>/<V>c</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            1.0463
+          </Eq>
+
+          <Shadows />
+
+          <Para>
+            Same mass, same camera, same disc — the only difference between the two panels is <V>A</V> and <V>B</V>. Rays are traced backwards from the eye until they escape or run into the matter, which is the only thing that stops one here, there being no horizon to fall through. The solid ring is general relativity's critical impact parameter and the dashed one is this model's, both drawn on both panels.
+          </Para>
+
+          <Seam />
+
+          <Para>
+            Two panels ask the eye to carry a radius between them, which it is bad at. Cut down the middle instead — relativity left of the seam, the counted metric right of it, everything else identical — and the shadow's edge and the photon ring both <i>step</i> as they cross. A step is something the eye is very good at.
+          </Para>
+
+          <Overlay />
+
+          <Para>
+            And laid on top of each other rather than beside: amber and blue cancel to pale wherever the two agree, so what is left over is the difference. Nothing is exaggerated — it is the same 4.6% at its true size. Traced rather than derived, the two edges come out at 5.196153 and 5.436619 against closed forms of 5.196152 and 5.436564.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>Measure the mass from orbits and the shadow from imaging, and this predicts a constant mismatch between them.</b> It sits inside the Event Horizon Telescope's present ~10% systematic error and outside what it is aiming for, which makes it a near-term test rather than a philosophical one, and the only claim on this page an existing instrument can settle.
+          </Para>
+
+          <Routes />
+
+          <Para>
+            There are two ways to a dark object here — the spatial density above, or a boost on the emission that restores a genuine horizon — and I should say outright that <b>they cannot be told apart</b>. Both share the whole exterior down to the photon sphere, and nothing returns from inside a photon sphere carrying information. The third panel is the ungated boost, drawn not because the model says it but to show what being wrong would look like.
+          </Para>
+
+          <Echoes />
+
+          <Para>
+            The usual fallback is a ringdown: a surface reflects, so the wave trapped under the photon sphere should leak back out as late echoes. This page used to say that separates the two routes. <b>It does not.</b> The delay is the round trip at the coordinate speed of light, and with the surface at 1.96 <i>cells</i> a solar mass carries a factor <V>e</V><Sup>(9·10³⁷)</Sup> in it. The echoes never come back — not late, never. So the model does not predict echoes, and it would be wrong to advertise horizonlessness as though it did.
+          </Para>
+
+          <Head>how far it reaches</Head>
+
+          <Para>
+            Every source is putting charges everywhere, so any place holds a thin fog of everyone else's — and a body's charges annihilate against that fog on the way to wherever they were going. Beyond a mean free path, none of them arrive. So the pull is <i>Yukawa</i>, which nothing in it was designed to be.
+          </Para>
+
+          <Eq derive={REACH}
+            note="the pull is Yukawa, and its range is a fixed fraction of the horizon">
+            <V>S</V>(<V>a</V>,<V>b</V>) ∝
+            <Frac over={<>e<Sup>−<V>R</V>/<V>λ</V></Sup></>}
+              under={<><V>R</V><Sup>2</Sup></>} />
+            <span style={{ padding: '0 1.6em' }} />
+            <Frac over={<V>λ</V>} under={<><V>R</V><Sub>h</Sub></>} /> =
+            √<Paren><Frac over={<>8<V>π G</V></>}
+              under={<>3 <K>BITE</K>·share·<K>SHEET</K></>} /></Paren> = 0.361
+          </Eq>
+
+          <Para>
+            I liked this one a great deal and then had to take most of it back, so it is worth walking through. Getting the density to cancel — "gravity reaches a third of the way to the horizon in <i>any</i> universe this model describes" — used <V>ρ</V> = 3<V>H</V><Sup>2</Sup>/8π<V>G</V>. <b>That is Friedmann, and this model has no Friedmann equation.</b> What survives is <V>λ</V>/<V>R</V><Sub>h</Sub> = 0.361/√<V>Ω</V>, and the model has no dark matter and no dark energy, so the density doing the screening is the <i>baryon</i> one — <V>Ω</V> = 0.049, hence 1.63, hence gravity reaching half again past the horizon. The prediction does not become wrong. It becomes unfalsifiable, which here is the worse of the two.
+          </Para>
+
+          <Head>and then the cosmology, which I did not want</Head>
+
+          <Para>
+            The rules fix a cosmology whether or not one was wanted, because matter makes space and meetings unmake it and the net is what escapes. Asked for the <i>observed</i> <V>H</V>, the version where space is made throughout the bulk fails seven separate ways, and the fatal one is that the pairs which make the space <i>are</i> the fog that stops the gravity. One <V>Φ</V>, two jobs, opposite values, thirty-five orders apart.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The way out is to notice that "space is made in the bulk" was an assumption nobody argued for. Put the creation only where there is <i>no space yet</i>: a cell on the <b>frontier</b> has nothing on one side, so a charge emitted outward meets nothing ever and never gives its point back, and that point is new space. A charge emitted inward meets the bulk and annihilates. The interior makes none at all — which dissolves five of the seven at once, since all five were consequences of a bulk vacuum.
+          </Para>
+
+          <Eq derive={REACH}
+            note="one emission a cell a tick is the ceiling — so it is also the rate">
+            <Frac over={<>d<V>R</V></>} under={<>d<V>t</V></>} /> = 1
+            <span style={{ padding: '0 0.6em', color: FAINT }}>cell/tick</span> = <V>c</V>
+            <span style={{ padding: '0 1.4em', color: FAINT }}>⇒</span>
+            <V>R</V> = <V>ct</V>
+          </Eq>
+
+          <Para>
+            And then a Hubble law by pure kinematics: matter that left the origin at <V>t</V> = 0 and free-streams sits at <V>x</V> = <V>vt</V>, so any two of them separate at <V>r</V>/<V>t</V> and <b>every</b> observer inside sees <V>v</V> = <V>Hr</V> with <V>H</V> = 1/<V>t</V>. No metric expansion, no stretched wavelengths, no tired light — the redshift is ordinary Doppler. And the age is then <i>forced</i>, not fitted: <V>t</V> = 1/<V>H</V><Sub>0</Sub> exactly, which is 14.51 Gyr at <V>H</V><Sub>0</Sub> = 67.4 and 13.39 at 73.0, against a measured 13.80 ± 0.02. <b>The Hubble tension brackets it.</b> A model with no freedom to miss does not miss.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            In its own units the universe is 8.49·10<Sup>60</Sup> ticks old and 8.49·10<Sup>60</Sup> cells in radius — the same number, which is what <V>R</V> = <V>ct</V> means and is worth seeing written down.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>And then it fails the supernovae, which is the honest end of this section.</b> A coasting universe is <V>q</V><Sub>0</Sub> = 0 exactly, with no <V>Ω</V>, no <V>Λ</V> and no freedom anywhere; the measured value is −0.55 ± 0.05. The defence — that a supernova's absolute magnitude is a nuisance parameter, so a constant offset is free and only the <i>shape</i> counts — is a real one, so marginalise the offset away and look at what is left. The residual runs +0.072 mag at <V>z</V> = 0.02, through zero near 0.18, to −0.130 at <V>z</V> = 1: <b>0.061 mag rms and monotonic</b>, where Pantheon+ bins carry 0.02–0.03. And the shape of that residual — nearby too bright, distant too faint — is precisely the one the 1998 measurements found and named acceleration. The same construction, asked a second question, gets it wrong by the width of the discovery that started modern cosmology.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            There is worse, and it is structural rather than numerical. A charge arriving at an occupied cell has exactly two outcomes and no third — annihilate, or reverse — and both are extinction. A step is one cell and a heading is one of <K><Bar>DEG</Bar></K>, so there is no soft forward channel anywhere in the rules: <b>the lattice can dim light and it cannot redden it</b>, and by the same missing channel it cannot move energy between frequencies either. FIRAS has the microwave background as a blackbody to a part in 10<Sup>5</Sup>, and this model has no mechanism that would produce one <i>at any temperature</i>. No thermal history, no light elements, no acoustic peaks. That is not a small number coming out wrong; it is an absence.
+          </Para>
+
+          <Head>and whether any of that is dark matter</Head>
+
+          <Para>
+            Now the part I spent longest on and got wrong most often. Below is the Milky Way put through the model's own force law, summed directly over its baryons ring by ring and angle by angle — no shell theorem, no enclosed-mass shortcut, so nothing about what the outside does is assumed.
+          </Para>
+
+          <Rotation />
+
+          <Para>
+            It peaks at 193 km/s and falls to 104 by 30 kpc, against a curve Gaia measures at 229 at the Sun and 200 at 25. That is a shortfall in the pull of 52% at the Sun and 242% at 30 kpc. And <b>it is not this model's shortfall in particular</b>, which is the honest way to put it.
+          </Para>
+
+          <Apart />
+
+          <Para>
+            Two lines at 10<Sup>−7</Sup>, one at 10<Sup>−10</Sup>, and the discrepancy at 10<Sup>0</Sup>. <b>The entire difference between Newton, Einstein and this model is six orders below the thing all three of them miss.</b> Whatever dark matter is, no correction of that size was ever going to reach it — so read this panel as closing off the obvious direction, not as closing the question.
+          </Para>
+
+          <Split />
+
+          <Para>
+            One tempting escape closes here too. The exterior mass does <i>not</i> cancel — a disc is not a sphere — but it pulls <b>outward</b>, because the near arc of an exterior ring is closer than the far arc and wins the inverse square. It takes 27% off the pull at 2 kpc. So the missing gravity cannot come from the outside failing to cancel: the outside is already counted, already fails to cancel, and already subtracts.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            After that I stopped testing mechanisms one at a time, because they kept dying on the same number. Enumerate instead every dimensionless quantity the model can build at 20 kpc — <V>GM</V>/<V>rc</V><Sup>2</Sup> = 1.70·10<Sup>−7</Sup>, <V>v</V><Sup>2</Sup>/<V>c</V><Sup>2</Sup> = 5.39·10<Sup>−7</Sup>, <V>r</V>/<V>λ</V><Sub>reach</Sub> = 1.25·10<Sup>−5</Sup>, <V>r</V>/<V>ct</V><Sub>0</Sub> = 4.73·10<Sup>−6</Sup>, the lattice spacing at 10<Sup>−56</Sup> — and closing a gap of +195% needs an <V>O</V>(1) number. <b>Exactly one of the eight is anywhere near unity</b>, and it is <V>g·t</V><Sub>0</Sub>/<V>c</V> = 3.86·10<Sup>−2</Sup>. Which closes the whole family at once rather than one idea at a time, and is worth more than any of the individual tests.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And there is a theorem underneath, which I would rather have found earlier. Action and reaction gives <V>m</V><Sub>a</Sub><V>h</V>(<V>m</V><Sub>b</Sub>) = <V>m</V><Sub>b</Sub><V>h</V>(<V>m</V><Sub>a</Sub>); equivalence gives <V>F</V> = <V>m</V><Sub>a</Sub>·<V>h</V>(<V>m</V><Sub>b</Sub>); together they force <V>F</V> ∝ <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> exactly, with no freedom at all. So <b>no two-body force law can give √<V>M</V></b>, which is what a Tully–Fisher slope of 3.85 ± 0.09 demands — not a modified one, not a screened one, not one with a different geometry. Every mechanism I built put the nonlinearity in the <i>source</i>, and each found a different way of being told it could not.
+          </Para>
+
+          <Head>what does work — the carriers slow where they are thin</Head>
+
+          <Para>
+            It has to go in the <i>transport</i>, then: in how the carriers travel rather than in how hard anything pulls. And <K>inStep</K> already says when a carrier gets to travel cheaply — emitters within a common phase pay the update once between them — so a dense field is a fast one and a thin field is a slow one. No new rule.
+          </Para>
+
+          <Eq note="the drift, and flux conservation with it">
+            <V>v</V> = <V>c</V>·min(1, <V>n</V>/<V>n</V><Sub>c</Sub>)
+            <span style={{ padding: '0 1.6em', color: FAINT }}>,</span>
+            <V>Φ</V> = 4π<V>r</V><Sup>2</Sup>·<V>n</V>·<V>v</V> = constant
+          </Eq>
+
+          <Para>
+            Dense, and <V>v</V> = <V>c</V>, so <V>n</V> ∝ 1/<V>r</V><Sup>2</Sup>: Newton. Thin, and <V>v</V> ∝ <V>n</V>, so flux conservation goes <i>quadratic</i> and <V>n</V> ∝ √<V>Φ</V>/<V>r</V> — which is <b>both halves at once</b>, the 1/<V>r</V> law and, since <V>Φ</V> ∝ <V>M</V>, an effective source going as √<V>M</V>. Measured by integrating the transport: slope −2.0000 inside, −1.0000 outside, and the outer density against √<V>Φ</V> comes to 10.0000 for a hundredfold mass. That is the nonlinearity the theorem demanded, living where the theorem allows it.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The turnover between the two is not borrowed either, which is the part every earlier version of this section quietly assumed. <K>through</K> says a point already carrying a charge is <i>busy</i> — an arriving charge annihilates or reverses, and either way that point does not split this tick — so splitting is suppressed exactly where the carrier density is high, which by <V>g</V> ∝ <V>n</V> is where the field is strong.
+          </Para>
+
+          <Eq note="occupancy θ = g/a₀, free fraction 1/(1+θ), and it closes">
+            <V>g</V> = <V>g</V><Sub>N</Sub>·(1 + <V>a</V><Sub>0</Sub>/<V>g</V>)
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>g</V> = <Frac over={<><V>g</V><Sub>N</Sub></>} under={<>2</>} /> + √(
+            <Frac over={<><V>g</V><Sub>N</Sub><Sup>2</Sup></>} under={<>4</>} /> +{' '}
+            <V>g</V><Sub>N</Sub><V>a</V><Sub>0</Sub>)
+          </Eq>
 
           <Para>
-            Three panels each: Newton on the left, general relativity in the middle, this model on the right. Everything here runs at a tenth to a third of the speed of light — an orbit worth watching has to be tens of cells across and come round inside a few hundred ticks, and 2π<V>R</V>/<V>T</V> at those numbers is what it is — so the two classical answers are visibly different curves and there is something to land between.
+            <b>That is MOND's "simple" interpolation function, and here it is derived rather than chosen.</b> Over six decades <V>g</V>/<V>g</V><Sub>N</Sub> runs 32.1, 10.5, 3.70, 1.62, 1.09, 1.010, 1.0010 against a deep limit √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>) of 31.6, 10.0, 3.16 — agreeing where it should and parting where it should. Every MOND paper picks that function by hand out of a family; this one picks itself out of the counting statistics of the mechanism.
           </Para>
 
-          <BR/>
-
-          And the same rule with three bodies in it, which is where I stopped expecting anything and got the known closed solutions back anyway.
-
-          <Models models={named(
-            'three bodies: figure eight',
-            'three bodies: Lagrange, equilateral',
-            'three bodies: Euler, collinear',
-          )} />
-
-          <Head>and the same count read a second way</Head>
+          <Head>and the scale is not fitted either</Head>
 
           <Para>
-            Everything above reads a meeting as a <i>direction</i> — which way the leaning went. But an annihilation is also a statement about <i>how much space a point holds</i>, and nobody had read it that way. That second reading is the metric, and it is the other five sixths of Mercury.
+            What sets the threshold is the thing the model is <i>about</i>: space being made. Making space has a rate, that rate is <V>H</V>, an acceleration built from it is <V>cH</V>, and the frontier already forces <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> exactly — so <V>cH</V><Sub>0</Sub> is a count of ticks and not a constant anybody chose. The 2π is <K>inStep</K>'s own.
           </Para>
 
-          <Eq derive={METRIC}
-            note="the same count read as a size rather than a direction — which is a metric, and is the other five sixths">
-            <V>A</V>(<V>s</V>) =
-            <Paren><Frac over={<>1 − <V>s</V></>} under={<>1 + <V>s</V></>} /></Paren><Sup>2</Sup>
-            <span style={{ padding: '0 1.4em' }} />
-            <V>B</V>(<V>s</V>) = (1 + <V>s</V>)<Sup>4</Sup>
-            <span style={{ padding: '0 1.4em' }} />
-            <V>s</V> = <Frac over={<V>u</V>} under={<>2</>} />
+          <Eq note="the acceleration scale, with nothing fitted in it">
+            <V>a</V><Sub>0</Sub> = <Frac over={<><V>c</V> <V>H</V><Sub>0</Sub></>} under={<>2π</>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            1.096·10<Sup>−10</Sup> m/s²
+            <span style={{ padding: '0 1.2em', color: FAINT }}>vs</span>
+            1.200·10<Sup>−10</Sup> measured
           </Eq>
 
           <Para>
-            The bit that makes it work is that <b>edges point both ways</b>. A node that has taken <V>n</V> annihilations has <K><Bar>DEG</Bar></K> + <V>n</V> ways out — and those same extra edges point <i>into</i> it, so a charge nearby is (<K><Bar>DEG</Bar></K>+<V>n</V>)/<K><Bar>DEG</Bar></K> times likelier to arrive there. More arrivals, more annihilations, more folding, more arrivals. The increment is proportional to what is already there, which is what makes it compound: d<V>u</V> = d<V>u</V><Sub>0</Sub>(1 + <V>u</V>), which integrates to an exponential with nothing chosen. <V>A</V> = <V>e</V><Sup>−2<V>u</V></Sup>, <V>B</V> = <V>e</V><Sup>+2<V>u</V></Sup>, <V>A</V>·<V>B</V> = 1, so β = γ = 1 both fall out.
+            <b>Nine percent, with nothing fitted anywhere.</b> And it explains a coincidence that is an embarrassment everywhere else — why should a galaxy know the age of the universe? Here it is not being told the age; it is being told the rate at which space is made, which is the same number because the frontier makes it so. <b>The cosmology and the rotation curves become one fact.</b>
           </Para>
 
           <BR/>
 
           <Para>
-            <V>B</V> needs one thing the pull did not, though, and it is worth being explicit about. The pull only ever asked what a meeting does to a <i>lean</i>. <V>B</V> asks what it does to the <i>amount</i> of space, and that is three rewrites and nothing else:
+            Run on the Milky Way with that predicted <V>a</V><Sub>0</Sub> and nothing fitted at all, the ratio to Gaia goes 0.977 · 0.997 · 0.999 · 0.995 · 0.987 · 0.987 · 1.002 · 1.028 from 6 to 30 kpc — <b>1.1% rms</b>, with a Tully–Fisher slope of 3.42 against a measured 3.85 ± 0.09. Newton alone runs 0.83 down to 0.54 over the same range. Which is worth <i>looking</i> at rather than reading, because a rotation curve is a graph and a graph hides what it means:
           </Para>
 
-          <Eq derive={SPACE}
-            note="making a charge makes space; a meeting takes it back; a move carries it">
-            neutral &nbsp;→&nbsp; + &nbsp;−
-            <span style={{ padding: '0 1.4em', color: FAINT }}>+1</span>
-            + &nbsp;− &nbsp;→&nbsp; neutral
-            <span style={{ padding: '0 1.4em', color: FAINT }}>−1</span>
-            move
-            <span style={{ padding: '0 0.8em', color: FAINT }}>0</span>
-          </Eq>
-
-          <Eq derive={MADE_FROM}
-            note="a point source settles to a potential — if something carries the surplus away, and that is the whole difficulty">
-            <V>δ</V>(<V>r</V>) = <Frac over={<V>S</V>}
-              under={<>4<V>π D r</V></>} /> = 3<V>u</V>
-            <span style={{ padding: '0 1.6em' }} />
-            ⇒ <V>u</V> = <Frac over={<V>Gm</V>}
-              under={<><V>r c</V><Sup>2</Sup></>} />
-          </Eq>
+          <Discs />
 
           <Para>
-            A body emitting <V>m</V><K>l.<Bar>SHEET</Bar></K> charges a tick is a <b>point source of space</b> — at the body, not spread through its field, which matters because a source spread as 1/<V>r</V><Sup>2</Sup> gives a logarithm and a point gives a potential. I should say plainly that this is the shakiest step on the page: the identification ∫<V>δ</V> = 3<V>u</V> is a choice, and the transport constant behind it wants a hopping charge to keep its heading about 85% of the time, which the lattice may simply do and nothing here derives.
+            Four spokes of stars laid down along one radius and left to shear, under each law, with the measured curve dashed and repeated in every panel. General relativity falls visibly behind it within one turn of the Sun.
           </Para>
 
-          <Head>Mercury, and light</Head>
+          <Head>the sharpest test, and it nearly failed</Head>
 
           <Para>
-            Mercury is where this gets a number rather than a story. The <i>lean</i> alone — the force law, with the count read as a direction — advances the perihelion by <b>+1.66°</b> an orbit where 6π<V>GM</V>/<V>c</V><Sup>2</Sup><V>a</V>(1−<V>e</V><Sup>2</Sup>) is +9.93°. That is the right sign and <b>exactly a sixth</b> of the size, and it is a sixth to a part in a hundred on Venus, Earth and Mars too, and on a second panel drawn at a different scale.
+            A first reading made <V>a</V><Sub>0</Sub> a <i>clock reading</i> — <V>c</V>/2π<V>t</V>, so three times larger at <V>z</V> = 2 — which is a dated, falsifiable prediction MOND cannot make. Genzel and co. measure five massive discs at <V>z</V> = 0.85–2.24 with <i>declining</i> outer curves and <V>f</V><Sub>DM</Sub>(&lt;<V>R</V><Sub>e</Sub>) &lt; 0.2, which is a boost under about 1.118. That reading predicts 1.18, 1.17, 1.16, 1.24 — four of five over the line — and refuses it.
           </Para>
 
-          <BR/>
+          <HighZDiscs />
 
           <Para>
-            Read the same annihilations a second time as a <i>size</i> and the same orbit advances <b>+3.41° an orbit</b> — 1.01 of the measured advance — and a ray grazing the Sun bends by the whole 4<V>GM</V>/<V>bc</V><Sup>2</Sup> rather than half of it. Measured through the model's own dynamics rather than off the metric, the five orbits come to <b>6.05, 6.08, 6.07, 6.11 and 6.22 sixths</b>, and the ellipse comes back at −0.00% on every one. Nothing is added to get the other five sixths: <V>A</V> and <V>B</V> carry the same <V>u</V> with the same coefficient, which is the statement that a point's lean and a point's thickness are one event seen twice.
+            The blocking above rescues it, and at a price. <V>a</V><Sub>0</Sub> is a function of the field at the point and nothing else, so it is <i>local</i> rather than cosmological and does not move with redshift — there is nothing in it that could. That removes the refutation. <b>It does not make the discs agree</b>, and an earlier version of this section said it did, on a calculation that was wrong.
           </Para>
 
-          <BR/>
+          <HighRedshift />
+
+          <HighZCurves />
 
           <Para>
-            That is also the sharpest thing here to be wrong about, since it is what fixes γ<Sub>PPN</Sub> = 1 — and Cassini has that to 2·10<Sup>−5</Sup>.
+            Drawn as curves rather than as a boost factor, the disagreement is immediate: <b>four of five overshoot</b>. The earlier pass took <V>g</V><Sub>N</Sub> = <V>GM</V>/<V>R</V><Sub>e</Sub><Sup>2</Sup>, a <i>point mass</i>, and these are discs — at one effective radius a disc has enclosed about half its mass, so its real <V>g</V><Sub>N</Sub> is roughly half that, which sits deeper in the boosted regime and gives a <i>larger</i> boost. The shortcut was generous in exactly the direction that made the model pass. Done properly: 1.174, 1.131, 1.122, 1.158 and 1.033 against a ceiling of 1.118.
           </Para>
 
-          <Head>so is that general relativity</Head>
+          <BR/>
 
-          <Rows of={[
-            [<>where they agree</>,
-              <>β = γ = 1, so every first-post-Newtonian test is identical: the
-                perihelion advance, light's deflection, Shapiro delay, the Cassini
-                bound on γ. <V>A</V> agrees to <V>O</V>(<V>u</V><Sup>3</Sup>).</>],
-            [<>where they differ</>,
-              <><V>B</V> parts company at <V>O</V>(<V>u</V><Sup>2</Sup>), which shows in
-                the perihelion at <V>O</V>(<V>u</V>) — 10<Sup>−6</Sup> arcseconds a
-                century at Mercury, and 0.13% to 0.56% in these panels, which run at
-                exaggerated depth so the effect is visible at all.</>],
-            [<>and where they part outright</>,
-              <><V>e</V><Sup>−2<V>u</V></Sup> never reaches nought, so <b>no
-                horizons</b>; the shadow is <b>4.6% larger</b> at the same mass; and a
-                neutron star shows about two thirds of its mass, which is outside any
-                equation of state and is the one place the model is probably just
-                wrong.</>],
-          ]} />
+          <Para>
+            But "overshoots four of five" is an adjective and not a measurement. <V>f</V><Sub>DM</Sub> &lt; 0.2 is an <i>upper limit</i>, so the true boost lies somewhere in 1.000…1.118 — Newton sits at the bottom of that band by construction and the model just above the top of it, and which is closer depends where in the band the truth is. At <V>f</V><Sub>DM</Sub> = 0 Newton is exact and the model is 13.3% high; at 0.10 it is 5.1% low against 8.1% high; at 0.20 it is <b>10.6% low against 4.4% high</b> and the model wins. Meanwhile on the Milky Way the model is <b>1.1% rms against Newton's 32.5%</b>, worst case 2.6% against 43.1%. So the high-<V>z</V> discs are a real tension and not a refutation — and the thing that had to go for the model to survive them is the dated prediction, which should be read as the model becoming <i>harder</i> to test.
+          </Para>
 
-          <Head>what a black hole is here</Head>
+          <Head>the prediction the lattice hands back</Head>
 
           <Para>
-            √<V>A</V> = 0 would need 1 + <V>u</V> = ∞, so <V>n</V> = ∞ — a node with <i>infinitely many ways out</i> — and each annihilation adds one while a finite mass sends finitely many charges. At what general relativity calls the horizon the node has 6.4 extra ways out per <K><Bar>DEG</Bar></K>: a lot, and not infinity. Light leaves, redshifted by <V>e</V><Sup>2</Sup> = 7.4. <b>Nothing is ever cut off.</b> Things get arbitrarily red and arbitrarily slow and never quite vanish.
+            One thing does come back, and it is sharper than what was lost. The pair is emitted with the field direction <i>removed</i>, so the space made around a mass is not a sphere — and the obvious worry is that an anisotropy varying with radius would change the <i>shape</i> of the curve and not just its scale.
           </Para>
 
           <BR/>
 
           <Para>
-            What makes something dark, then, is not the metric but <i>screening</i>: a body's charges annihilate against its own field on the way out, so only a skin of thickness <V>λ</V> ever reaches the outside and a body looks lighter than it is. Ordinary matter is transparent — <V>R</V>/<V>λ</V> is 10<Sup>−8</Sup> for the Earth and 3·10<Sup>−5</Sup> for the Sun, so nothing anywhere the model was tested moves. Push it to the lattice's own ceiling of one emitter a cell and <V>R</V>/<V>R</V><Sub>s</Sub> = 0.7219 at <i>every</i> size, flat from 10<Sup>5</Sup> to 10<Sup>30</Sup> cells: <b>the densest thing the lattice permits sits inside its own Schwarzschild radius</b>, and inside its own photon sphere, so it casts a shadow of the full size.
+            It does not, and the lattice is why. The 26 exits from a cell have only <b>three distinct direction cosines</b> — 1 for the six faces, 1/√2 for the twelve edges, 1/√3 for the eight corners — so the projection is a <i>step</i> function with four values: 0.4721, 0.4510, 0.4022, 0.3610. A galaxy spans <V>g</V>/<V>a</V><Sub>0</Sub> from 0.34 at 30 kpc to 4.84 at 2 kpc and never crosses a step. The expansion around it is genuinely not a sphere, but it is one of <i>four discrete shapes</i>, and a galaxy sits in one of them throughout.
           </Para>
 
-          <Eq derive={METRIC}
-            note="the area does not shrink to nothing — it has a narrowest point, and inside that it grows again">
-            <Frac over={<>d</>} under={<>d<V>r</V></>} />
-            <Paren><V>r e</V><Sup><V>GM</V>/<V>r</V></Sup></Paren> = 0
-            <span style={{ padding: '0 1.2em', color: FAINT }}>at</span>
-            <V>r</V> = <V>GM</V>/<V>c</V><Sup>2</Sup>
-            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
-            <V>r</V><Sub>areal</Sub> = <V>e</V>·<V>GM</V>/<V>c</V><Sup>2</Sup> =
-            1.3591 <V>R</V><Sub>s</Sub>
-          </Eq>
+          <BR/>
 
           <Para>
-            <b>The area has a throat.</b> Inside it the area grows again without bound, so the geometry is a narrow neck opening into something vast, at a ratio that is the same at every scale. A solar mass two cells across carries a node with 10<Sup>39</Sup> edges — two cells across and enormous at once, and those are one fact rather than two.
+            <b>But a galaxy is not the whole of anything.</b> Far enough out the occupancy does cross a step, and when it does <V>a</V><Sub>0</Sub> jumps by a fixed ratio — which is a <b>discontinuity in a rotation curve, at a radius the model computes</b>. For the Milky Way that is <b>33 and 52 kpc</b>, where the Sagittarius stream lives and where the satellite population is measured; for a big spiral 58 and 90; for a dwarf <b>6 and 9 kpc</b>, inside the stellar body where a curve is easiest to measure. The size is small and the shape is the point: <V>v</V> ∝ <V>a</V><Sub>0</Sub><Sup>¼</Sup>, so the plateau ratios give jumps of 1.1%, 2.8% and 2.7% — two to six km/s on a 200 km/s curve, <i>sharp</i>, at a radius fixed by the baryons alone with nothing to tune. MOND has no reason for a curve to be anything but smooth, and a halo is smooth by construction.
           </Para>
 
-          <Eq derive={METRIC}
-            note="and this is the one number in the whole model that an instrument can settle now">
-            <V>b</V> = 2<V>e</V>·<V>GM</V>/<V>c</V><Sup>2</Sup>
-            <span style={{ padding: '0 1.2em', color: FAINT }}>against</span>
-            3√3·<V>GM</V>/<V>c</V><Sup>2</Sup>
-            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
-            1.0463
-          </Eq>
-
-          <Shadows />
+          <Head>and whether it is dark matter at all</Head>
 
           <Para>
-            Same mass, same camera, same disc — the only difference between the two panels is <V>A</V> and <V>B</V>. Rays are traced backwards from the eye until they escape or run into the matter, which is the only thing that stops one here, there being no horizon to fall through. The solid ring is general relativity's critical impact parameter and the dashed one is this model's, both drawn on both panels.
+            No, and this is the test that decides it. Clusters need 6.0× their baryons — Coma 6.0, A1689 6.8, A2029 5.3, Perseus 5.9, Virgo 6.0 — and the model supplies 3.32, 3.59, 3.52, 3.75, 5.54, a mean of 3.94 against a mean of 6.0. <b>Short by 1.53×</b>, systematically rather than scattered.
           </Para>
 
-          <Seam />
+          <BR/>
 
           <Para>
-            Two panels ask the eye to carry a radius between them, which it is bad at. Cut down the middle instead — relativity left of the seam, the counted metric right of it, everything else identical — and the shadow's edge and the photon ring both <i>step</i> as they cross. A step is something the eye is very good at.
+            And the reason is structural rather than a matter of tuning. In the boosted regime the mass ratio is √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>), so a factor of six needs <V>g</V><Sub>N</Sub>/<V>a</V><Sub>0</Sub> = 1/36, and clusters sit at 0.04 to 0.13 — near the turnover rather than deep in it, where the ceiling is about 3×. <b>The square root is a hard ceiling and clusters are above it</b>, so no interpolation function and no value of <V>a</V><Sub>0</Sub> reaches them. Worse, the demands point opposite ways: clusters want <V>a</V><Sub>0</Sub> up to 4× larger and the compact high-<V>z</V> discs want it 0.6× smaller.
           </Para>
 
-          <Overlay />
+          <BR/>
 
           <Para>
-            And laid on top of each other rather than beside: amber and blue cancel to pale wherever the two agree, so what is left over is the difference. Nothing is exaggerated — it is the same 4.6% at its true size. Traced rather than derived, the two edges come out at 5.196153 and 5.436619 against closed forms of 5.196152 and 5.436564.
+            <b>So this is not a dark-matter theory. It is a mechanism for the rotation-curve regime.</b> In the deep limit it <i>is</i> MOND — that is what deriving the interpolation rather than choosing it means — so it inherits MOND's cluster problem exactly, for the same reason and by the same factor. What it adds is that <V>a</V><Sub>0</Sub> is computed rather than fitted, the interpolation is derived rather than chosen, and there is a step nobody else predicts. What it does not add is any reach beyond galaxies: no microwave background at all, a failed supernova diagram, no source for the light elements, and clusters short by half. <b>Four of the five things dark matter was invented for are untouched or failed</b>, and a galaxy fitted to 1.1% by a computed constant is one regime out of five.
           </Para>
 
-          <BR/>
+          <Head>the ledger</Head>
 
           <Para>
-            <b>Measure the mass from orbits and the shadow from imaging, and this predicts a constant mismatch between them.</b> It sits inside the Event Horizon Telescope's present ~10% systematic error and outside what it is aiming for, which makes it a near-term test rather than a philosophical one, and the only claim on this page an existing instrument can settle.
+            Which leaves the thing I most want kept honest — what went in, what came out, and what is still owed.
           </Para>
 
-          <Routes />
+          <Rows of={[
+            [<>what is put in</>,
+              <>Six countable facts and nothing else. <K>DEG</K> = 3<Sup>3</Sup> − 1 = 26,
+                ways out of a point. <K>SHEET</K> = 3<Sup>2</Sup> − 1 = 8, charges in one
+                pulse. <K>BITE</K> = 1, points an annihilation removes, so that making and
+                unmaking a ± pair are exact inverses. <K>LIGHT</K> = 1, points per tick.{' '}
+                <K>HALF</K> = ½, a shell being never smaller than the cell its source sits
+                in. And <V>m</V>, which is how <i>often</i> a thing emits rather than a
+                property it has.</>],
+            [<>what comes out</>,
+              <>The inverse square, as a fixed count over a growing shell. The equivalence
+                principle. <V>G</V>, every symbol of it a count. Special relativity's own
+                1/<V>γ</V><Sup>3</Sup> and 1/<V>γ</V>. The metric, <V>A</V> and <V>B</V>{' '}
+                from one compounding count, with β = γ = 1. The geodesic equation, matching
+                Euler–Lagrange to 10<Sup>−7</Sup>. Mercury's advance and light's deflection
+                in full. <V>E</V> = ħω from what mass is, and λ = <V>h</V>/<V>p</V> from not
+                knowing where it is. A screening term Newton has no name for. And the tick,
+                which is the Planck time by identity.</>],
+            [<>what is owed</>,
+              <>One link, and it is arithmetic rather than astronomy: that a carrier's
+                update cost goes as its accumulated phase. <K>through</K> gives the
+                blocking, <K>inStep</K> gives the budget, and nothing here derives the join.
+                Then the ambient sea, which is 2.65× the crossover density even after{' '}
+                <K>reach</K> cuts it off, so the MOND regime switches on only <i>barely</i>{' '}
+                where every fit above assumed it switches on cleanly. And the two
+                derivations of <V>a</V><Sub>0</Sub>, which differ by exactly{' '}
+                <K>DEG</K>/2<K>SHEET</K> = 13/8 — so one of them miscounts, and finding
+                which turns a 9% agreement into a derivation or kills it outright.</>],
+            [<>and four things to shoot at</>,
+              <>The <b>shadow</b>, 4.6% larger than general relativity's at the same mass,
+                parameter-free and inside the reach of an instrument that exists. The{' '}
+                <b>age</b>, forced to 1/<V>H</V><Sub>0</Sub> with no freedom to miss, which
+                the Hubble tension brackets. <b><V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π</b>,
+                computed rather than fitted. And <b>the step</b> — a discontinuity in a
+                rotation curve at 6 and 9 kpc in a dwarf, which nothing else in physics
+                predicts.</>],
+            [<>and one that is probably just wrong</>,
+              <>A neutron star shows about two thirds of its mass, which is outside any
+                equation of state, and pulsar timing measures those directly.</>],
+          ]} />
 
           <Para>
-            There are two ways to a dark object here — the spatial density above, or a boost on the emission that restores a genuine horizon — and I should say outright that <b>they cannot be told apart</b>. Both share the whole exterior down to the photon sphere, and nothing returns from inside a photon sphere carrying information. The third panel is the ungated boost, drawn not because the model says it but to show what being wrong would look like.
+            The rest of the arrangements the model has been run on are below — every one of them the same rules, differing only in what was put in the world and how it was watched.
           </Para>
 
-          <Echoes />
+          <Models models={MODELS} />
+        </Section>
+        <Section head="TODO2">
+
+          <Head>the same emission, with the signs kept</Head>
 
           <Para>
-            The usual fallback is a ringdown: a surface reflects, so the wave trapped under the photon sphere should leak back out as late echoes. This page used to say that separates the two routes. <b>It does not.</b> The delay is the round trip at the coordinate speed of light, and with the surface at 1.96 <i>cells</i> a solar mass carries a factor <V>e</V><Sup>(9·10³⁷)</Sup> in it. The echoes never come back — not late, never. So the model does not predict echoes, and it would be wrong to advertise horizonlessness as though it did.
+            Everything in the gravity arc counts <i>one</i> thing about an emitter: how often it lets go. That is mass. But a source has a second property that has nothing to do with the first — <b>which way round it is when it does</b> — and the gravitational half never once looked at it. Keep the signs instead of throwing them away and the very same emission answers a different question.
           </Para>
 
-          <Head>how far it reaches</Head>
+          <BR/>
 
           <Para>
-            Every source is putting charges everywhere, so any place holds a thin fog of everyone else's — and a body's charges annihilate against that fog on the way to wherever they were going. Beyond a mean free path, none of them arrive. So the pull is <i>Yukawa</i>, which nothing in it was designed to be.
+            I want to say what that question is before going any further, because it is narrower than the section title suggests. There is no account of <i>matter</i> in this model, so nothing here says what an electron or a positron would be, and the electric half — charge, how matter interacts with it — is not attempted. What the signs give is a <b>bias</b>, and a bias is magnetism.
           </Para>
 
-          <Eq derive={REACH}
-            note="the pull is Yukawa, and its range is a fixed fraction of the horizon">
-            <V>S</V>(<V>a</V>,<V>b</V>) ∝
-            <Frac over={<>e<Sup>−<V>R</V>/<V>λ</V></Sup></>}
-              under={<><V>R</V><Sup>2</Sup></>} />
-            <span style={{ padding: '0 1.6em' }} />
-            <Frac over={<V>λ</V>} under={<><V>R</V><Sub>h</Sub></>} /> =
-            √<Paren><Frac over={<>8<V>π G</V></>}
-              under={<>3 <K>BITE</K>·share·<K>SHEET</K></>} /></Paren> = 0.361
+          <Eq note="one emission, two moments of it — the count is mass, the signed first moment is a bias">
+            <V>m</V> = ⟨1⟩<span style={{ padding: '0 1.6em' }} />
+            <V>q</V> = ⟨<V>s</V>⟩<span style={{ padding: '0 1.6em' }} />
+            <V>µ</V> = ⟨<V>s</V> <V>d̂</V>⟩
           </Eq>
 
           <Para>
-            I liked this one a great deal and then had to take most of it back, so it is worth walking through. Getting the density to cancel — "gravity reaches a third of the way to the horizon in <i>any</i> universe this model describes" — used <V>ρ</V> = 3<V>H</V><Sup>2</Sup>/8π<V>G</V>. <b>That is Friedmann, and this model has no Friedmann equation.</b> What survives is <V>λ</V>/<V>R</V><Sub>h</Sub> = 0.361/√<V>Ω</V>, and the model has no dark matter and no dark energy, so the density doing the screening is the <i>baryon</i> one — <V>Ω</V> = 0.049, hence 1.63, hence gravity reaching half again past the horizon. The prediction does not become wrong. It becomes unfalsifiable, which here is the worse of the two.
+            Which is why the two behave so differently, and it is not a coincidence. <b>A count always adds</b>, so gravity has one sign and cannot be screened. <b>A signed sum cancels</b>, so a bias comes in two kinds and ordinary matter has none of it while still having all of its mass.
           </Para>
 
-          <Head>and then the cosmology, which I did not want</Head>
+          <Head>four emitters, and each of the four is something</Head>
+
+          <Kinds />
 
           <Para>
-            The rules fix a cosmology whether or not one was wanted, because matter makes space and meetings unmake it and the net is what escapes. Asked for the <i>observed</i> <V>H</V>, the version where space is made throughout the bulk fails seven separate ways, and the fatal one is that the pairs which make the space <i>are</i> the fog that stops the gravity. One <V>Φ</V>, two jobs, opposite values, thirty-five orders apart.
+            A source has exactly two switches and they are independent: whether it has <i>sides</i> (an axis) and whether it <i>comes round</i> (turns, or flips). Crossing them gives four distinguishable emissions — nothing signed at all, one sign in every direction, nothing signed again, and + out of one side with − out of the other. That much is structure, and it was not arranged for.
           </Para>
 
           <BR/>
 
           <Para>
-            The way out is to notice that "space is made in the bulk" was an assumption nobody argued for. Put the creation only where there is <i>no space yet</i>: a cell on the <b>frontier</b> has nothing on one side, so a charge emitted outward meets nothing ever and never gives its point back, and that point is new space. A charge emitted inward meets the bulk and annihilates. The interior makes none at all — which dissolves five of the seven at once, since all five were consequences of a bulk vacuum.
+            What those four <i>are</i> is a different question and I am not going to pretend to answer it. Calling the second an electric charge and the fourth a magnet is a guess — reasonable, and not earned — so the panel says what each one emits and stops. Everything below concerns the fourth, which is a bias.
           </Para>
 
-          <Eq derive={REACH}
-            note="one emission a cell a tick is the ceiling — so it is also the rate">
-            <Frac over={<>d<V>R</V></>} under={<>d<V>t</V></>} /> = 1
-            <span style={{ padding: '0 0.6em', color: FAINT }}>cell/tick</span> = <V>c</V>
-            <span style={{ padding: '0 1.4em', color: FAINT }}>⇒</span>
-            <V>R</V> = <V>ct</V>
-          </Eq>
+          <BR/>
 
           <Para>
-            And then a Hubble law by pure kinematics: matter that left the origin at <V>t</V> = 0 and free-streams sits at <V>x</V> = <V>vt</V>, so any two of them separate at <V>r</V>/<V>t</V> and <b>every</b> observer inside sees <V>v</V> = <V>Hr</V> with <V>H</V> = 1/<V>t</V>. No metric expansion, no stretched wavelengths, no tired light — the redshift is ordinary Doppler. And the age is then <i>forced</i>, not fitted: <V>t</V> = 1/<V>H</V><Sub>0</Sub> exactly, which is 14.51 Gyr at <V>H</V><Sub>0</Sub> = 67.4 and 13.39 at 73.0, against a measured 13.80 ± 0.02. <b>The Hubble tension brackets it.</b> A model with no freedom to miss does not miss.
+            And whatever they turn out to be, <b>none of them can be a sided source with a net</b>: there is no way to be sided without having two sides. Checked over twenty thousand axes, the net emission is exactly nought every time, because the lattice's exits come in ± pairs so a direction and its opposite always get opposite signs. That is ∇·<V>B</V> = 0 and the absence of monopoles — a symmetry electromagnetism <i>observes</i>, and this model cannot avoid.
           </Para>
 
-          <BR/>
+          <Head>a magnet is a lopsided default, not a stopped one</Head>
 
           <Para>
-            In its own units the universe is 8.49·10<Sup>60</Sup> ticks old and 8.49·10<Sup>60</Sup> cells in radius — the same number, which is what <V>R</V> = <V>ct</V> means and is worth seeing written down.
+            The constraint that decides this whole section is that <b>a magnet still has to pulse its weight</b>. The two clocks are independent — <K>beat</K> = 1/<V>m</V> is how often it lets go, <K>rate</K> is how fast its axis comes round — so magnetising a thing cannot change what it weighs, and an emitter never has to stop. Both go on at once, and the magnet is the amount by which the alternation fails to come out even.
           </Para>
 
-          <BR/>
+          <Eq note="a lopsided default, not a stopped one — and dwell is a count of ticks, so P is quantised">
+            <V>P</V> = 2·<K>dwell</K> − 1,<span style={{ padding: '0 1.2em' }} />
+            <K>dwell</K> = <V>k</V>/<K>CYCLE</K><span style={{ padding: '0 1.2em' }} />
+            ⇒ <V>P</V> ∈ {'{'}0, ¼, ½, ¾, 1{'}'}
+          </Eq>
+
+          <Lopsided />
 
           <Para>
-            <b>And then it fails the supernovae, which is the honest end of this section.</b> A coasting universe is <V>q</V><Sub>0</Sub> = 0 exactly, with no <V>Ω</V>, no <V>Λ</V> and no freedom anywhere; the measured value is −0.55 ± 0.05. The defence — that a supernova's absolute magnitude is a nuisance parameter, so a constant offset is free and only the <i>shape</i> counts — is a real one, so marginalise the offset away and look at what is left. The residual runs +0.072 mag at <V>z</V> = 0.02, through zero near 0.18, to −0.130 at <V>z</V> = 1: <b>0.061 mag rms and monotonic</b>, where Pantheon+ bins carry 0.02–0.03. And the shape of that residual — nearby too bright, distant too faint — is precisely the one the 1998 measurements found and named acceleration. The same construction, asked a second question, gets it wrong by the width of the discovery that started modern cosmology.
+            <K>dwell</K> is a count of ticks, so the smallest magnetisation a single emitter can carry is 2/<K>CYCLE</K> = <b>a quarter</b>. Magnetisation comes in units, with nothing free in it. Against that, a saturated neodymium magnet measures <V>P</V> = 1.51·10<Sup>−5</Sup> in bulk: <b>99.9985% of what it emits cancels</b>, and what a magnet <i>is</i> is the fifteen parts per million that failed to.
           </Para>
 
           <BR/>
 
           <Para>
-            There is worse, and it is structural rather than numerical. A charge arriving at an occupied cell has exactly two outcomes and no third — annihilate, or reverse — and both are extinction. A step is one cell and a heading is one of <K><Bar>DEG</Bar></K>, so there is no soft forward channel anywhere in the rules: <b>the lattice can dim light and it cannot redden it</b>, and by the same missing channel it cannot move energy between frequencies either. FIRAS has the microwave background as a blackbody to a part in 10<Sup>5</Sup>, and this model has no mechanism that would produce one <i>at any temperature</i>. No thermal history, no light elements, no acoustic peaks. That is not a small number coming out wrong; it is an absence.
+            The count behind that is a check rather than a fit, and worth spelling out because it is the only place the two halves of the model touch a laboratory. It is a measured remanence divided by a measured <V>µ</V><Sub>B</Sub>, read against the moment per atom measured a different way — iron <b>2.17</b> against 2.22, cobalt 1.69 against 1.72, nickel 0.57 against 0.61, Nd<Sub>2</Sub>Fe<Sub>14</Sub>B 29.8 against about 32. So whatever carries magnetisation has an electron's moment and an electron's abundance, in four materials at once. <b><V>µ</V><Sub>B</Sub> and the electron are inputs here, not results.</b>
           </Para>
 
-          <Head>and whether any of that is dark matter</Head>
+          <Head>the sign law was already inside G</Head>
 
           <Para>
-            Now the part I spent longest on and got wrong most often. Below is the Milky Way put through the model's own force law, summed directly over its baryons ring by ring and angle by angle — no shell theorem, no enclosed-mass shortcut, so nothing about what the outside does is assumed.
+            Here is the thing I did not expect. <K><Bar>G</Bar></K>'s derivation carries a factor it has never had to justify: <i>half of them opposite</i>. That half is the chance two charges landing in the same cell have opposite sign — and it is not a constant, it is a fact about the matter involved. Half is what you get when both bodies are unbiased. Ordinary matter is unbiased. <b>That is the whole reason it ever looked like a number.</b> Put the bias back and the sign law falls out with no new rule at all.
           </Para>
 
-          <Rotation />
+          <Eq note="like biases attract less, opposite attract more — and at P = 0 it is Newton exactly">
+            <V>F</V> = <Frac
+              over={<><K>G</K> <V>m</V><Sub>a</Sub> <V>m</V><Sub>b</Sub></>}
+              under={<><V>R</V><Sup>2</Sup></>} />
+            <span style={{ padding: '0 0.5em' }} />
+            (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)
+          </Eq>
 
           <Para>
-            It peaks at 193 km/s and falls to 104 by 30 kpc, against a curve Gaia measures at 229 at the Sun and 200 at 25. That is a shortfall in the pull of 52% at the Sun and 242% at 30 kpc. And <b>it is not this model's shortfall in particular</b>, which is the honest way to put it.
+            Read off the split: unbiased against unbiased is one half and one half, which <i>is</i> the ½ in <K><Bar>G</Bar></K>, so Newton is the <V>P</V> = 0 case and not a separate claim. Biased against unbiased is also one half — a bias does nothing to something with no bias of its own, which comes out of the arithmetic rather than being put in by hand. Same bias gives nought, opposite bias gives twice. <b>Opposites attract and sameness repels, derived</b>, which is where this whole idea started.
           </Para>
 
-          <Apart />
+          <BR/>
 
           <Para>
-            Two lines at 10<Sup>−7</Sup>, one at 10<Sup>−10</Sup>, and the discrepancy at 10<Sup>0</Sup>. <b>The entire difference between Newton, Einstein and this model is six orders below the thing all three of them miss.</b> Whatever dark matter is, no correction of that size was ever going to reach it — so read this panel as closing off the obvious direction, not as closing the question.
+            Which is worth stopping on: <b>the gravitational constant carries a factor of one half because ordinary matter is unbiased.</b> If matter had a net bias, <V>G</V> would be a different number. The half was already there and unexplained; this is what it was — and that needs no reading whatever of what the bias <i>is</i>.
           </Para>
 
-          <Split />
+          <Head>and where the bias lives decides everything</Head>
 
           <Para>
-            One tempting escape closes here too. The exterior mass does <i>not</i> cancel — a disc is not a sphere — but it pulls <b>outward</b>, because the near arc of an exterior ring is closer than the far arc and wins the inverse square. It takes 27% off the pull at 2 kpc. So the missing gravity cannot come from the outside failing to cancel: the outside is already counted, already fails to cancel, and already subtracts.
+            There are two places the bias could sit and only one of them is a magnet, and getting that wrong cost me a long time. Put it on a <i>direction</i> — one emitter, + out of its north half and − out of its south, from a single place — and it fails: pole to pole gives <b>exactly nothing</b>, by an exact cancellation, and the fall-off is 1/<V>R</V><Sup>2</Sup> where two magnets are 1/<V>R</V><Sup>4</Sup>. Giving the emitter a ring does not rescue it, at any phase.
           </Para>
 
           <BR/>
 
           <Para>
-            After that I stopped testing mechanisms one at a time, because they kept dying on the same number. Enumerate instead every dimensionless quantity the model can build at 20 kpc — <V>GM</V>/<V>rc</V><Sup>2</Sup> = 1.70·10<Sup>−7</Sup>, <V>v</V><Sup>2</Sup>/<V>c</V><Sup>2</Sup> = 5.39·10<Sup>−7</Sup>, <V>r</V>/<V>λ</V><Sub>reach</Sub> = 1.25·10<Sup>−5</Sup>, <V>r</V>/<V>ct</V><Sub>0</Sub> = 4.73·10<Sup>−6</Sup>, the lattice spacing at 10<Sup>−56</Sup> — and closing a gap of +195% needs an <V>O</V>(1) number. <b>Exactly one of the eight is anywhere near unity</b>, and it is <V>g·t</V><Sub>0</Sub>/<V>c</V> = 3.86·10<Sup>−2</Sup>. Which closes the whole family at once rather than one idea at a time, and is worth more than any of the individual tests.
+            Put it on a <i>place</i> and everything works. A bar magnet is then a lump biased + at one end and − at the other — net zero because the two ends cancel, <b>separated in space rather than in direction</b> — which is what magnetostatics has always called the pole model. Nothing else changes: the same <K>chance</K>, the same co-location rule, the same (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)/2 XOR whose unbiased case is the half inside <K><Bar>G</Bar></K>.
           </Para>
 
-          <BR/>
+          <Fields />
+
+          <Pairs />
 
           <Para>
-            And there is a theorem underneath, which I would rather have found earlier. Action and reaction gives <V>m</V><Sub>a</Sub><V>h</V>(<V>m</V><Sub>b</Sub>) = <V>m</V><Sub>b</Sub><V>h</V>(<V>m</V><Sub>a</Sub>); equivalence gives <V>F</V> = <V>m</V><Sub>a</Sub>·<V>h</V>(<V>m</V><Sub>b</Sub>); together they force <V>F</V> ∝ <V>m</V><Sub>a</Sub><V>m</V><Sub>b</Sub> exactly, with no freedom at all. So <b>no two-body force law can give √<V>M</V></b>, which is what a Tully–Fisher slope of 3.85 ± 0.09 demands — not a modified one, not a screened one, not one with a different geometry. Every mechanism I built put the nonlinearity in the <i>source</i>, and each found a different way of being told it could not.
+            Measured over the whole of space, by integrating the annihilation excess: <b>3cos²<V>θ</V> − 1 to three decimals</b> at every angle including both sign changes, <b>slope −2.00</b> on gravity's own 1/<V>R</V><Sup>2</Sup> so the force between two of them is 1/<V>R</V><Sup>4</Sup>, and all five orientations right — N–S facing, N–N facing, side by side either way, and one across the other giving nought to 10<Sup>−19</Sup>. That is magnetostatics, out of the same machinery that gave the rotation curve, with <b>nothing added to it</b>.
           </Para>
 
-          <Head>what does work — the carriers slow where they are thin</Head>
+          <BarField />
 
           <Para>
-            It has to go in the <i>transport</i>, then: in how the carriers travel rather than in how hard anything pulls. And <K>inStep</K> already says when a carrier gets to travel cheaply — emitters within a common phase pay the update once between them — so a dense field is a fast one and a thin field is a slow one. No new rule.
+            And the field lines there are integrated from the model's own signed emission — Σ sign·<K>SHEET</K>/4π<V>r</V><Sup>2</Sup> over the two pole faces — rather than from a textbook formula. They come out as a dipole because that sum <i>is</i> a dipole, which is the whole of the point.
           </Para>
 
-          <Eq note="the drift, and flux conservation with it">
-            <V>v</V> = <V>c</V>·min(1, <V>n</V>/<V>n</V><Sub>c</Sub>)
-            <span style={{ padding: '0 1.6em', color: FAINT }}>,</span>
-            <V>Φ</V> = 4π<V>r</V><Sup>2</Sup>·<V>n</V>·<V>v</V> = constant
-          </Eq>
+          <BR/>
 
           <Para>
-            Dense, and <V>v</V> = <V>c</V>, so <V>n</V> ∝ 1/<V>r</V><Sup>2</Sup>: Newton. Thin, and <V>v</V> ∝ <V>n</V>, so flux conservation goes <i>quadratic</i> and <V>n</V> ∝ √<V>Φ</V>/<V>r</V> — which is <b>both halves at once</b>, the 1/<V>r</V> law and, since <V>Φ</V> ∝ <V>M</V>, an effective source going as √<V>M</V>. Measured by integrating the transport: slope −2.0000 inside, −1.0000 outside, and the outer density against √<V>Φ</V> comes to 10.0000 for a hundredfold mass. That is the nonlinearity the theorem demanded, living where the theorem allows it.
+            It also says why <b>cutting a magnet gives two magnets</b> rather than two monopoles: the sign belongs to a region's boundary, so a new cut makes a new pair of faces. And ∇·<V>B</V> = 0 survives for the same reason — a body's two poles are the same emitters counted at both ends, so they are equal and opposite by construction.
           </Para>
 
-          <BR/>
+          <Head>scale is not the problem</Head>
+
+          <Ceiling />
 
           <Para>
-            The turnover between the two is not borrowed either, which is the part every earlier version of this section quietly assumed. <K>through</K> says a point already carrying a charge is <i>busy</i> — an arriving charge annihilates or reverses, and either way that point does not split this tick — so splitting is suppressed exactly where the carrier density is high, which by <V>g</V> ∝ <V>n</V> is where the field is strong.
+            One emitter's ring has radius (<K>CYCLE</K>·<K>G</K>/2<V>π</V>)·<V>λ̄</V><Sub>C</Sub>, and <V>λ̄</V><Sub>C</Sub> goes as 1/<V>m</V>, so a <i>heavier</i> emitter is a <i>smaller</i> loop. Per kilogram the moment therefore goes as 1/<V>m</V><Sup>2</Sup> in whatever the body is made of, so <b>the lightest constituent wins by the square</b>. That is a scaling law and not a claim about what emitters are — what it buys is that if a body has light and heavy ones, the light ones carry the magnetism, which is the fact <V>µ</V><Sub>B</Sub>/<V>µ</V><Sub>N</Sub> = 1836 records.
           </Para>
 
-          <Eq note="occupancy θ = g/a₀, free fraction 1/(1+θ), and it closes">
-            <V>g</V> = <V>g</V><Sub>N</Sub>·(1 + <V>a</V><Sub>0</Sub>/<V>g</V>)
-            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
-            <V>g</V> = <Frac over={<><V>g</V><Sub>N</Sub></>} under={<>2</>} /> + √(
-            <Frac over={<><V>g</V><Sub>N</Sub><Sup>2</Sup></>} under={<>4</>} /> +{' '}
-            <V>g</V><Sub>N</Sub><V>a</V><Sub>0</Sub>)
-          </Eq>
+          <BR/>
 
           <Para>
-            <b>That is MOND's "simple" interpolation function, and here it is derived rather than chosen.</b> Over six decades <V>g</V>/<V>g</V><Sub>N</Sub> runs 32.1, 10.5, 3.70, 1.62, 1.09, 1.010, 1.0010 against a deep limit √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>) of 31.6, 10.0, 3.16 — agreeing where it should and parting where it should. Every MOND paper picks that function by hand out of a family; this one picks itself out of the counting statistics of the mechanism.
+            And a big body screens itself, so only a skin gets out and the aggregate is an <i>area</i> law rather than a volume one. Run backwards against what is measured, a fully aligned skin of <b>4.5 mm carries the whole of the Earth's field</b>, 3.9 m the Sun's, and 0.16 µm a neutron star's. Nothing anywhere reaches 10<Sup>−4</Sup> of the ceiling. <b>Scale is not what stops this</b>, at any size from an electron to a magnetar — which is a null result in the useful direction.
           </Para>
 
-          <Head>and the scale is not fitted either</Head>
+          <Head>and how many pulses that takes</Head>
 
           <Para>
-            What sets the threshold is the thing the model is <i>about</i>: space being made. Making space has a rate, that rate is <V>H</V>, an acceleration built from it is <V>cH</V>, and the frontier already forces <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub> exactly — so <V>cH</V><Sub>0</Sub> is a count of ticks and not a constant anybody chose. The 2π is <K>inStep</K>'s own.
+            The mechanism is settled and the <i>size</i> is not, so it is worth asking the question the gravitational half answered: how much emission does a magnet actually need? First, it cannot come from the mass stream. If the biased pulses were a subset of the mass pulses, the whole effect would be the (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>) factor, which runs 0 to 2 — <b>so the most magnetism could ever be is one times gravity</b>, the pull switched off or doubled and nothing further. Two touching N52 cubes pull 2.2·10<Sup>12</Sup> times their own gravity. That is settled, and cleanly: magnetism is its own layer.
           </Para>
 
-          <Eq note="the acceleration scale, with nothing fitted in it">
-            <V>a</V><Sub>0</Sub> = <Frac over={<><V>c</V> <V>H</V><Sub>0</Sub></>} under={<>2π</>} />
-            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
-            1.096·10<Sup>−10</Sup> m/s²
-            <span style={{ padding: '0 1.2em', color: FAINT }}>vs</span>
-            1.200·10<Sup>−10</Sup> measured
-          </Eq>
+          <BR/>
 
           <Para>
-            <b>Nine percent, with nothing fitted anywhere.</b> And it explains a coincidence that is an embarrassment everywhere else — why should a galaxy know the age of the universe? Here it is not being told the age; it is being told the rate at which space is made, which is the same number because the frontier makes it so. <b>The cosmology and the rotation curves become one fact.</b>
+            So it has its own budget, and the budget is a number. Equating the two channels gives one conversion with no material in it — <V>m</V><Sub>eff</Sub> = <V>q</V>·√(<V>µ</V><Sub>0</Sub>/4<V>π</V><K>G</K>) = 38.7 kg per A·m — so a 1 cm N52 cube must emit as if it weighed <b>four and a half tonnes</b>, six hundred thousand times its own mass.
           </Para>
 
           <BR/>
 
           <Para>
-            Run on the Milky Way with that predicted <V>a</V><Sub>0</Sub> and nothing fitted at all, the ratio to Gaia goes 0.977 · 0.997 · 0.999 · 0.995 · 0.987 · 0.987 · 1.002 · 1.028 from 6 to 30 kpc — <b>1.1% rms</b>, with a Tully–Fisher slope of 3.42 against a measured 3.85 ± 0.09. Newton alone runs 0.83 down to 0.54 over the same range. Which is worth <i>looking</i> at rather than reading, because a rotation curve is a graph and a graph hides what it means:
+            And the ratio is not a constant, which is the informative part: it runs 6·10<Sup>3</Sup> to 6·10<Sup>5</Sup> across six magnets, going as <V>M</V>/<V>ρL</V>, because <b>a pole is a surface and mass is a volume</b>. Divide the geometry out and what is left <i>is</i> constant — 4.5·10<Sup>7</Sup> kg/m² of pole face for saturated N52, one number reproducing all six geometries with no residual. What sets that number is the open question, and it is the same shape as <V>a</V><Sub>0</Sub> was before <V>cH</V><Sub>0</Sub>/2π: a coupling waiting for a count.
           </Para>
 
-          <Discs />
+          <BR/>
 
           <Para>
-            Four spokes of stars laid down along one radius and left to shear, under each law, with the measured curve dashed and repeated in every panel. General relativity falls visibly behind it within one turn of the Sun.
+            And because there is one ceiling, the budget is <i>shared</i>: pulses spent being a magnet are not being mass, so <b>magnetising a thing makes it lighter</b>, by exactly the fraction diverted. Which is a prediction that can be shot at — and the cheap version of it is already dead, because if the diverted fraction were the bulk bias itself, 1.5·10<Sup>−5</Sup>, a kilogram bar would lose 10 mg on being saturated, five orders above what a comparator would miss. So the magnetic layer's pulses are worth at least 10<Sup>14</Sup> gravitational ones, and that floor comes from a weighing rather than from a choice.
           </Para>
 
-          <Head>the sharpest test, and it nearly failed</Head>
+          <Head>and the one number the whole thing owes</Head>
+
+          <Ladder />
 
           <Para>
-            A first reading made <V>a</V><Sub>0</Sub> a <i>clock reading</i> — <V>c</V>/2π<V>t</V>, so three times larger at <V>z</V> = 2 — which is a dated, falsifiable prediction MOND cannot make. Genzel and co. measure five massive discs at <V>z</V> = 0.85–2.24 with <i>declining</i> outer curves and <V>f</V><Sub>DM</Sub>(&lt;<V>R</V><Sub>e</Sub>) &lt; 0.2, which is a boost under about 1.118. That reading predicts 1.18, 1.17, 1.16, 1.24 — four of five over the line — and refuses it.
+            Every force in this model is second order in the emission — nothing happens to a charge that does not <i>meet</i> another charge — so the electric force is capped at the size of gravity, and measurement puts it 4.166·10<Sup>42</Sup> above. What is worth saying is that <b>the hierarchy itself is not the mystery</b>. <i>If</i> the coupling were a count of order one where gravity is a product of two rates, the gap would be the mass in Planck units squared: <V>α</V>/(<V>m</V><Sub>e</Sub>/<V>m</V><Sub>P</Sub>)<Sup>2</Sup> = 4.166·10<Sup>42</Sup>, which is the measured ratio to five figures. <b>The bill is exactly one number, <V>α</V></b>, and nothing here derives it. Of 117,649 lattice monomials searched, 51 land within half a percent of 137.036 — so a hit would not be evidence, and none is claimed.
           </Para>
 
-          <HighZDiscs />
+          <BR/>
 
           <Para>
-            The blocking above rescues it, and at a price. <V>a</V><Sub>0</Sub> is a function of the field at the point and nothing else, so it is <i>local</i> rather than cosmological and does not move with redshift — there is nothing in it that could. That removes the refutation. <b>It does not make the discs agree</b>, and an earlier version of this section said it did, on a calculation that was wrong.
+            And the bias is not electric charge, which is sharper than the factor and has to be answered first. Emission rate goes as mass, so if charge were the signed emission rate a proton would carry <b>1836 times</b> an electron's, where measurement has the two equal to 10<Sup>−21</Sup>. Whatever <V>P</V> is, it is not <V>q</V>.
           </Para>
 
-          <HighRedshift />
+          <Head>the audit</Head>
 
-          <HighZCurves />
+          <Rows of={[
+            [<>what comes out</>,
+              <>The 1/<V>r</V><Sup>2</Sup>, as flux over a growing shell — exactly{' '}
+                <K>SHEET</K> = 8 through any sphere, to the last digit. The sign law, for a
+                bias. Two signs that cancel. A ± ledger that balances, which is what{' '}
+                <K>BITE</K> = 1 exists for. Magnetisation quantised in quarters. ∇·<V>B</V> = 0
+                and the absence of monopoles. That the lightest constituent wins by the
+                square. Superposition. The dipole angular law 3cos²<V>θ</V> − 1, the
+                1/<V>R</V><Sup>4</Sup> force, all five orientations, and that cutting a magnet
+                halves it. <b>Thirteen of twenty-nine.</b></>],
+            [<>what is assumed</>,
+              <><K>LIGHT</K> = 1 is an axiom rather than a result, so <V>c</V> being finite
+                and universal is built in — and with it, that radiation exists at all.</>],
+            [<>what is owed</>,
+              <>One number: <b>the magnetic coupling</b>, the 4.5·10<Sup>7</Sup> kg/m² of
+                pole face. Measured, not counted. Everything else here follows once it is
+                fixed.</>],
+            [<>what is not started</>,
+              <>The electric half, entirely: charge, <V>ε</V><Sub>0</Sub>, <V>α</V>, Faraday,
+                Ampère–Maxwell, the Lorentz force. Those need a model of matter <i>and</i> a
+                first-order channel, and neither exists — a force here is a <i>meeting</i>,
+                which is second order. That one fact is the whole of the missing column.</>],
+            [<>and what is refuted</>,
+              <><V>g</V> = 1, where the electron's is 2.0023 — and that one survives every
+                choice, since <V>µ</V>/<V>L</V> = <V>q</V>/2<V>m</V> with the radius
+                cancelling out. The anisotropy predicts ⟨111⟩ by 11.1% in every cubic
+                crystal, which is right for nickel, wrong for iron, and flat where
+                measurement runs from 2.6% to 32%. And a magnet cannot be made of{' '}
+                <i>sided</i> emitters, however they are ordered.</>],
+          ]} />
+
+          <Head>where the poles come from, which is not settled</Head>
 
           <Para>
-            Drawn as curves rather than as a boost factor, the disagreement is immediate: <b>four of five overshoot</b>. The earlier pass took <V>g</V><Sub>N</Sub> = <V>GM</V>/<V>R</V><Sub>e</Sub><Sup>2</Sup>, a <i>point mass</i>, and these are discs — at one effective radius a disc has enclosed about half its mass, so its real <V>g</V><Sub>N</Sub> is roughly half that, which sits deeper in the boosted regime and gives a <i>larger</i> boost. The shortcut was generous in exactly the direction that made the model pass. Done properly: 1.174, 1.131, 1.122, 1.158 and 1.033 against a ceiling of 1.118.
+            A magnet needs its bias on a place, and something has to <i>put</i> it there. The natural answer is ordering: emitters pointed the same way and held there, so inside the body every + has a − sitting on it and at a face it does not. <b>Measured, that happens</b> — the signed emission is nought in the middle of a cylinder and largest at its ends.
           </Para>
 
           <BR/>
 
           <Para>
-            But "overshoots four of five" is an adjective and not a measurement. <V>f</V><Sub>DM</Sub> &lt; 0.2 is an <i>upper limit</i>, so the true boost lies somewhere in 1.000…1.118 — Newton sits at the bottom of that band by construction and the model just above the top of it, and which is closer depends where in the band the truth is. At <V>f</V><Sub>DM</Sub> = 0 Newton is exact and the model is 13.3% high; at 0.10 it is 5.1% low against 8.1% high; at 0.20 it is <b>10.6% low against 4.4% high</b> and the model wins. Meanwhile on the Milky Way the model is <b>1.1% rms against Newton's 32.5%</b>, worst case 2.6% against 43.1%. So the high-<V>z</V> discs are a real tension and not a refutation — and the thing that had to go for the model to survive them is the dated prediction, which should be read as the model becoming <i>harder</i> to test.
+            And it still does not make a magnet. Axial, radial and cylindrical orderings all give a far field falling as 1/<V>r</V><Sup>2</Sup> where a magnet is 1/<V>r</V><Sup>3</Sup>, because <b>the cancellation is a near-field fact</b>: a distant body does not see neighbours cancelling, it sees every emitter's chosen side at once. The sign of a sided emitter's pulse is decided by where the observer <i>is</i>, so the sides add instead of cancelling.
           </Para>
 
-          <Head>the prediction the lattice hands back</Head>
+          <BR/>
 
           <Para>
-            One thing does come back, and it is sharper than what was lost. The pair is emitted with the field direction <i>removed</i>, so the space made around a mass is not a sphere — and the obvious worry is that an anisotropy varying with radius would change the <i>shape</i> of the curve and not just its scale.
+            Which turns the open question into one line of the source. <K>emission</K> is <code>sided ? along() : cos(2πβ)</code>, and <K>along</K> resolves the direction against the axis <i>at the destination</i>. A pulse whose polarity were fixed <b>when it left</b> would carry it, the near-field cancellation would survive to infinity, and the faces would be poles. So: <b>is a pulse's sign fixed when it leaves, or when it arrives?</b> Nothing else about the mechanism changes either way, which makes it the cheapest open question on the page.
           </Para>
 
           <BR/>
 
           <Para>
-            It does not, and the lattice is why. The 26 exits from a cell have only <b>three distinct direction cosines</b> — 1 for the six faces, 1/√2 for the twelve edges, 1/√3 for the eight corners — so the projection is a <i>step</i> function with four values: 0.4721, 0.4510, 0.4022, 0.3610. A galaxy spans <V>g</V>/<V>a</V><Sub>0</Sub> from 0.34 at 30 kpc to 4.84 at 2 kpc and never crosses a step. The expansion around it is genuinely not a sphere, but it is one of <i>four discrete shapes</i>, and a galaxy sits in one of them throughout.
+            So the honest sentence here is the opposite shape to the gravitational one. There, the scale came out unfitted and the structure was the fight. Here it is the other way round: <b>the whole structure of magnetostatics comes out of the same XOR that gave gravity</b>, and the one thing it owes is the scale. <b>Magnetostatics derived, its coupling owed, and electric charge not started.</b>
           </Para>
 
-          <BR/>
+          <Head>and the same theory with the XOR turned off</Head>
 
           <Para>
-            <b>But a galaxy is not the whole of anything.</b> Far enough out the occupancy does cross a step, and when it does <V>a</V><Sub>0</Sub> jumps by a fixed ratio — which is a <b>discontinuity in a rotation curve, at a radius the model computes</b>. For the Milky Way that is <b>33 and 52 kpc</b>, where the Sagittarius stream lives and where the satellite population is measured; for a big spiral 58 and 90; for a dwarf <b>6 and 9 kpc</b>, inside the stellar body where a curve is easiest to measure. The size is small and the shape is the point: <V>v</V> ∝ <V>a</V><Sub>0</Sub><Sup>¼</Sup>, so the plateau ratios give jumps of 1.1%, 2.8% and 2.7% — two to six km/s on a 200 km/s curve, <i>sharp</i>, at a radius fixed by the baryons alone with nothing to tune. MOND has no reason for a curve to be anything but smooth, and a halo is smooth by construction.
+            Which is worth asking because it makes this a <i>family</i> rather than a single thing. Take the polarity away — no signs, no opposites, just discrete directions, and a meeting counted when two charges come at each other head on. Does gravity notice?
           </Para>
 
-          <Head>and whether it is dark matter at all</Head>
+          <BR/>
 
           <Para>
-            No, and this is the test that decides it. Clusters need 6.0× their baryons — Coma 6.0, A1689 6.8, A2029 5.3, Perseus 5.9, Virgo 6.0 — and the model supplies 3.32, 3.59, 3.52, 3.75, 5.54, a mean of 3.94 against a mean of 6.0. <b>Short by 1.53×</b>, systematically rather than scattered.
+            Two things change in the rules and they pull opposite ways. The <b>share</b> goes from ½ to 1, because every meeting now annihilates where before only the opposite ones did. And the <b>angular gate comes back</b> — with no sign to decide the outcome there is nothing left but the angle, so <K>closing</K> returns and the folding is bounded to a lens again.
           </Para>
 
-          <BR/>
+          <Eq note="G doubles — and that is the whole of it">
+            <K>G</K> = <Frac
+              over={<><K>BITE</K>·<i>share</i>·<K>SHEET</K><Sup>2</Sup></>}
+              under={<>4<V>π</V><Sup>2</Sup>·<K>CORE</K>·<K>DEG</K></>} />
+            <span style={{ padding: '0 1.4em' }} />
+            {gravitational(0.5).toFixed(6)} → {gravitational(1).toFixed(6)}
+          </Eq>
 
           <Para>
-            And the reason is structural rather than a matter of tuning. In the boosted regime the mass ratio is √(<V>a</V><Sub>0</Sub>/<V>g</V><Sub>N</Sub>), so a factor of six needs <V>g</V><Sub>N</Sub>/<V>a</V><Sub>0</Sub> = 1/36, and clusters sit at 0.04 to 0.13 — near the turnover rather than deep in it, where the ceiling is about 3×. <b>The square root is a hard ceiling and clusters are above it</b>, so no interpolation function and no value of <V>a</V><Sub>0</Sub> reaches them. Worse, the demands point opposite ways: clusters want <V>a</V><Sub>0</Sub> up to 4× larger and the compact high-<V>z</V> discs want it 0.6× smaller.
+            And the factor of two is not observable in an orbit. Every mass in the model is carried in units of <K>GRAVITY</K>, so a body of physical mass <V>M</V> holds <V>M</V>/<K>G</K> and the dynamics compute <K>G</K>·(<V>M</V>/<K>G</K>). The constant is gone before it is used — <b>a change of the mass unit, not of a trajectory</b>. Measured on the line integral: exactly two at every separation, with <V>S</V>·<V>R</V><Sup>2</Sup> flat in both. The one thing it does carry with it is the mass unit itself: <V>µ</V> = <K>G</K>·<V>m</V><Sub>P</Sub>, so the heaviest elementary thing goes from {(massUnit(0.5) * 1e9).toFixed(3)} µg to {(massUnit(1) * 1e9).toFixed(3)} µg and every emitter pulses half as often. The step and the tick do not go with it — the <K>G</K> cancels out of both.
           </Para>
 
           <BR/>
 
           <Para>
-            <b>So this is not a dark-matter theory. It is a mechanism for the rotation-curve regime.</b> In the deep limit it <i>is</i> MOND — that is what deriving the interpolation rather than choosing it means — so it inherits MOND's cluster problem exactly, for the same reason and by the same factor. What it adds is that <V>a</V><Sub>0</Sub> is computed rather than fitted, the interpolation is derived rather than chosen, and there is a step nobody else predicts. What it does not add is any reach beyond galaxies: no microwave background at all, a failed supernova diagram, no source for the light elements, and clusters short by half. <b>Four of the five things dark matter was invented for are untouched or failed</b>, and a galaxy fitted to 1.1% by a computed constant is one regime out of five.
+            <K>SHEET</K>, <K>DEG</K>, <K>BITE</K>, <K>BIAS</K>, <K>MADE</K>, <K>SPREAD</K>, <K>REACHES</K>, the step and the tick do not move at all. And neither does anything <i>measured</i>: Mercury's sixth, the other five sixths, light's deflection, <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π, the Milky Way to 1.1%, the transport turnover, the interpolation function, the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>. <b>All identical, to every digit quoted</b> — because every one of them is computed from something that never mentions a sign.
           </Para>
 
-          <Head>the ledger</Head>
+          <BR/>
 
           <Para>
-            Which leaves the thing I most want kept honest — what went in, what came out, and what is still owed.
+            <b>So gravity is the same theory.</b> Not approximately. What is lost is magnetism entirely — the sign law, 3cos²<V>θ</V> − 1, 1/<V>R</V><Sup>4</Sup>, ∇·<V>B</V> = 0, the quantised magnetisation — and one <i>explanation</i>: with polarity the ½ in <V>G</V> is derived, being the chance two charges disagree. Without it, the share is 1 by fiat and there is nothing to explain.
           </Para>
 
-          <Rows of={[
-            [<>what is put in</>,
-              <>Six countable facts and nothing else. <K>DEG</K> = 3<Sup>3</Sup> − 1 = 26,
-                ways out of a point. <K>SHEET</K> = 3<Sup>2</Sup> − 1 = 8, charges in one
-                pulse. <K>BITE</K> = 1, points an annihilation removes, so that making and
-                unmaking a ± pair are exact inverses. <K>LIGHT</K> = 1, points per tick.{' '}
-                <K>HALF</K> = ½, a shell being never smaller than the cell its source sits
-                in. And <V>m</V>, which is how <i>often</i> a thing emits rather than a
-                property it has.</>],
-            [<>what comes out</>,
-              <>The inverse square, as a fixed count over a growing shell. The equivalence
-                principle. <V>G</V>, every symbol of it a count. Special relativity's own
-                1/<V>γ</V><Sup>3</Sup> and 1/<V>γ</V>. The metric, <V>A</V> and <V>B</V>{' '}
-                from one compounding count, with β = γ = 1. The geodesic equation, matching
-                Euler–Lagrange to 10<Sup>−7</Sup>. Mercury's advance and light's deflection
-                in full. <V>E</V> = ħω from what mass is, and λ = <V>h</V>/<V>p</V> from not
-                knowing where it is. A screening term Newton has no name for. And the tick,
-                which is the Planck time by identity.</>],
-            [<>what is owed</>,
-              <>One link, and it is arithmetic rather than astronomy: that a carrier's
-                update cost goes as its accumulated phase. <K>through</K> gives the
-                blocking, <K>inStep</K> gives the budget, and nothing here derives the join.
-                Then the ambient sea, which is 2.65× the crossover density even after{' '}
-                <K>reach</K> cuts it off, so the MOND regime switches on only <i>barely</i>{' '}
-                where every fit above assumed it switches on cleanly. And the two
-                derivations of <V>a</V><Sub>0</Sub>, which differ by exactly{' '}
-                <K>DEG</K>/2<K>SHEET</K> = 13/8 — so one of them miscounts, and finding
-                which turns a 9% agreement into a derivation or kills it outright.</>],
-            [<>and four things to shoot at</>,
-              <>The <b>shadow</b>, 4.6% larger than general relativity's at the same mass,
-                parameter-free and inside the reach of an instrument that exists. The{' '}
-                <b>age</b>, forced to 1/<V>H</V><Sub>0</Sub> with no freedom to miss, which
-                the Hubble tension brackets. <b><V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π</b>,
-                computed rather than fitted. And <b>the step</b> — a discontinuity in a
-                rotation curve at 6 and 9 kpc in a dwarf, which nothing else in physics
-                predicts.</>],
-            [<>and one that is probably just wrong</>,
-              <>A neutron star shows about two thirds of its mass, which is outside any
-                equation of state, and pulsar timing measures those directly.</>],
-          ]} />
+          <BR/>
 
           <Para>
-            The rest of the arrangements the model has been run on are below — every one of them the same rules, differing only in what was put in the world and how it was watched.
+            Which leaves the XOR as a <b>tunable parameter, and a free one on the gravitational side</b>. Turning it on costs nothing and buys magnetism; turning it off costs magnetism and buys nothing. That is a better position than this page was in before the question was asked, because it means the magnetic half cannot break the gravitational one — there is no shared number for it to get wrong.
           </Para>
 
-          <Models models={MODELS} />
         </Section>
         <Section head="TODO3">
 
@@ -1859,762 +2605,878 @@ const Physics = () => {
           <Head>except where it is recovered, which is where the law reads it</Head>
 
           <Para>
-            Everything on this page is about <i>one pulse in flight</i>, and for one pulse the verdict above holds without qualification: the front is a cube, scaling a cube gives a cube, and no amount of blur or averaging or 10<Sup>39</Sup> constituents makes a twenty-seventh direction. But the force law never asks a front anything. It asks what is <i>at</i> a place, of a source that has been emitting every tick since it existed — and that is a settled field, which is a different object with a different shape.
+            Everything on this page is about <i>one pulse in flight</i>, and for one pulse the verdict above holds without qualification: the front is a cube, scaling a cube gives a cube, and no amount of blur or averaging or 10<Sup>39</Sup> constituents makes a twenty-seventh direction. But the force law never asks a front anything. It asks what is <i>at</i> a place, of a source that has been emitting every tick since it existed — and that is a settled field, which is a different object with a different shape.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>And the settled field is round, without choosing anything.</b> One absorber in a 101<Sup>3</Sup> vacuum on the 26-neighbour rule, run to steady state: the deficit fits <V>A</V>(1/<V>r</V> − 1/<V>R</V>) to 2% past <V>r</V> = 8, and ⟨100⟩, ⟨110⟩ and ⟨111⟩ agree to 0.90–1.10 at matched radius with no axis preferred. A Chebyshev field would read 2.16 where ⟨111⟩ at <V>r</V> = 20 reads 0.775. The reason is not a rule and not a repair: relaxation kills the anisotropy because the 26-neighbour Laplacian is isotropic to fourth order, and a cube is what only <i>ballistic</i> propagation preserves.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            So the two halves of this section are about two different questions and only one of them is open. <b>What is the shape of a pulse?</b> — a cube, chosen, and the choice is real physics with a 37 µm fingerprint on it. <b>What is the shape of a field?</b> — a sphere, derived, past about four cells, and that is the one <K>chance</K> divides by. The lattice survives in the near field, where ⟨111⟩ runs 21% high at <V>r</V> = 6 and is inside 5% by <V>r</V> = 10, which is exactly the range <K><Bar>FLOOR</Bar></K> was already guarding by hand.
+          </Para>
+
+          <Law/>
+        </Section>
+        <Section head="Quantum Mechanics">
+          <Para>
+            The arc above never mentions quantum mechanics and keeps arriving at it anyway — <V>E</V> = ħω, de Broglie to nine figures, Feynman's amplitude rule, the Planck time as an identity. That is either a good sign or an accident, and the only way to tell is to ask the question directly: <b>where in this model would the two theories actually have to meet, and does anything break there?</b> What follows is that audit, and then the construction it turns into: Dirac out of the movement rules, Schrödinger under it, the Born rule as bookkeeping, and interference as rule (G/1) unchanged. It ends at a wall that is a theorem rather than a debt, which is the one place in this book where the honest answer is that the model cannot get there from here.
+          </Para>
+
+          <Head>there is no second scale to reconcile with</Head>
+
+          <Para>
+            Start with what is <i>not</i> a problem, because it is usually the whole problem. A quantum theory of gravity is normally hard because two constants sit at different scales and nothing relates them. Here they are the same count: the tick comes out at the Planck time to ten figures with <i><K><Bar>G</Bar></K></i> cancelling out of the identity, and ħ enters only through period = 1/mass. <b>ħ, <V>c</V> and <V>G</V> are one grain, not three.</b> There is no gap between the regimes because there is only one regime.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What there <i>is</i>, and it took me a while to see it as the same question, is a seam of a different kind. The gravity chain is written in probabilities — <K>chance</K>, <K>through</K> and <K>met</K> are real occupancies multiplied together, and the meeting rate is explicitly "the chance both are there, a product of two probabilities". The quantum results are written in amplitudes. <b>One model, two arithmetics, and the pull is built on the collapsed one.</b> Everything below is that seam, looked at from four sides.
+          </Para>
+
+          <Head>share was a coherence all along</Head>
+
+          <Para>
+            There is exactly one place in the entire derivation of the pull where a <i>phase</i> enters, and it is <K>share</K>. Every other factor counts arrivals. And <K>share</K> was already shown not to be a stipulation — it is a half because a body made of 10<Sup>57</Sup> emitters with no reason to agree has a uniform phase, and the average of <i>opposed</i> over a uniform phase is exactly a half.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Read that forwards rather than backwards and it says something sharper than it was used for. <b>The gravitational law above is already an expectation value</b>, taken over a phase the derivation chose not to track. It is not a classical law waiting to be quantised. It is a quantum law that has already had its average taken, and <i>G</i><Sub>eff</Sub>/<i>G</i> = 2·share is the statement of what it would be if you put the phase back.
+          </Para>
+
+          <Eq derive={COHERENT} note="the model's kernel, and the one a Born rule would want">
+            share = ⟨opposed(<V>ψ</V>)⟩,&nbsp;&nbsp; opposed(<V>ψ</V>) = |<V>ψ</V>|/π
+            <span style={{ padding: '0 1.2em', color: FAINT }}>vs</span>
+            ¼|<V>e</V><Sup>i<V>φ</V><Sub>a</Sub></Sup> − <V>e</V><Sup>i<V>φ</V><Sub>b</Sub></Sup>|<Sup>2</Sup>
+            = (1 − cos <V>ψ</V>)/2
+          </Eq>
+
+          <Para>
+            The left is what <i>gravity.ts</i> computes — a triangle wave, chosen for smoothness after testing signs directly produced every failure this account has had. The right is a modulus-square of a difference of two phases, which is the shape every interference term in quantum mechanics has. <b>They agree at nought, at a half cycle and at π</b>, which is why nothing measured could have told them apart, and they disagree everywhere in between.
+          </Para>
+
+          <Eq note="G_eff/G for two of the same thing in step, through the same raised-cosine window">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.8em', whiteSpace: 'pre' }}>
+              {`R/λ        0.02   0.10   0.20   0.27   0.50   1.00
+triangle   0.024  0.119  0.238  0.318  0.595  1.000
+cosine     0.001  0.026  0.099  0.171  0.500  1.000`}
+            </span>
+          </Eq>
+
+          <Para>
+            The difference is not a coefficient, it is a <i>power</i>: <b>the triangle vanishes linearly in the separation and the cosine quadratically.</b> So this is a commitment rather than a reinterpretation — adopting the Born-shaped kernel changes what the model says about two identical particles at close range, and the gap peaks at 0.147 in <i>G</i><Sub>eff</Sub>/<i>G</i> at <V>R</V>/<V>λ</V> = 0.268.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And then the honest half. One model wavelength is 2π<i>G</i><V>λ</V><Sub>C</Sub> = 0.151 pm for an electron, so the place the two kernels disagree most is <b>forty femtometres</b> apart — where the electric force between them is 4.166·10<Sup>42</Sup> times the gravitational one, which is the identical ratio the magnetism arc owes <V>α</V> for. The discriminator is real, it is sharp, and it is unreachable. It is written down here as a statement about the model rather than advertised as a test.
+          </Para>
+
+          <Head>and what the rewrite would cost</Head>
+
+          <Para>
+            If the kernel is the cosine, then <K>share</K> should not be a separate factor at all. Promote <K>chance</K> to an amplitude <V>ψ</V> = √chance·<V>e</V><Sup>i<V>φ</V></Sup>, with <V>φ</V> the retarded source phase the model already carries, and the meeting rate's cross-term <i>is</i> <K>share</K> — two factors collapsing into one.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            That is the move this page rewards elsewhere: the falloff and the transparency were one fact counted once, and <K><Bar>DEG</Bar></K> was one constant doing two jobs. <b>It is not made here</b>, because it would alter published numbers in the near field and the measurement that would justify it does not exist.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And it turns out to be far too large a change anyway. Written like this it reads as a rewrite of the whole chain; by the time the walk below is built it is clear that <b>the chain is right everywhere it multiplies probabilities, and there is exactly one function that is in the wrong regime.</b> The narrow version of this proposal is at the foot of the arc, and it is the one I would defend.
+          </Para>
+
+          <Head>a thing in two places, and whether it interferes with itself</Head>
+
+          <Para>
+            Now the question the whole arc was really about. Put one elementary source in a superposition of two positions. Do the branches interfere?
           </Para>
 
           <BR/>
 
           <Para>
-            <b>And the settled field is round, without choosing anything.</b> One absorber in a 101<Sup>3</Sup> vacuum on the 26-neighbour rule, run to steady state: the deficit fits <V>A</V>(1/<V>r</V> − 1/<V>R</V>) to 2% past <V>r</V> = 8, and ⟨100⟩, ⟨110⟩ and ⟨111⟩ agree to 0.90–1.10 at matched radius with no axis preferred. A Chebyshev field would read 2.16 where ⟨111⟩ at <V>r</V> = 20 reads 0.775. The reason is not a rule and not a repair: relaxation kills the anisotropy because the 26-neighbour Laplacian is isotropic to fourth order, and a cube is what only <i>ballistic</i> propagation preserves.
+            <b>They must, and the model has no way to stop them.</b> (G/1) says two rays meeting annihilate; it says nothing about whether they came from the same emitter, and there is no bookkeeping anywhere that could mark two rays <i>same particle, skip</i>. The model already computes this for a single body — the <K><Bar>SKIN</Bar></K> self-screening is a body's charges annihilating against its own field. A superposition is that same computation with the emission split across two places.
           </Para>
 
           <BR/>
 
           <Para>
-            So the two halves of this section are about two different questions and only one of them is open. <b>What is the shape of a pulse?</b> — a cube, chosen, and the choice is real physics with a 37 µm fingerprint on it. <b>What is the shape of a field?</b> — a sphere, derived, past about four cells, and that is the one <K>chance</K> divides by. The lattice survives in the near field, where ⟨111⟩ runs 21% high at <V>r</V> = 6 and is inside 5% by <V>r</V> = 10, which is exactly the range <K><Bar>FLOOR</Bar></K> was already guarding by hand.
+            And the coherence is not fragile here, it is <i>rigid</i>. Two branches of one particle have the same mass, so the same ω, so a fixed phase relation for as long as they exist — by construction, with no dial that could randomise it. Which fixes the self-gravitation outright from the table above: <b>a superposition narrower than a Compton wavelength does not gravitate against itself at all</b>, and past one wavelength it settles to the ordinary law.
           </Para>
 
-          <Law/>
-        </Section>
-      </Section>
-
-      <Section head="XOR: Gravity + Magnetism">
-
-        Instead of having our rays be neutral, we can introduce a polarity to them: positive/negative. When we do that gravity + magnetism comes down to three rules:
-        <BR/>
-        (G+M/1) Annihilation: When two opposite polarities meet, they annihilate, leaving a single neutral spatial point behind.
-
-        <Models models={[DISCRETE[5]]}/>
-
-        (G+M/2) Creation: On all axis, a neutral point expands into two points with opposite polarity in all directions.
-
-        <Models models={[BACKWARD[5]]}/>
-
-        (G+M/3) Repulsion: When two identical polarities meet, they turn around.
-
-        <Models models={[DISCRETE[4]]}/>
-
-        Then the other permutations of the rules are just movement rules (like these two).
-
-        <Models models={[DISCRETE[1]]}/>
-
-        With this setup, we get aggregate behavior of groups of the same polarities, turning away from each other.
-
-        <Models models={([
-            [Polarity.Positive, Polarity.Positive],
-            [Polarity.Negative, Polarity.Negative],
-        ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
-          name: '',
-          note: '',
-          lattice: {
-            seed: () => Graph.blocks({ charge: bySide(left, right) }),
-            ticks: 15, height: 140, density: false,
-          },
-        }))}/>
-
-        And ones with opposite polarities annihilating each-other.
+          <BR/>
 
-        <Models models={([
-            [Polarity.Positive, Polarity.Negative],
-        ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
-          name: '',
-          note: '',
-          lattice: {
-            seed: () => Graph.blocks({ charge: bySide(left, right) }),
-            ticks: 5, height: 140, density: false,
-          },
-        }))}/>
+          <Para>
+            Numerically that is again a statement with nothing to measure in it. For an electron the wavelength is 0.151 pm and interferometric separations are microns — seven orders into the ordinary regime. The model is not in trouble here, and it is not saying anything either.
+          </Para>
 
-        Then an interesting thing happens when you alternate polarities (the phase not mattering for this result). You get attraction. And we recover our two rules of gravity (G/1 + G/2) from these three rules.
+          <Head>the record it leaves, which is derived and is nothing</Head>
 
-        <Models models={([
-          [Polarity.Positive, Polarity.Negative],
-          [Polarity.Positive, Polarity.Positive],
-        ] as [Polarity, Polarity][]).map(([left, right]): Model => ({
-          name: '',
-          note: '',
-          lattice: {
-            seed: () => Graph.emitters({ left, right, gap: 20, every: 1, spin: true }),
-            ticks: 22, height: 140,
-          },
-        }))}/>
+          <Para>
+            The interesting version of the question is not gravitational, it is about <i>what is left behind</i>. An annihilation folds space, and folded space is permanent. So a superposition whose branches annihilate against the outside world writes a which-path record into the geometry, and the visibility of any interference should decay at the rate those records are written. That is decoherence, mechanically, from a rule that was already there.
+          </Para>
 
-        <Section head="Gravity vs XOR">
-          - the heaviest elementary thing goes from ≈1.36 µg to ≈2.71 µg
-          - a body of given physical mass pulses half as often
+          <BR/>
 
-          <Eq>
-            <K><Bar>G</Bar></K><Sup><R>XOR</R></Sup> = <Frac over={1} under={2} /><K><Bar>G</Bar></K>
-          </Eq>
-        </Section>
-        
-        <Section head="XOR Continuous Model">
+          <Para>
+            One distinction has to be made first or the answer comes out wrong, and I had it wrong. Branch-against-<i>branch</i> annihilation needs both branches present, so it is the interference term itself and carries no information about which branch anything was in. Only branch-against-<i>environment</i> leaves a fold whose position differs between the branches. <b>Two rates, and only the second one decoheres.</b>
+          </Para>
 
-          <Eq derive={TURNS} note="two on a line, and eight at every dimension of two or more">
-            <K>l.<Bar>CYCLE</Bar></K> = ways(min(<K>l.<Bar>D</Bar></K>, 2)) =
-            3<Sup>min(<K>l.<Bar>D</Bar></K>, 2)</Sup> − 1
-            <span style={{ padding: '0 1.4em' }} />
-            <K><Bar>SPIN</Bar></K> =
-            <Frac over={<>2<V>π</V></>} under={<K><Bar>CYCLE</Bar></K>} /> = 45°
+          <Eq derive={RECORD} note="linear in the mass, linear in the separation, and the constant is the screening length gravity already had">
+            <V>Γ</V><Sub>env</Sub> = ∫<Sub><V>d</V></Sub><Sup>∞</Sup>
+            share·<V>ρ</V>·chance(<V>m</V>,<V>r</V>)·<V>c</V> ·
+            <Paren><Frac over={<V>d</V>} under={<V>r</V>} /></Paren><Sup>2</Sup>
+            · 4<V>π</V><V>r</V><Sup>2</Sup> d<V>r</V>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            <Frac over={<><V>m</V> <V>d</V></>} under={<><V>λ</V><Sup>2</Sup></>} />
           </Eq>
 
           <Para>
-            The gravity arc counts <i>one</i> thing about an emitter: how often it lets go. That is mass. This arc keeps the second thing, which is <b>which way round it is when it does</b> — and the whole of the difference between the two models is what you do with a sign.
+            The bracket is the distinguishability — two branches <V>d</V> apart look identical from far away up to a dipole term going as <V>d</V>/<V>r</V> — and the rest is the ambient annihilation rate the vacuum section already carries. Three powers of <V>r</V> cancel against each other, and then <V>λ</V> = 1/√(<K><Bar>BITE</Bar></K>·share·<K><Bar>SHEET</Bar></K>·<V>ρ</V>) eats the density and the <K><Bar>SHEET</Bar></K> whole. <b>Nothing was fitted and nothing new was introduced</b>, which is the whole reason for doing it this way.
           </Para>
 
           <BR/>
 
           <Para>
-            So the plan for this section is: first what changes in the rules, then <i>where</i> the two models diverge — which is local and is the interesting part — then why the global answer is nevertheless the same, and then magnetism, which is what the signs buy.
+            <b>And then the number kills it.</b> <V>λ</V> is 1.63 horizon radii, so 1/<V>λ</V><Sup>2</Sup> is 10<Sup>−122</Sup>, and in SI the entire law reads <V>Γ</V> = 4.41·10<Sup>−36</Sup>·<V>M</V>·<V>d</V> per second.
           </Para>
 
-          <Head>a charge as a number</Head>
+          <Eq note="against an age of the universe of 4.35·10¹⁷ s">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.8em', whiteSpace: 'pre' }}>
+              {`                          m (kg)    d (m)    t_decoh (s)
+electron                  9.1e−31   1e−6     2.5e+71
+C60                       1.2e−24   1e−7     1.9e+66
+1e−14 kg nanoparticle     1e−14     1e−4     2.3e+53
+1 kg, a metre apart       1         1        2.3e+35`}
+            </span>
+          </Eq>
 
           <Para>
-            Give each ray a polarity and write it as a number, because that is the form both readings share: +1, −1, or 0 for neutral space. Then the entire interaction law is one expression.
+            I wanted this to be the measurement mechanism and it is not one, by thirty-five orders at the most generous. <b>The vacuum this model has is far too thin to be an environment.</b> So the model offers no gravitationally-induced collapse in the sense <Ref of={'Diósi, "Models for universal reduction of macroscopic quantum fluctuations", Phys. Rev. A 40:1165'} year="1989" at="https://doi.org/10.1103/PhysRevA.40.1165" /> and <Ref of={'Penrose, "On Gravity\'s Role in Quantum State Reduction", Gen. Rel. Grav. 28:581'} year="1996" at="https://doi.org/10.1007/BF02105068" /> propose, and it should not be advertised as though it did. What it does offer is a derived rate rather than a postulated one, which is worth having even when the rate is nought.
           </Para>
 
-          <Eq note="the whole interaction law, and it has exactly two outcomes">
-            agreement(<V>a</V>,<V>b</V>) =
-            <Frac over={<><V>ab</V></>} under={<>|<V>a</V>||<V>b</V>| + <V>ε</V></>} />
-            <span style={{ padding: '0 1.2em' }} />
-            alike = max(agreement, 0)
-            <span style={{ padding: '0 1.2em' }} />
-            cancelling = max(−agreement, 0)
-          </Eq>
+          <Head>what does the dividing work instead</Head>
 
           <Para>
-            Alike is +1 and neither can cancel the other and neither can pass through it, so each turns around — that is (G+M/3). Opposite is −1 and they annihilate, taking the space they were on with them — that is (G+M/1), and it is the only event in the model that changes how much space there is. <b>Nothing in between ever happens to a pair on the lattice</b>, because a lattice charge is ±1 and the product of two of those is ±1.
+            Which leaves the question of why big things do not interfere, and the model's answer is not a rate at all — it is structural, and it was written down long before this section. <b>An elementary thing has a phase and a composite does not.</b> Small things interfere, large things cannot, and the line between them is compositeness rather than a decoherence time. That is roughly the right qualitative answer, arrived at without a postulate.
           </Para>
 
           <BR/>
 
           <Para>
-            In between is what a <i>field</i> does, and it is not a third outcome — it is what you get when the same rule is applied to a great many pairs at once and the answer is how many of them went each way. Which is exactly why the continuous model can hand this same expression a fractional value and mean something true by it: <b>a polarity is a field value rounded off to its sign</b>, and every law is written against the number so neither reading has to restate it.
+            It is also, read carelessly, in direct contradiction with the rest of the model — which is what falls out of this arc, and it is the sharpest thing in it.
           </Para>
 
-          <Head>where the two models actually diverge — and it is local</Head>
+          <Head>the trouble that falls out: a composite needs a phase it is not allowed to have</Head>
 
           <Para>
-            Here is the thing worth being careful about, because it is easy to read the two models as the same theory with a different label on the rays, and they are not.
+            Molecular interferometry works. C60 gives fringes at <V>h</V>/<V>Mv</V> with <V>M</V> the <i>whole molecule</i> — 2.77 pm at 200 m/s against a measured 2.5 — and it has been pushed to 25 kDa since. So whatever the model says a matter wave is, it has to give the total mass.
           </Para>
 
           <BR/>
 
           <Para>
-            Take two rays coming head on. <b>Without polarity there is only one thing that can happen:</b> they meet, they annihilate, and the space goes <i>there</i>, at that cell, on that tick. <b>With polarity there are two.</b> If they disagree, the same thing happens in the same place. If they agree, they <i>turn around</i> — nothing is destroyed at that cell at all — and each travels back the way it came until it runs into the next wave its own source put out behind it. That wave is the opposite sign, because the source alternates. So they annihilate <i>there</i>: half a wavelength back, several ticks later, on the source's side of where the meeting was.
+            But a composite here is <i>many emitters</i> — that is what the mass ceiling means, and matter is nothing else. Each constituent pulses at its own rate with its own <V>λ</V><Sub>C</Sub>, and the de Broglie construction builds its phase out of a single ω. Run it per constituent and the answer is <V>h</V>/<V>m</V><Sub>nucleon</Sub><V>v</V> = 1.98 nm.
           </Para>
 
-          <Eq note="the same two rays, the same eventual annihilation — a different cell and a different tick">
-            <F>no polarity</F>&nbsp;&nbsp;
-            meet at <V>x</V> &nbsp;→&nbsp; annihilate at <V>x</V>, on tick <V>t</V>
-            <span style={{ padding: '0 1.4em' }} />
-            <F>XOR</F>&nbsp;&nbsp;
-            meet at <V>x</V> &nbsp;→&nbsp; turn &nbsp;→&nbsp;
-            annihilate at <V>x</V> ∓ <V>λ</V>/2, on tick <V>t</V> + <V>λ</V>/2<V>c</V>
+          <Eq note="the nucleon count, and it is not a small discrepancy">
+            <Frac over={<><V>h</V>/<V>m</V><Sub>nucleon</Sub><V>v</V></>}
+              under={<><V>h</V>/<V>Mv</V></>} /> = 714
           </Eq>
 
           <Para>
-            <b>That is a real difference and it is entirely local.</b> The map of where space is being destroyed is different between the two models — the XOR one puts its annihilations on the near side of the midline in bands, one per half-cycle, rather than all of them on the surface between the sources. It is the same difference that makes the aggregate panels in the previous section behave as they do: alternating polarities attract because the meetings land where they land, and matched polarities turn away because the meetings keep getting pushed back.
+            <b>Seven hundred times too wide, and measured.</b> This is the same shape as the open question the magnetism arc ends on — a near-field cancellation that does not survive to the far field — and it is the more dangerous of the two, because here the experiment has already been done.
           </Para>
 
           <BR/>
 
           <Para>
-            And then a second thing changes with it, in the opposite direction. Without a sign, there is nothing left to decide an outcome <i>but</i> the angle — so the angular gate comes back and a meeting only counts when the two are closing on each other, which bounds the folding to a lens between the bodies. With a sign, the sign decides it and being in the same cell is the whole of the condition, at any angle; what the angle sets is not <i>whether</i> but <i>how much</i>.
+            The rescue is available and it is the identity the whole book leans on. <i>Mass is a rate.</i> A composite's emission is <V>N</V> interleaved pulse trains, and the aggregate train's repetition rate is Σ<V>m</V><Sub>i</Sub> = <V>M</V> whatever the constituents are doing individually. If what carries the de Broglie phase is the <b>repetition rate of the aggregate emission</b> rather than the phase of any one emitter, ω = <V>M</V> falls out and the fringes are right.
           </Para>
 
-          <Eq note="what the angle is for, once polarity decides the outcome">
-            closing(<B>u</B>,<B>v</B>) = max(−<B>u</B>·<B>v</B>, 0)
-            <span style={{ padding: '0 1.2em' }} />
-            <K><Bar>HEAD_ON</Bar></K> = 1/√2
-            <span style={{ padding: '0 1.2em' }} />
-            splice(<B>u</B>,<B>v</B>) = |<B>û</B> − <B>v̂</B>| = 2 sin(<V>θ</V>/2)
-          </Eq>
+          <BR/>
 
           <Para>
-            splice is how much a meeting <i>shortens</i>: two cells for two rays head on, nothing at all for two going the same way. Which is the honest reading of what an annihilation does to a distance, and it needs the angle whether or not there are signs.
+            And that rescue resolves the contradiction rather than dodging it, which is why I believe it. <b>A rate is coherent and an offset is not.</b> A composite has a perfectly definite ω — it is the sum — and a phase offset that is a sum of <V>N</V> unrelated ones, hence uniform. So <V>λ</V> = <V>h</V>/<V>p</V> reads the rate and works for a molecule, and <K>share</K> reads the relative offset and stays at a half for everything made of parts. The two requirements that looked incompatible are requirements on different halves of the same quantity.
           </Para>
 
-          <Head>and why the global answer is the same anyway</Head>
+          <BR/>
 
           <Para>
-            Two rules changed and they pull opposite ways, and when you write them into <V>S</V><Sub>ab</Sub> they land on the same factor.
+            It is not free, though. It says a bound state's emission is <i>one train</i> and not <V>N</V>, and nothing in the rules makes that happen — a bound state is not yet a thing this model has. <b>That is the one genuinely load-bearing debt in this arc</b>, and it is owed to gravity too, since a composite's pull already assumes the rates add.
           </Para>
 
-          <Rows of={[
-            [<><i>share</i>: ½ → 1</>,
-              <>Without polarity <b>every</b> meeting annihilates, where before only the
-                opposite half did. So the share doubles.</>],
-            [<>the angular gate</>,
-              <>Comes back, since there is nothing else left to decide an outcome. So the
-                folding is bounded to a lens again.</>],
-          ]} />
-
-          <Eq note="G doubles — and that is the whole of it">
-            <i><K><Bar>G</Bar></K></i> = <Frac
-              over={<><K><Bar>BITE</Bar></K>·<i>share</i>·<K><Bar>SHEET</Bar></K><Sup>2</Sup>·<K><Bar>c</Bar></K></>}
-              under={<>4<V>π</V><Sup>2</Sup>·{HALF}·<K><Bar>DEG</Bar></K></>} />
-            <span style={{ padding: '0 1.4em' }} />
-            {gravitational(0.5).toFixed(6)} → {gravitational(1).toFixed(6)}
-          </Eq>
+          <Head>and the fork that is cheap to state and not settled</Head>
 
           <Para>
-            <b>And the factor of two is not observable in an orbit.</b> Every mass in the model is carried in units of <i><K><Bar>G</Bar></K></i>, so a body of physical mass <V>M</V> holds <V>M</V>/<i><K><Bar>G</Bar></K></i> and the dynamics compute <i><K><Bar>G</Bar></K></i>·(<V>M</V>/<i><K><Bar>G</Bar></K></i>). The constant is gone before it is used — <b>a change of the mass unit, not of a trajectory</b>. Measured on the line integral: exactly two at every separation, with <V>S</V>·<V>R</V><Sup>2</Sup> flat in both.
+            There are two carriers of phase in this book and they are not obviously the same object. A source's emission field carries a retarded phase at ω = <V>m</V>, whose interference scale is the Compton wavelength. The matter wave carries <V>φ</V> = ωγ(<V>t</V> − <V>vx</V>/<V>c</V><Sup>2</Sup>), whose scale is <V>λ</V><Sub>C</Sub>/γβ — coarser by 1/β, which for anything slow is an enormous factor.
           </Para>
 
           <BR/>
 
           <Para>
-            <b>But "not of a prediction" would be too strong, and the exception is the mass unit itself.</b> It is not free to stay put — <V>µ</V> = <i><K><Bar>G</Bar></K></i>·<V>m</V><Sub>P</Sub>, so doubling one doubles the other. The heaviest elementary thing goes from <b>{(massUnit(0.5) * 1e9).toFixed(3)} µg to {(massUnit(1) * 1e9).toFixed(3)} µg</b>, and a body of given physical mass pulses <b>half as often</b>: an electron every 1.61·10<Sup>−22</Sup> s against 8.03·10<Sup>−23</Sup>. Which is the right direction rather than a fault — with no polarity every meeting annihilates instead of half of them, so each emission is twice as effective and half as much of it is needed for the same pull. Nothing measures that ceiling, so it refutes neither version; but it is a statement about the world, and it moves.
+            A two-slit apparatus measures the second. Nothing in this book says which of the two it is reading, or how they are the same field. Note that the de Broglie construction is <i>itself</i> an ignorance-over-position argument — two retarded branches weighted at a half — so it may already <b>be</b> the two-slit calculation, with the weight being the split between the slits. If it is, interference comes free. If it is not, there are two unrelated position superpositions here and one of them is spurious. <b>Is the two-slit weight the same one-half as the ignorance weight?</b> Like the magnetism arc's question about when a pulse's sign is fixed, nothing else changes either way, which makes it cheap.
           </Para>
 
-          <BR/>
+          <Head>and one thing that has no representation at all</Head>
 
           <Para>
-            The tick and the step do <i>not</i> go with it, which is worth checking rather than assuming. At the ceiling the period is <i><K><Bar>G</Bar></K></i>ħ/(<V>µc</V><Sup>2</Sup>) = ħ/(<V>m</V><Sub>P</Sub><V>c</V><Sup>2</Sup>) — the <i><K><Bar>G</Bar></K></i> cancels — so both stay exactly Planck at either share. And so does the Compton line, whose constant tracks <i><K><Bar>G</Bar></K></i> because <V>µ</V> does: measured, <V>k</V>/<i><K><Bar>G</Bar></K></i> = 1.000000000 at both.
+            Worth saying plainly rather than leaving to be noticed. Mass here is a pulse rate, and a body either pulses on a given tick or does not. A superposition of <i>positions</i> has an obvious representation — emission from two places. A superposition of <b>energy eigenstates</b> does not: there is no state of the model that is two rates at once, and rates do not superpose the way positions do. Every quantum result in this book is about position, momentum or phase, and that is not a stylistic choice — it is the boundary of what the model can currently say.
           </Para>
 
-          <BR/>
+          <Head>the walk the rules already are</Head>
 
           <Para>
-            <K><Bar>SHEET</Bar></K>, <K><Bar>DEG</Bar></K>, <K><Bar>BITE</Bar></K>, <K><Bar>BIAS</Bar></K>, {HALF}, <V>ε</V>, <V>D</V>, the reach, the step and the tick do not move at all. And neither does anything <i>measured</i>: Mercury's sixth, the other five sixths, light's deflection, <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π, the Milky Way to 1.1%, the transport turnover, the interpolation function, the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>. <b>All identical, to every digit quoted</b> — because every one of them is computed from something that never mentions a sign.
+            Now the constructive half, and it starts by noticing that the discrete rules at the top of the gravity arc <i>are</i> a quantum walk and nobody said so. In one dimension a ray moves one cell a tick and its only other option is to turn around. Mass is how often it turns. That is two numbers per cell — how much is going right, how much is going left — and one operation a tick.
           </Para>
 
-          <BR/>
+          <Eq note="a coin that mixes the two headings, then a shift that moves each the way it points">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`ψ_R(x+1, t+1)  =  cos m · ψ_R(x, t)  −  sin m · ψ_L(x, t)
+ψ_L(x−1, t+1)  =  sin m · ψ_R(x, t)  +  cos m · ψ_L(x, t)`}
+            </span>
+          </Eq>
 
           <Para>
-            So the honest statement of the divergence is: <b>the two models put their annihilations in different places and get the same pull out of them.</b> Locally different, globally identical. Which makes the XOR a free parameter on the gravitational side — turning it on costs nothing and buys magnetism, turning it off costs magnetism and buys nothing — and that is a better position than the page was in before the question was asked, because it means the magnetic half cannot break the gravitational one. There is no shared number for it to get wrong.
+            Nothing there is a postulate. <K>cos m</K> is the chance of carrying straight on, <K>sin m</K> the chance of turning, and mass being the turning rate is the same identity — period = 1/mass — that the Compton relation and the Planck tick both came out of. <b>The rotation is the only thing that was chosen</b>, and it was chosen because a turn has to preserve how much ray there is.
           </Para>
 
-          <Head>the sign law was already inside G</Head>
+          <Head>Dirac, and then Schrödinger in two lines</Head>
 
           <Para>
-            Except for one, and this is the part I did not expect. <V>G</V>'s derivation carries a factor it has never had to justify: <i>half of them opposite</i>. That half is the chance that two charges landing in the same cell have opposite sign — and it is not a constant. It is a fact about the matter involved. Half is what you get when both bodies are unbiased. Ordinary matter is unbiased. <b>That is the whole reason it ever looked like a number.</b>
+            Take that to momentum. The transfer matrix has determinant one and trace 2·cos <V>m</V>·cos <V>k</V>, so its eigenvalues are <V>e</V><Sup>±i<V>Ω</V></Sup> with the dispersion below — which is the relation the gravity arc already reported measuring, arrived at here from the rules rather than from a fit.
           </Para>
 
-          <BR/>
+          <Eq note="and for small arguments this is Ω² = k² + m², which is the relativistic one">
+            cos <V>Ω</V> = cos <V>m</V> · cos <V>k</V>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
+            <V>Ω</V><Sup>2</Sup> = <V>k</V><Sup>2</Sup> + <V>m</V><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>to</span>
+            0.99997 at <V>m</V> = 0.01
+          </Eq>
 
           <Para>
-            Put the bias back. If a fraction (1+<V>P</V>)/2 of a body's charges are positive at a place, then of the meetings between <V>a</V>'s and <V>b</V>'s:
+            That is the Dirac equation in 1+1 dimensions, as a continuum limit of a rule about rays turning round. And the non-relativistic limit is two lines of arithmetic on top of it: put <V>Ω</V> = <V>m</V> + <V>δ</V>, expand both sides for <V>k</V> ≪ <V>m</V> ≪ 1, and the <V>δ</V><Sup>2</Sup> term drops out.
           </Para>
 
-          <Eq note="opposite annihilates, alike turns — and there is nothing else two charges can do">
-            annihilating(<V>P</V><Sub>a</Sub>,<V>P</V><Sub>b</Sub>) =
-            <Frac over={<>1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub></>} under={<>2</>} />
-            <span style={{ padding: '0 1.4em' }} />
-            turning(<V>P</V><Sub>a</Sub>,<V>P</V><Sub>b</Sub>) =
-            <Frac over={<>1 + <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub></>} under={<>2</>} />
+          <Eq note="the free Schrödinger equation, with a rest energy sitting in front of it">
+            <V>Ω</V> = <V>m</V> +
+            <Frac over={<><V>k</V><Sup>2</Sup></>} under={<>2 tan <V>m</V></>} />
+            <span style={{ padding: '0 1.4em', color: FAINT }}>measured to</span>
+            1 part in 10<Sup>4</Sup>
           </Eq>
 
-          <Eq note="like biases attract less, opposite attract more — and at P = 0 it is Newton exactly">
-            <V>F</V> = <Frac
-              over={<><V>G</V> <V>m</V><Sub>a</Sub> <V>m</V><Sub>b</Sub></>}
-              under={<><V>R</V><Sup>2</Sup></>} />
-            <span style={{ padding: '0 0.5em' }} />
-            (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)
-          </Eq>
+          <Para>
+            <b>Schrödinger, and it is not quite Schrödinger.</b> The inertial mass that comes out is tan <V>m</V> rather than <V>m</V> — a lattice correction of order <V>m</V><Sup>2</Sup>/3, which for an electron at 10<Sup>−22</Sup> in lattice units is invisible and is nonetheless the model's own answer rather than the textbook's. Using <V>m</V> instead is 8.5% wrong by <V>m</V> = 0.5, so the distinction is real and simply far away.
+          </Para>
+
+          <Head>and the Born rule is the conserved ray count</Head>
 
           <Para>
-            Read off the split. Unbiased against unbiased is one half and one half, which <i>is</i> the ½ in <V>G</V>, so Newton is the <V>P</V> = 0 case and not a separate claim. Biased against unbiased is also one half — a bias does nothing to something with no bias of its own, which comes out of the arithmetic rather than being put in by hand. Same bias gives nought; opposite bias gives twice. <b>Opposites attract and sameness repels, derived</b> — which is where this whole idea started, and which is the sign law <Ref of={'Coulomb, "Premier mémoire sur l\'électricité et le magnétisme", Histoire de l\'Académie Royale des Sciences 569'} year="1785" at="https://gallica.bnf.fr/ark:/12148/bpt6k3570k/f662" /> wrote down as an observation.
+            The rule that usually has to be assumed is here a bookkeeping identity. The walk conserves Σ|<V>ψ</V>|<Sup>2</Sup> exactly — measured at 1.000000000000 after a hundred and twenty ticks — and it does so for one reason: <b>a turn is a rotation, and a rotation preserves a length squared.</b>
           </Para>
 
           <BR/>
 
           <Para>
-            Which is worth stopping on: <b>the gravitational constant carries a factor of one half because ordinary matter is unbiased.</b> If matter had a net bias, <V>G</V> would be a different number. The half was already there and unexplained; this is what it was — and it needs no reading whatever of what the bias <i>is</i>.
+            Which says what the Born rule <i>is</i> in this model, and it is not deep. The model conserves rays; the dynamics is linear in <V>ψ</V>; and rays go as <V>ψ</V><Sup>2</Sup>. So the squaring is not an interpretive act performed at a measurement — it is the relation between the thing the dynamics is linear in and the thing that is conserved, and there was never a choice about which one gets counted. <b>The Born rule is the statement that what is conserved is quadratic in what evolves.</b>
           </Para>
 
-          <Head>one emission, three moments of it</Head>
+          <Head>interference is (G/1), verbatim</Head>
 
           <Para>
-            Gravity used the zeroth moment of the emission and threw the rest away. Keep them and the same emission answers three different questions.
+            And the minus sign — the thing that makes two paths cancel rather than pile up — is not imported either. Look at what the coin does: contributions arrive at a cell and are <i>added</i>, with a sign, before anything is counted. A + and a − arriving together give nought.
           </Para>
 
-          <Eq note="the count is mass, the signed sum is a net, the signed first moment is a bias">
-            <V>m</V> = ⟨1⟩<span style={{ padding: '0 1.6em' }} />
-            <V>q</V> = ⟨<V>s</V>⟩<span style={{ padding: '0 1.6em' }} />
-            <V>µ</V> = ⟨<V>s</V> <B>d̂</B>⟩
-          </Eq>
+          <BR/>
 
           <Para>
-            And that is why the two behave so differently, which is not a coincidence. <b>A count always adds</b>, so gravity has one sign and cannot be screened by cancellation. <b>A signed sum cancels</b>, so a bias comes in two kinds and ordinary matter has none of it while still having all of its mass.
+            That is rule (G/1). <b>Annihilation is destructive interference</b>, written out in the first three lines of the gravity arc and not recognised as such for the whole length of it. Which also says what the XOR arc has been about all along: <b>polarity is the sign of the amplitude.</b> The magnetism arc kept the signs and got magnetism; keep the same signs and ask what a sum over paths does with them, and you get interference. One structure, read twice, which is the move the whole book is built on.
           </Para>
 
-          <Head>what a source is doing at a given moment</Head>
+          <Head>so: amplitude or probability, and the answer is both, by regime</Head>
 
           <Para>
-            A source has exactly two switches and they are independent: whether it has <i>sides</i> (an axis) and whether it <i>comes round</i> (turns, or flips). Crossing them gives four distinguishable emissions, and the whole of what a source is doing at a tick is three lines.
+            Now the question that started this. The gravity chain multiplies real occupancies; the walk adds signed amplitudes and squares afterwards. <b>Those are not in conflict, and I had been reading the seam wrong.</b>
           </Para>
 
-          <Eq note="where its north points, and what it emits that way">
-            rate(<V>s</V>) ∈ [0, 1]
-            <span style={{ padding: '0 1.2em', color: FAINT }}>turns per <K><Bar>CYCLE</Bar></K> ticks</span>
-            <V>β</V>(<V>s</V>,<V>t</V>) = phase +
-            <Frac over={<><V>t</V>·rate</>} under={<K><Bar>CYCLE</Bar></K>} />
-          </Eq>
-
-          <Eq note="a spiral and a ring are the same function with and without an angle in it">
-            <V>F</V>(<B>d</B>) = sided ? <B>d</B>·<B>n̂</B>(<V>β</V>) : cos(2<V>π</V><V>β</V>)
-          </Eq>
+          <BR/>
 
           <Para>
-            <i>Sided</i> is the only thing separating the two kinds of source, and it is not a parameter so much as a question about the source. With sides, what it emits depends on the direction — the field carries a θ in it, its zero set is θ = 2π<V>β</V> + const, and that is an Archimedean spiral. Without, direction drops out altogether, the zero set is a set of <i>instants</i> rather than places, and what travels out is rings.
+            Multiplying probabilities is <i>correct</i> whenever the phases have already averaged out, and the gravity chain is never anywhere else: every source in every panel is 10<Sup>57</Sup> emitters, and <K>share</K> = ½ is precisely the statement that the average has been taken. So <K>chance</K>, <K>through</K> and <K>met</K> are aggregates of |<V>ψ</V>|<Sup>2</Sup>, computed in the regime where that is exactly right. <b>The seam is a regime boundary, not an inconsistency</b> — and the model already knows where the boundary is, because it drew it itself.
           </Para>
 
           <BR/>
 
           <Para>
-            And whatever the four turn out to be, <b>none of them can be a sided source with a net</b>: there is no way to be sided without having two sides. Checked over twenty thousand axes the net emission is exactly nought every time, because the lattice's exits come in ± pairs so a direction and its opposite always get opposite signs. That is ∇·<B>B</B> = 0 and the absence of monopoles — the symmetry <Ref of={'Maxwell, "A Dynamical Theory of the Electromagnetic Field", Phil. Trans. R. Soc. Lond. 155:459'} year="1865" at="https://doi.org/10.1098/rstl.1865.0008" /> had to write in as an observation, and which this model cannot avoid.
+            There is exactly one place where the model crosses its own line. <K>coherence</K> in <i>gravity.ts</i> returns a half immediately unless <i>both</i> sources are elementary — so the only code that ever runs past that guard is code in the coherent regime, and it is the code using |<V>ψ</V>|/π, a real triangle. <b>That is the one function that should be adding amplitudes and is multiplying probabilities instead</b>, and it is nine lines long.
           </Para>
 
-          <Head>a magnet is a lopsided default, not a stopped one</Head>
+          <Eq note="the whole of the proposed change, and it does not touch a single published number outside λ_C">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`opposed(ψ)  =  |ψ|/π   →   (1 − cos ψ)/2
+                       inside "lone" only`}
+            </span>
+          </Eq>
 
           <Para>
-            The constraint that decides this whole section is that <b>a magnet still has to pulse its weight</b>. The two clocks are independent — <K><Bar>beat</Bar></K> = 1/<V>m</V> is how often it lets go, rate is how fast its axis comes round — so magnetising a thing cannot change what it weighs, and an emitter never has to stop. Both go on at once, and the magnet is the amount by which the alternation fails to come out even.
+            So the resolution is not the global rewrite I first thought it was. <b>Probabilities are right everywhere the book uses them except in one function, whose own guard already marks it as the exception.</b> Everything outside <V>λ</V><Sub>C</Sub> is untouched, which is everything the model has ever been tested against.
           </Para>
 
-          <Eq note="a lopsided default, not a stopped one — and dwell is a count of ticks, so P is quantised">
-            <K><Bar>dwell</Bar></K> = <V>k</V>/<K><Bar>CYCLE</Bar></K>
-            <span style={{ padding: '0 1.2em' }} />
-            <V>P</V> = 2·<K><Bar>dwell</Bar></K> − 1
-            <span style={{ padding: '0 1.2em', color: FAINT }}>⇒</span>
-            <V>P</V> ∈ {'{'}0, ¼, ½, ¾, 1{'}'}
+          <Head>and the i is a change of basis, which I did not expect</Head>
+
+          <Para>
+            That leaves the part I was most confident about and was wrong about. The Dirac walk is normally written with a complex coin — <K>cos m</K> on the diagonal and <K>−i·sin m</K> off it — and I assumed the model would have to earn that <V>i</V> from somewhere. It does not have to, because in one dimension there is nothing to earn.
+          </Para>
+
+          <Eq note="identical dispersion, identical distributions, and the same walk in different coordinates">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`max | P_real(x) − P_complex(x) |  over every site, 120 ticks  =  0`}
+            </span>
           </Eq>
 
           <Para>
-            A source turning at full rate is at <K><Bar>dwell</Bar></K> = ½ and has no magnet in it: its axis passes through all <K><Bar>CYCLE</Bar></K> directions, a fixed direction sees + + + 0 − − − 0, and the mean is nought. Turning it slower does not help — the same states in the same order, held longer each — which is worth being explicit about, because slowing <i>looks</i> like it should magnetise and does not. It changes the wavelength of what comes out and not the mean.
+            Exactly nought, not nought to a tolerance. And the reason is one line: <V>D</V> = diag(1, <V>i</V>) turns one coin into the other, and <V>D</V> is diagonal in the left/right basis, so it commutes with the shift. <b>The two walks are the same walk in different coordinates</b>, and the <V>i</V> is a gauge choice with no observable attached to it. The real rotation above is the honest form, and it is the one written here.
           </Para>
 
           <BR/>
 
           <Para>
-            And <K><Bar>dwell</Bar></K> is a count of ticks, so the smallest magnetisation a single emitter can carry is 2/<K><Bar>CYCLE</Bar></K> = <b>a quarter</b>. Magnetisation comes in units, with nothing free in it. Against that, a saturated neodymium magnet measures <V>P</V> = 1.51·10<Sup>−5</Sup> in bulk: <b>99.9985% of what it emits cancels</b>, and what a magnet <i>is</i> is the fifteen parts per million that failed to.
+            Which also retires something the previous section leaned on. cos <V>Ω</V> = cos <V>m</V>·cos <V>k</V> was quoted as evidence that the lattice is doing quantum mechanics; it is satisfied identically by the real coin and by the complex one, so <b>the dispersion relation is not evidence of anything complex</b>. It is evidence of a rotation and a shift, which is all that was put in.
           </Para>
 
-          <Head>and where the bias lives decides everything</Head>
+          <Head>where the i would have to come from, then</Head>
 
           <Para>
-            There are two places the bias could sit and only one of them is a magnet. Put it on a <i>direction</i> — one emitter, + out of its north half and − out of its south, from a single place — and it fails: pole to pole gives <b>exactly nothing</b>, by an exact cancellation, and the fall-off is 1/<V>R</V><Sup>2</Sup> where two magnets are 1/<V>R</V><Sup>4</Sup>. Giving the emitter a ring does not rescue it, at any phase.
+            A real field carrying Dirac dynamics is a Majorana field, and a Majorana field is <i>neutral</i>. That is not a coincidence of the one-dimensional case: real gamma matrices exist in 3+1 dimensions too, so a neutral spinor never needs a complex number anywhere. What needs one is a <b>charged</b> field — which is two real fields, with a U(1) rotating one into the other, and that U(1) <i>is</i> the electric charge.
           </Para>
 
           <BR/>
 
           <Para>
-            Put it on a <i>place</i> and everything works. A bar magnet is then a lump biased + at one end and − at the other — net zero because the two ends cancel, <b>separated in space rather than in direction</b> — which is what magnetostatics has always called the pole model. Nothing else changes: the same <K>chance</K>, the same co-location rule, the same (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)/2 XOR whose unbiased case is the half inside <V>G</V>. And the field is integrated from the model's own signed emission rather than from a textbook formula.
+            So the two things this book has been unable to produce turn out to be one thing. The magnetism arc ends owing electric charge outright — "the electric half, entirely" — and this arc would owe the complex phase. <b>They are the same debt.</b> A second binary label, independent of polarity and rotating against it, delivers the complex structure and the charge in one object; with only polarity, the model is real, neutral, and correspondingly has no <V>q</V> in it — which is exactly what was measured when the bias turned out not to be charge, since emission rate goes as mass and would have made a proton's charge 1836 times an electron's.
           </Para>
 
-          <Eq note="the field of a bar, summed over its two pole faces — and that sum IS a dipole">
-            <B>B</B>(<V>r</V>) = <span style={{ fontSize: '1.3em' }}>Σ</span><Sub>faces</Sub>
-            <Frac over={<>sign · <K><Bar>SHEET</Bar></K></>}
-              under={<>4<V>π r</V><Sup>2</Sup></>} />
-            <span style={{ padding: '0 1.4em' }} />
-            ⟨annihilation excess⟩ ∝ 3cos<Sup>2</Sup><V>θ</V> − 1
-            <span style={{ padding: '0 1.2em' }} />
-            <V>F</V> ∝ 1/<V>R</V><Sup>4</Sup>
-          </Eq>
+          <BR/>
 
           <Para>
-            Measured over the whole of space by integrating the annihilation excess: <b>3cos²<V>θ</V> − 1 to three decimals</b> at every angle including both sign changes, <b>slope −2.00</b> on gravity's own 1/<V>R</V><Sup>2</Sup> so the force between two of them is 1/<V>R</V><Sup>4</Sup>, and all five orientations right — N–S facing, N–N facing, side by side either way, and one across the other giving nought to 10<Sup>−19</Sup>. That is magnetostatics, out of the same machinery that gave the rotation curve, with <b>nothing added to it</b>.
+            That is the strongest thing in this arc and it is worth being clear that it is a <i>direction</i> rather than a result. Nothing here builds the second label, and the model as it stands has one sign per ray and no room for another.
+          </Para>
+
+          <Head>and the wall, which is a theorem rather than a debt</Head>
+
+          <Para>
+            Everything above is one particle. The moment there are two, this model and quantum mechanics part company in a way that no amount of construction repairs, and it should be said flatly rather than left for a reader to find.
           </Para>
 
           <BR/>
 
           <Para>
-            It also says why <b>cutting a magnet gives two magnets</b> rather than two monopoles: the sign belongs to a region's boundary, so a new cut makes a new pair of faces. And ∇·<B>B</B> = 0 survives for the same reason — a body's two poles are the same emitters counted at both ends, so they are equal and opposite by construction.
+            A wavefunction of <V>N</V> particles lives on 3<V>N</V> coordinates. Everything in this book lives on <b>three</b> — occupancies on a lattice, one number per cell per tick, updated from its neighbours. That is a classical local field, and <Ref of={'Bell, "On the Einstein Podolsky Rosen paradox", Physics 1:195'} year="1964" at="https://doi.org/10.1103/PhysicsPhysiqueFizika.1.195" /> is a proof that no such thing reproduces the correlations that have since been measured. <b>This is not a gap in the derivation. It is a theorem against it</b>, and the model as written is on the wrong side of it.
           </Para>
 
-          <Head>the size, which is the one thing owed</Head>
+          <BR/>
 
           <Para>
-            The mechanism is settled and the <i>size</i> is not. First, it cannot come from the mass stream: if the biased pulses were a subset of the mass pulses the whole effect would be the (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>) factor, which runs 0 to 2, <b>so the most magnetism could ever be is one times gravity</b> — and two touching N52 cubes pull 2.2·10<Sup>12</Sup> times their own gravity. Settled, and cleanly: magnetism is its own layer with its own budget.
+            Three honest responses exist and none of them is cheap. Carry configuration space, which means the lattice is not space and the whole geometric reading of gravity goes with it. Deny measurement independence, which is available and which most people including me regard as too high a price. Or accept that the model is a single-particle theory that recovers Dirac, Schrödinger, Born and interference, and stops before entanglement. <b>The third is what this arc actually is</b>, and saying so is worth more than a fourth option invented to avoid it.
           </Para>
 
-          <Eq note="one emitter's moment, the scaling in the constituent, and the conversion the layer costs">
-            <K><Bar>MAGNETON</Bar></K> =
-            <Frac over={<><K><Bar>CYCLE</Bar></K>·<V>G</V></>} under={<>2<V>π</V></>} /> = 0.0794 <V>µ</V><Sub>B</Sub>
-            <span style={{ padding: '0 1.2em' }} />
-            <V>µ</V><Sub>max</Sub>/<V>M</V> ∝ 1/<V>m</V><Sup>2</Sup>
-            <span style={{ padding: '0 1.2em' }} />
-            <V>m</V><Sub>eff</Sub> = <V>q</V>√(<V>µ</V><Sub>0</Sub>/4<V>πG</V>) = 38.7 kg per A·m
-          </Eq>
+          <Head>the ledger</Head>
+
+          <Rows of={[
+            [<>what comes out</>,
+              <>The <b>Dirac equation</b> in 1+1D, as a coin and a shift with mass as the
+                turning rate. <b>Schrödinger</b> below it, with an inertial mass of
+                tan <V>m</V> rather than <V>m</V>. The <b>Born rule</b>, as the conserved
+                quantity being quadratic in the evolving one. <b>Interference</b>, which is
+                rule (G/1) unchanged — so polarity is the sign of the amplitude. That the
+                pull is already an expectation over a phase, so there is nothing to
+                quantise. That ħ, <V>c</V> and <V>G</V> are one grain, so there is no second
+                scale. And a which-path rate, <V>Γ</V> = <V>md</V>/<V>λ</V><Sup>2</Sup>,
+                derived rather than postulated.</>],
+            [<>what is assumed</>,
+              <>That a turn preserves how much ray there is — the rotation, which is the one
+                choice in the walk and the whole source of unitarity. And that the retarded
+                phase a place carries is the same object the matter wave is built from,
+                which is the two-slit fork above.</>],
+            [<>what is owed</>,
+              <>Two, and the second is larger than it looks. <b>A bound state whose emission
+                is a single train at the total rate</b> — molecular interferometry needs it
+                and composite gravity already assumes it. And <b>a second binary label</b>,
+                independent of polarity, which is simultaneously the complex phase and the
+                electric charge. The magnetism arc was already owing the second half of
+                that one.</>],
+            [<>what is refuted</>,
+              <>Lattice decoherence as the measurement mechanism — the rate is real and
+                10<Sup>35</Sup> times too slow. And the reading of cos <V>Ω</V> = cos{' '}
+                <V>m</V>·cos <V>k</V> as evidence of anything quantum: <b>the real coin
+                satisfies it identically</b>, and the two walks agree to exactly nought.</>],
+            [<>and what is walled off</>,
+              <>Entanglement, and with it measurement. Not owed — <b>excluded</b>. Everything
+                here is a field on three dimensions and a wavefunction of <V>N</V> particles
+                needs 3<V>N</V>, which is a theorem rather than a gap.</>],
+          ]} />
 
           <Para>
-            One emitter's ring has radius (<K><Bar>CYCLE</Bar></K>·<V>G</V>/2<V>π</V>)·<V>λ̄</V><Sub>C</Sub>, and <V>λ̄</V><Sub>C</Sub> goes as 1/<V>m</V>, so a <i>heavier</i> emitter is a <i>smaller</i> loop and per kilogram the moment goes as 1/<V>m</V><Sup>2</Sup> in whatever the body is made of. <b>The lightest constituent wins by the square</b> — which is the fact <V>µ</V><Sub>B</Sub>/<V>µ</V><Sub>N</Sub> = 1836 records, so the model derives that magnetism is electronic rather than assuming it.
+            So the arc ends better and worse than it started. Better, because the single-particle equations are genuinely there and were not put in: Dirac out of turning, Born out of counting, interference out of annihilation, and the amplitude-versus-probability worry dissolving into a regime boundary the model had already drawn — nine lines of one function, and nothing outside <V>λ</V><Sub>C</Sub> moves.
           </Para>
 
           <BR/>
 
           <Para>
-            And the conversion has no material in it, which is what makes it a bill rather than a fit: a 1 cm N52 cube must emit as if it weighed <b>four and a half tonnes</b>, six hundred thousand times its own mass. The ratio is not constant across magnets — it runs 6·10<Sup>3</Sup> to 6·10<Sup>5</Sup>, going as <V>M</V>/<V>ρL</V>, because <b>a pole is a surface and mass is a volume</b>. Divide the geometry out and what is left <i>is</i> constant: 4.5·10<Sup>7</Sup> kg/m² of pole face for saturated N52, one number reproducing all six geometries with no residual. <b>That number is the whole of what this arc owes</b>, and it is the same shape <V>a</V><Sub>0</Sub> was before <V>cH</V><Sub>0</Sub>/2π — a coupling waiting for a count.
+            Worse, because the two things I was most confident of did not survive contact. The <V>i</V> is a change of basis and buys nothing, and the wall at two particles is a proof rather than an absence. <b>What is left is a single-particle theory that recovers rather more than it had any right to and stops exactly where Bell says it must</b>, plus one debt — the second label — that the magnetism arc turns out to have been carrying under a different name the whole time.
           </Para>
 
           <BR/>
 
           <Para>
-            Because there is one ceiling, the budget is <i>shared</i>: pulses spent being a magnet are not being mass, so <b>magnetising a thing makes it lighter</b>, by exactly the fraction diverted. The cheap version of that is already dead — if the diverted fraction were the bulk bias itself, 1.5·10<Sup>−5</Sup>, a kilogram bar would lose 10 mg on being saturated, five orders above what a comparator would miss. So the magnetic layer's pulses are worth at least 10<Sup>14</Sup> gravitational ones, and that floor comes from a weighing rather than from a choice.
+            That debt is what the next arc pays, and it also overturns one thing settled here. <b>The <V>i</V> being a change of basis is true in one dimension and false in three</b>, for a reason this arc could not have seen: one dimension has no closed loops, and a phase on a hop is only physical when there is a loop for it to fail to cancel around. The negative result above stands exactly as far as it was measured, and no further.
+          </Para>
+        </Section>
+        <Section head="Layer 2: Charge, Phase and Matter">
+          <Para>
+            The last arc ended owing one thing — a second binary label, independent of polarity, which would be the complex phase and the electric charge at once — and the magnetism arc ended owing the same object under a different name. This arc builds it. <b>The proposal is that there is a second structure riding on the first: matter, as distinct from the emitters the first two arcs are made of, moving <i>through</i> Layer 1 rather than being part of it.</b> Charge is then not a property a thing carries. It is which way that thing runs relative to the grain of the field it is moving through.
           </Para>
 
-          <Head>and the three things this arc gets wrong</Head>
+          <BR/>
 
-          <Rows of={[
-            [<><V>g</V> = 1</>,
-              <>An emitter going round a loop at <K><Bar>c</Bar></K> has <V>µ</V> =
-                <V>qcr</V>/2 and <V>L</V> = <V>mcr</V>, so <V>µ</V>/<V>L</V> = <V>q</V>/2
-                <V>m</V> with the radius cancelling — the classical ratio. The electron's is
-                2.0023 to fourteen figures{' '}
-                <Ref of={'Hanneke, Fogwell & Gabrielse, "New Measurement of the Electron Magnetic Moment and the Fine Structure Constant", Phys. Rev. Lett. 100:120801'} year="2008" at="https://doi.org/10.1103/PhysRevLett.100.120801" />.
-                This one survives every choice, which makes it the sharpest.</>],
-            [<>the easy axis</>,
-              <>A held emitter puts + into every exit whose projection on its axis is
-                positive, and there are only <K><Bar>DEG</Bar></K> = 26 exits, so that split
-                is a <i>count</i>: 9 + / 8 equator / 9 − on a face or edge axis, 10 / 6 / 10
-                on a corner. So the model predicts ⟨111⟩ is the easy axis <b>by 11.1% in
-                every cubic material</b>. Right for nickel, wrong for iron, and flat where
-                measurement runs from 2.6% to 32%. A real prediction, in the right decade,
-                refuted in detail.</>],
-            [<><V>P</V> is not charge</>,
-              <>Emission rate goes as mass, so if the bias were electric charge a proton
-                would carry <b>1836 times</b> an electron's. Measurement has the two equal to
-                one part in 10<Sup>21</Sup>{' '}
-                <Ref of={'Baumann, Gähler, Kalus & Mampe, "Experimental limit for the charge of the free neutron", Phys. Rev. D 37:3107'} year="1988" at="https://doi.org/10.1103/PhysRevD.37.3107" />.
-                Whatever <V>P</V> is, it is not <V>q</V>, and everything here is read as
-                magnetism.</>],
-          ]} />
+          <Para>
+            What makes it worth writing down rather than merely saying is that the lattice turns out to have left exactly the right amount of room for it, and that three things the earlier arcs marked as refuted or owed come back as consequences.
+          </Para>
 
-          <Head>and the one number the whole thing owes</Head>
+          <Head>what layer 1 throws away</Head>
 
           <Para>
-            Every force in this model is second order in the emission — nothing happens to a charge that does not <i>meet</i> another charge — so the electric force is capped at the size of gravity, and measurement puts it 4.166·10<Sup>42</Sup> above. What is worth saying is that <b>the hierarchy itself is not the mystery</b>.
+            Start with a count that was already in the magnetism arc and was read as a curiosity. Take a cell with a local axis — the <i>north</i> a held emitter points along — and sort the <K><Bar>DEG</Bar></K> = 26 ways out of that cell by which side of the axis they fall on.
           </Para>
 
-          <Eq note="if the coupling were a count of order one where gravity is a product of two rates">
-            <Frac over={<V>α</V>} under={<>(<V>m</V><Sub>e</Sub>/<V>m</V><Sub>P</Sub>)<Sup>2</Sup></>} />
-            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
-            4.166·10<Sup>42</Sup>
-            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
-            <V>F</V><Sub>e</Sub>/<V>F</V><Sub>g</Sub>
-            <span style={{ padding: '0 1.2em', color: FAINT }}>measured</span>
+          <Eq note="and the equator of a face axis is exactly SHEET — a whole pulse's worth of directions the source cannot emit into">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`axis          +    equator    −
+⟨100⟩ face    9       8       9
+⟨110⟩ edge    9       8       9
+⟨111⟩ corner 10       6      10`}
+            </span>
           </Eq>
 
           <Para>
-            The gap is the mass in Planck units squared, which is the measured ratio to five figures because that is what those symbols mean. <b>The bill is exactly one number, <V>α</V></b>, and nothing here derives it. Of 117,649 lattice monomials searched, 51 land within half a percent of 137.036 — so a hit would not be evidence, and none is claimed.
+            The magnetism arc noticed the eight and called it "thrown away". <b>It is not thrown away. It is vacant</b>, and it is vacant in precisely the sense a second structure needs: eight directions, at every cell, that Layer 1's emission rule never touches. Anything built on them costs the gravity arc nothing — not a digit of <i><K><Bar>G</Bar></K></i>, not a term in met(<V>R</V>), not one of the numbers this book has already published — because the emission was never using them.
           </Para>
 
-          <Head>the divergence, in one place</Head>
-
-          <Rows of={[
-            [<>what changes locally</>,
-              <>Alike charges <i>turn</i> instead of annihilating, so their annihilation
-                happens half a wavelength back and several ticks later, against the
-                following wave rather than against each other. <b>The map of where space is
-                destroyed is different.</b></>],
-            [<>what changes globally</>,
-              <><i>share</i> ½ → 1 and the angular gate returns, so <V>G</V> doubles — and
-                masses are carried in units of <V>G</V>, so <b>nothing measurable moves at
-                all</b>.</>],
-            [<>what the signs buy</>,
-              <>The sign law (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>), which explains
-                the ½ that was already sitting unexplained inside <V>G</V>. Magnetisation
-                quantised in quarters. ∇·<B>B</B> = 0 and no monopoles. The dipole
-                3cos²<V>θ</V> − 1 and the 1/<V>R</V><Sup>4</Sup> force. That cutting a magnet
-                halves it. That the lightest constituent wins by the square.</>],
-            [<>what they cost</>,
-              <>One coupling — 4.5·10<Sup>7</Sup> kg/m² of pole face — measured rather than
-                counted. And three refutations: <V>g</V> = 1, the flat 11.1% anisotropy, and
-                that the bias cannot be electric charge.</>],
-            [<>what is not started</>,
-              <>The electric half, entirely: charge, <V>ε</V><Sub>0</Sub>, <V>α</V>, Faraday,
-                Ampère–Maxwell, the Lorentz force. Those need a model of matter <i>and</i> a
-                first-order channel, and neither exists — a force here is a <i>meeting</i>,
-                which is second order. That one fact is the whole of the missing column.</>],
-          ]} />
+          <BR/>
 
-        </Section>
-        <Section head="XOR Discrete Model">
-        </Section>
+          <Para>
+            And the eight are not a bag. Ordered by angle they close into a single ring at forty-five degrees a step, which is <K><Bar>CYCLE</Bar></K> = 8 and <K><Bar>SPIN</Bar></K> = 2π/<K><Bar>CYCLE</Bar></K>, both of which have been sitting in <i>lattice.ts</i> since the magnetism arc needed a source to come back round.
+          </Para>
 
-        <Section head="TODO2">
+          <Eq note="the equator of a face axis, in cyclic order — a discrete U(1), already in the model under another name">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`(1,0) → (1,1) → (0,1) → (−1,1) → (−1,0) → (−1,−1) → (0,−1) → (1,−1) → back`}
+            </span>
+          </Eq>
 
-          <Head>the same emission, with the signs kept</Head>
+          <Head>an axis, a ring, and what each of them is</Head>
 
           <Para>
-            Everything in the gravity arc counts <i>one</i> thing about an emitter: how often it lets go. That is mass. But a source has a second property that has nothing to do with the first — <b>which way round it is when it does</b> — and the gravitational half never once looked at it. Keep the signs instead of throwing them away and the very same emission answers a different question.
+            So a cell offers a Layer-2 strand two independent things, and this is the whole construction:
           </Para>
 
-          <BR/>
+          <Rows of={[
+            [<>along the axis</>,
+              <>Which way the strand advances — <i>with</i> the local north or{' '}
+                <i>against</i> it. Two states, no in-between, because a step is one cell a
+                tick and there is no such thing as running three-tenths against the grain.
+                <b> This is the charge.</b></>],
+            [<>around the ring</>,
+              <>Where on the eight-step equator the strand sits as it advances. A helix, not
+                a line. <b>This is the phase</b>, and it is a genuine U(1) with a quantum of
+                45°.</>],
+          ]} />
 
           <Para>
-            I want to say what that question is before going any further, because it is narrower than the section title suggests. There is no account of <i>matter</i> in this model, so nothing here says what an electron or a positron would be, and the electric half — charge, how matter interacts with it — is not attempted. What the signs give is a <b>bias</b>, and a bias is magnetism.
+            The two do not interfere with each other — a direction relative to an axis splits into a sign along it and an azimuth around it, and those are independent for any axis. So the model gets a <i>quantised</i> charge and a <i>continuous</i> phase out of one geometric object, which is the combination it has been unable to produce anywhere else.
           </Para>
 
-          <Eq note="one emission, two moments of it — the count is mass, the signed first moment is a bias">
-            <V>m</V> = ⟨1⟩<span style={{ padding: '0 1.6em' }} />
-            <V>q</V> = ⟨<V>s</V>⟩<span style={{ padding: '0 1.6em' }} />
-            <V>µ</V> = ⟨<V>s</V> <V>d̂</V>⟩
-          </Eq>
+          <BR/>
 
           <Para>
-            Which is why the two behave so differently, and it is not a coincidence. <b>A count always adds</b>, so gravity has one sign and cannot be screened. <b>A signed sum cancels</b>, so a bias comes in two kinds and ordinary matter has none of it while still having all of its mass.
+            <b>And it settles the oldest objection in the magnetism arc immediately.</b> That arc had to conclude the bias was not electric charge, because emission goes as mass, so a bias read off the emission would give a proton 1836 times an electron's charge where measurement has them equal to one part in 10<Sup>21</Sup>. It also wrote down the escape and could not take it: <i>a count would escape that, since a count is not a rate — but the model has no matter in it to say how many.</i>
           </Para>
 
-          <Head>four emitters, and each of the four is something</Head>
-
-          <Kinds />
+          <Eq note="two different kinds of number, which is why they were never going to track each other">
+            <i><Bar>m</Bar></i> = pulses per tick ∈ [0, 1]
+            <span style={{ padding: '0 1.2em', color: FAINT }}>a rate</span>
+            <V>q</V> = net traversal sense ∈ {'{'}…, −1, 0, +1, …{'}'}
+            <span style={{ padding: '0 1.2em', color: FAINT }}>a count</span>
+          </Eq>
 
           <Para>
-            A source has exactly two switches and they are independent: whether it has <i>sides</i> (an axis) and whether it <i>comes round</i> (turns, or flips). Crossing them gives four distinguishable emissions — nothing signed at all, one sign in every direction, nothing signed again, and + out of one side with − out of the other. That much is structure, and it was not arranged for.
+            Layer 2 <i>is</i> the matter that arc said it did not have. A proton is heavy because its Layer-1 emission rate is high and singly charged because its net Layer-2 traversal is one, and <b>there is no mechanism by which those two could have been proportional</b>. The 1836 stops being a refutation and becomes a statement that mass and charge live on different layers.
           </Para>
 
-          <BR/>
+          <Head>a positron is an electron against the grain</Head>
 
           <Para>
-            What those four <i>are</i> is a different question and I am not going to pretend to answer it. Calling the second an electric charge and the fourth a magnet is a guess — reasonable, and not earned — so the panel says what each one emits and stops. Everything below concerns the fourth, which is a bias.
+            Which gives the reading this arc is named for. There is one kind of strand. An electron is one running with the grain and a positron is the same strand running against it, and <i>charge conjugation is a reversal of traversal</i> — a local, geometric operation on the lattice rather than an internal label being negated by hand.
           </Para>
 
           <BR/>
 
           <Para>
-            And whatever they turn out to be, <b>none of them can be a sided source with a net</b>: there is no way to be sided without having two sides. Checked over twenty thousand axes, the net emission is exactly nought every time, because the lattice's exits come in ± pairs so a direction and its opposite always get opposite signs. That is ∇·<V>B</V> = 0 and the absence of monopoles — a symmetry electromagnetism <i>observes</i>, and this model cannot avoid.
+            Two things follow that were not aimed at. The first is that <b>charge conservation stops being a law</b>. You cannot make a lone traversal sense any more than you can make a lone end of a piece of string: a strand created in the vacuum has a with-the-grain piece and an against-the-grain piece by construction, which is pair production, and the conservation is a statement about orientation rather than a bookkeeping rule imposed on top.
           </Para>
 
-          <Head>a magnet is a lopsided default, not a stopped one</Head>
+          <BR/>
 
           <Para>
-            The constraint that decides this whole section is that <b>a magnet still has to pulse its weight</b>. The two clocks are independent — <K>beat</K> = 1/<V>m</V> is how often it lets go, <K>rate</K> is how fast its axis comes round — so magnetising a thing cannot change what it weighs, and an emitter never has to stop. Both go on at once, and the magnet is the amount by which the alternation fails to come out even.
+            The second is finer and is the reason I believe the picture. Reverse the direction of advance and keep the winding fixed in space, and the winding is now the other way round <i>relative to the direction of travel</i>. <b>So C flips helicity, automatically</b> — a left-handed strand with the grain is a right-handed strand against it, which is what charge conjugation does to a real particle and which nothing here was arranged to produce.
           </Para>
 
-          <Eq note="a lopsided default, not a stopped one — and dwell is a count of ticks, so P is quantised">
-            <V>P</V> = 2·<K>dwell</K> − 1,<span style={{ padding: '0 1.2em' }} />
-            <K>dwell</K> = <V>k</V>/<K>CYCLE</K><span style={{ padding: '0 1.2em' }} />
-            ⇒ <V>P</V> ∈ {'{'}0, ¼, ½, ¾, 1{'}'}
-          </Eq>
-
-          <Lopsided />
+          <Head>and the phase is not removable this time</Head>
 
           <Para>
-            <K>dwell</K> is a count of ticks, so the smallest magnetisation a single emitter can carry is 2/<K>CYCLE</K> = <b>a quarter</b>. Magnetisation comes in units, with nothing free in it. Against that, a saturated neodymium magnet measures <V>P</V> = 1.51·10<Sup>−5</Sup> in bulk: <b>99.9985% of what it emits cancels</b>, and what a magnet <i>is</i> is the fifteen parts per million that failed to.
+            Now the objection the previous arc raised against itself, because it has to be answered and the answer is what makes Layer 2 more than a relabelling. That arc found the <V>i</V> in the Dirac walk to be a change of basis — <V>D</V> = diag(1, <V>i</V>) turns the complex coin into a real one and commutes with the shift, and the two walks agree to exactly nought. So why is this phase different?
           </Para>
 
           <BR/>
 
           <Para>
-            The count behind that is a check rather than a fit, and worth spelling out because it is the only place the two halves of the model touch a laboratory. It is a measured remanence divided by a measured <V>µ</V><Sub>B</Sub>, read against the moment per atom measured a different way — iron <b>2.17</b> against 2.22, cobalt 1.69 against 1.72, nickel 0.57 against 0.61, Nd<Sub>2</Sub>Fe<Sub>14</Sub>B 29.8 against about 32. So whatever carries magnetisation has an electron's moment and an electron's abundance, in four materials at once. <b><V>µ</V><Sub>B</Sub> and the electron are inputs here, not results.</b>
+            <b>Because that result was a fact about one dimension, and I checked it the wrong way round.</b> Run the walk with a uniform azimuthal advance θ on a line and the effect is precisely zero — measured, at every θ tried — and that is not a failure of the idea, it is the statement that on a chain with no closed loops a phase on the hop is pure gauge and can be undone by ψ(<V>x</V>) → <V>e</V><Sup>iθ<V>x</V></Sup>ψ(<V>x</V>). One dimension has no plaquettes. There was nothing there for the <V>i</V> to be.
           </Para>
 
-          <Head>the sign law was already inside G</Head>
+          <BR/>
 
           <Para>
-            Here is the thing I did not expect. <K><Bar>G</Bar></K>'s derivation carries a factor it has never had to justify: <i>half of them opposite</i>. That half is the chance two charges landing in the same cell have opposite sign — and it is not a constant, it is a fact about the matter involved. Half is what you get when both bodies are unbiased. Ordinary matter is unbiased. <b>That is the whole reason it ever looked like a number.</b> Put the bias back and the sign law falls out with no new rule at all.
+            Three dimensions do have plaquettes, and the local axis is not uniform — a magnetic texture is exactly a north that turns as you move. Carry a strand around a closed loop and the azimuthal advances do not cancel; what is left is the solid angle the axis swept, and a site-by-site phase redefinition cancels around any closed loop and so cannot touch it.
           </Para>
 
-          <Eq note="like biases attract less, opposite attract more — and at P = 0 it is Newton exactly">
-            <V>F</V> = <Frac
-              over={<><K>G</K> <V>m</V><Sub>a</Sub> <V>m</V><Sub>b</Sub></>}
-              under={<><V>R</V><Sup>2</Sup></>} />
-            <span style={{ padding: '0 0.5em' }} />
-            (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)
+          <Eq note="a twisting Layer-1 axis, four plaquettes — the holonomy is the swept solid angle, and it is gauge-invariant">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`plaquette      solid angle    flux Φ = Ω/2
+(0,0) 1×1       −6.997e−2      −3.498e−2
+(1.5,0.7)        7.816e−3       3.908e−3
+(0,0) 2×2       −1.043e−1      −5.214e−2
+(3,3)           −9.061e−2      −4.530e−2`}
+            </span>
           </Eq>
 
           <Para>
-            Read off the split: unbiased against unbiased is one half and one half, which <i>is</i> the ½ in <K><Bar>G</Bar></K>, so Newton is the <V>P</V> = 0 case and not a separate claim. Biased against unbiased is also one half — a bias does nothing to something with no bias of its own, which comes out of the arithmetic rather than being put in by hand. Same bias gives nought, opposite bias gives twice. <b>Opposites attract and sameness repels, derived</b>, which is where this whole idea started.
+            <b>So the complex structure is forced by the existence of closed loops, and not before.</b> The previous arc's negative result stands exactly as far as it was measured — one dimension — and stops being general the moment the lattice is allowed to be three-dimensional and the axis is allowed to turn. That is also the Aharonov–Bohm statement, arrived at as a lattice-counting fact: the phase around a loop is a thing about the loop, and the choice of where azimuth zero sits is unobservable because <b>the equator has no marked point on it</b>. Gauge invariance is that absence.
           </Para>
 
-          <BR/>
+          <Head>minimal coupling, which nobody put in</Head>
 
           <Para>
-            Which is worth stopping on: <b>the gravitational constant carries a factor of one half because ordinary matter is unbiased.</b> If matter had a net bias, <V>G</V> would be a different number. The half was already there and unexplained; this is what it was — and that needs no reading whatever of what the bias <i>is</i>.
+            Feed the azimuthal advance into the walk of the previous arc and the dispersion does one thing, cleanly. The advance per axial step enters as a shift of the momentum, and nothing else changes.
           </Para>
 
-          <Head>and where the bias lives decides everything</Head>
+          <Eq note="p → p − θ, with θ the azimuthal advance — and the two real sectors are exactly j = 0 and j = CYCLE/2">
+            cos <V>Ω</V> = cos <V>m</V> · cos(<V>k</V> − θ)
+            <span style={{ padding: '0 1.2em', color: FAINT }}>with</span>
+            θ = 2π<V>j</V>/<K><Bar>CYCLE</Bar></K>
+          </Eq>
 
           <Para>
-            There are two places the bias could sit and only one of them is a magnet, and getting that wrong cost me a long time. Put it on a <i>direction</i> — one emitter, + out of its north half and − out of its south, from a single place — and it fails: pole to pole gives <b>exactly nothing</b>, by an exact cancellation, and the fall-off is 1/<V>R</V><Sup>2</Sup> where two magnets are 1/<V>R</V><Sup>4</Sup>. Giving the emitter a ring does not rescue it, at any phase.
+            <b>That is minimal coupling</b>, which in every other treatment is a rule about how to put a field into a wave equation and here is what a helix does. Six of the eight sectors carry a group velocity at <V>k</V> = 0; the two that do not are <V>j</V> = 0 and <V>j</V> = 4, the two whose phases are +1 and −1 — <i>the real ones</i>. So the lattice says which sectors could have been done without complex numbers, and it is two out of eight.
           </Para>
 
-          <BR/>
+          <Head>and the force, measured</Head>
 
           <Para>
-            Put it on a <i>place</i> and everything works. A bar magnet is then a lump biased + at one end and − at the other — net zero because the two ends cancel, <b>separated in space rather than in direction</b> — which is what magnetostatics has always called the pole model. Nothing else changes: the same <K>chance</K>, the same co-location rule, the same (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>)/2 XOR whose unbiased case is the half inside <K><Bar>G</Bar></K>.
+            Then the claim that started this arc, put to the walk directly. Let the azimuthal advance ramp — θ(<V>t</V>) = <V>gt</V>, which is a vector potential growing in time and therefore a constant field — and run the same strand with the grain and against it.
           </Para>
 
-          <Fields />
-
-          <Pairs />
+          <Eq note="one object, two traversal senses, the same Layer-1 texture — and the norm is conserved exactly throughout">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`  g       ⟨x⟩ with grain   ⟨x⟩ against    separation
+0.000         −47.94         −47.94         0.00
+0.001         −45.70         −49.27         3.58
+0.002         −41.43         −50.15         8.72
+0.004         −20.99         −51.22        30.23
+0.008          11.59         −52.07        63.66`}
+            </span>
+          </Eq>
 
           <Para>
-            Measured over the whole of space, by integrating the annihilation excess: <b>3cos²<V>θ</V> − 1 to three decimals</b> at every angle including both sign changes, <b>slope −2.00</b> on gravity's own 1/<V>R</V><Sup>2</Sup> so the force between two of them is 1/<V>R</V><Sup>4</Sup>, and all five orientations right — N–S facing, N–N facing, side by side either way, and one across the other giving nought to 10<Sup>−19</Sup>. That is magnetostatics, out of the same machinery that gave the rotation curve, with <b>nothing added to it</b>.
+            <b>They go opposite ways, and the separation grows as the square of the time</b>, which is what a force does rather than what a drift does. At <V>g</V> = 0.008 the with-the-grain strand has been turned all the way round and is moving the other way while the against-the-grain one carries on. Nothing was added to the walk to arrange this — the ramp is the field, the traversal sense is the charge, and the acceleration is the two of them multiplied, which is the Lorentz force with its sign.
           </Para>
 
-          <BarField />
+          <BR/>
 
           <Para>
-            And the field lines there are integrated from the model's own signed emission — Σ sign·<K>SHEET</K>/4π<V>r</V><Sup>2</Sup> over the two pole faces — rather than from a textbook formula. They come out as a dipole because that sum <i>is</i> a dipole, which is the whole of the point.
+            One honest note on how that number was got, because two earlier versions of the measurement said the effect was zero. A strand with no momentum, or with a real amplitude, is mapped to itself by the conjugation that swaps the two traversal senses, so the two are forced equal by symmetry and no value of <V>g</V> separates them. <b>The charge needs something to be asymmetric about before it shows.</b> That is not an artefact of the test; it is the reason a charge at rest in no field is not observably a charge.
           </Para>
 
-          <BR/>
+          <Head>the g-factor the arc had given up on</Head>
 
           <Para>
-            It also says why <b>cutting a magnet gives two magnets</b> rather than two monopoles: the sign belongs to a region's boundary, so a new cut makes a new pair of faces. And ∇·<V>B</V> = 0 survives for the same reason — a body's two poles are the same emitters counted at both ends, so they are equal and opposite by construction.
+            The magnetism arc lists <V>g</V> = 1 as its sharpest refutation, against a measured 2.0023, and says the ratio survives every choice because µ/<V>L</V> = <V>q</V>/2<V>m</V> with the radius cancelling. It also found where a two could live and then declined to take it:
           </Para>
 
-          <Head>scale is not the problem</Head>
-
-          <Ceiling />
+          <Eq note="the lattice's own double cover — the observable turning twice as fast as the state, which is what a spinor is">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`a directed north returns after    CYCLE = 8 steps   (2π)
+an undirected axis returns after CYCLE/2 = 4 steps (π)`}
+            </span>
+          </Eq>
 
           <Para>
-            One emitter's ring has radius (<K>CYCLE</K>·<K>G</K>/2<V>π</V>)·<V>λ̄</V><Sub>C</Sub>, and <V>λ̄</V><Sub>C</Sub> goes as 1/<V>m</V>, so a <i>heavier</i> emitter is a <i>smaller</i> loop. Per kilogram the moment therefore goes as 1/<V>m</V><Sup>2</Sup> in whatever the body is made of, so <b>the lightest constituent wins by the square</b>. That is a scaling law and not a claim about what emitters are — what it buys is that if a body has light and heavy ones, the light ones carry the magnetism, which is the fact <V>µ</V><Sub>B</Sub>/<V>µ</V><Sub>N</Sub> = 1836 records.
+            The reason it declined is stated exactly: <i>emission tracks north and not the axis, so as written the model gives one, and taking the two would be changing the emission rule — a change and not a consequence.</i>
           </Para>
 
           <BR/>
 
           <Para>
-            And a big body screens itself, so only a skin gets out and the aggregate is an <i>area</i> law rather than a volume one. Run backwards against what is measured, a fully aligned skin of <b>4.5 mm carries the whole of the Earth's field</b>, 3.9 m the Sun's, and 0.16 µm a neutron star's. Nothing anywhere reaches 10<Sup>−4</Sup> of the ceiling. <b>Scale is not what stops this</b>, at any size from an electron to a magnetar — which is a null result in the useful direction.
+            <b>With two layers it is no longer a change to the emission rule, because the axis and the north are no longer the same object.</b> North belongs to Layer 1 and is what emits; the axis is what a Layer-2 strand winds around, and it is undirected because a ring has no preferred sense until a traversal picks one. The observable turns twice per turn of the state because the two things doing the turning live on different layers. So <V>g</V> = 2 is available here for the reason the arc identified and could not use, and <b>it is the sharpest test this proposal has</b> — the 0.0023 is not claimed and would want the coupling that is still owed.
           </Para>
 
-          <Head>and how many pulses that takes</Head>
+          <Head>matter, and the debt it pays</Head>
 
           <Para>
-            The mechanism is settled and the <i>size</i> is not, so it is worth asking the question the gravitational half answered: how much emission does a magnet actually need? First, it cannot come from the mass stream. If the biased pulses were a subset of the mass pulses, the whole effect would be the (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>) factor, which runs 0 to 2 — <b>so the most magnetism could ever be is one times gravity</b>, the pull switched off or doubled and nothing further. Two touching N52 cubes pull 2.2·10<Sup>12</Sup> times their own gravity. That is settled, and cleanly: magnetism is its own layer.
+            The quantum arc ended owing one load-bearing thing: a bound state whose emission is a <i>single train at the total rate</i>, because molecular interferometry needs the de Broglie phase to run on the whole molecule's mass and composite gravity already assumes the rates add. No rule in the first two arcs produces it, for the good reason that those arcs have no matter in them — only emitters.
           </Para>
 
           <BR/>
 
           <Para>
-            So it has its own budget, and the budget is a number. Equating the two channels gives one conversion with no material in it — <V>m</V><Sub>eff</Sub> = <V>q</V>·√(<V>µ</V><Sub>0</Sub>/4<V>π</V><K>G</K>) = 38.7 kg per A·m — so a 1 cm N52 cube must emit as if it weighed <b>four and a half tonnes</b>, six hundred thousand times its own mass.
+            Layer 2 pays it in the natural way. If a cell's Layer-1 emission rate is set by <b>how much Layer 2 is in that region</b> rather than by each strand separately, then a region containing <V>N</V> strands emits one train at the summed rate whatever the strands are individually doing. The de Broglie phase reads the aggregate rate and comes out at <V>h</V>/<V>Mv</V>; <K>share</K> reads the relative offset, which is a sum of <V>N</V> unrelated ones and stays at a half. <b>The rate is collective and the offset is not</b>, which is exactly the split that arc needed and could not motivate.
           </Para>
 
           <BR/>
 
           <Para>
-            And the ratio is not a constant, which is the informative part: it runs 6·10<Sup>3</Sup> to 6·10<Sup>5</Sup> across six magnets, going as <V>M</V>/<V>ρL</V>, because <b>a pole is a surface and mass is a volume</b>. Divide the geometry out and what is left <i>is</i> constant — 4.5·10<Sup>7</Sup> kg/m² of pole face for saturated N52, one number reproducing all six geometries with no residual. What sets that number is the open question, and it is the same shape as <V>a</V><Sub>0</Sub> was before <V>cH</V><Sub>0</Sub>/2π: a coupling waiting for a count.
+            And it says what matter <i>is</i> in a way the book has not been able to before: not a heavy emitter, but a strand threading a region and setting how hard that region emits. Mass is what Layer 2 does to Layer 1. Charge is what Layer 2 does relative to Layer 1. <b>The two arcs were describing the same object from opposite sides.</b>
           </Para>
 
-          <BR/>
+          <Head>and the amplitude fix, which now has something to be</Head>
 
           <Para>
-            And because there is one ceiling, the budget is <i>shared</i>: pulses spent being a magnet are not being mass, so <b>magnetising a thing makes it lighter</b>, by exactly the fraction diverted. Which is a prediction that can be shot at — and the cheap version of it is already dead, because if the diverted fraction were the bulk bias itself, 1.5·10<Sup>−5</Sup>, a kilogram bar would lose 10 mg on being saturated, five orders above what a comparator would miss. So the magnetic layer's pulses are worth at least 10<Sup>14</Sup> gravitational ones, and that floor comes from a weighing rather than from a choice.
+            The quantum arc proposed one narrow change — <K>opposed</K>(<V>ψ</V>) = |<V>ψ</V>|/π should be (1 − cos <V>ψ</V>)/2 inside the coherent regime — and could only justify it by analogy with a Born rule. Here <V>ψ</V> stops being an abstract phase difference: it is the difference of two azimuths on the eight-step ring, so it takes the values 45°·<V>k</V> and the kernel is evaluated on a lattice quantity like everything else in the book.
           </Para>
 
-          <Head>and the one number the whole thing owes</Head>
+          <Eq note="the same nine-line change as before, with the phase now identified as an equatorial index">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`opposed(ψ) = (1 − cos ψ)/2,    ψ = 2π(k_a − k_b)/CYCLE`}
+            </span>
+          </Eq>
 
-          <Ladder />
+          <Head>what this does not reach</Head>
 
           <Para>
-            Every force in this model is second order in the emission — nothing happens to a charge that does not <i>meet</i> another charge — so the electric force is capped at the size of gravity, and measurement puts it 4.166·10<Sup>42</Sup> above. What is worth saying is that <b>the hierarchy itself is not the mystery</b>. <i>If</i> the coupling were a count of order one where gravity is a product of two rates, the gap would be the mass in Planck units squared: <V>α</V>/(<V>m</V><Sub>e</Sub>/<V>m</V><Sub>P</Sub>)<Sup>2</Sup> = 4.166·10<Sup>42</Sup>, which is the measured ratio to five figures. <b>The bill is exactly one number, <V>α</V></b>, and nothing here derives it. Of 117,649 lattice monomials searched, 51 land within half a percent of 137.036 — so a hit would not be evidence, and none is claimed.
+            Two things, said plainly so the arc is not read as claiming more than it has. <b>Entanglement is untouched.</b> A second layer gives more field components at each cell, and Bell's theorem is about the number of <i>coordinates</i>, not components — two layers on a three-dimensional lattice is still three dimensions, and a wavefunction of <V>N</V> particles still needs 3<V>N</V>. Layering does not get near that wall and nothing here pretends to.
           </Para>
 
           <BR/>
 
           <Para>
-            And the bias is not electric charge, which is sharper than the factor and has to be answered first. Emission rate goes as mass, so if charge were the signed emission rate a proton would carry <b>1836 times</b> an electron's, where measurement has the two equal to 10<Sup>−21</Sup>. Whatever <V>P</V> is, it is not <V>q</V>.
+            And <b>the coupling is still one number</b>. Layer 2 says what charge <i>is</i> and gives it the right structure — quantised, integral, independent of mass, conserved by orientation, coupling minimally, accelerating the two senses oppositely — and it does not say how strongly. <V>α</V> is owed exactly as it was, and the magnetism arc's 4.5·10<Sup>7</Sup> kg/m² of pole face is owed with it. What has changed is that they are now one debt rather than two.
           </Para>
 
-          <Head>the audit</Head>
+          <Head>the ledger</Head>
 
           <Rows of={[
             [<>what comes out</>,
-              <>The 1/<V>r</V><Sup>2</Sup>, as flux over a growing shell — exactly{' '}
-                <K>SHEET</K> = 8 through any sphere, to the last digit. The sign law, for a
-                bias. Two signs that cancel. A ± ledger that balances, which is what{' '}
-                <K>BITE</K> = 1 exists for. Magnetisation quantised in quarters. ∇·<V>B</V> = 0
-                and the absence of monopoles. That the lightest constituent wins by the
-                square. Superposition. The dipole angular law 3cos²<V>θ</V> − 1, the
-                1/<V>R</V><Sup>4</Sup> force, all five orientations, and that cutting a magnet
-                halves it. <b>Thirteen of twenty-nine.</b></>],
+              <><b>Charge as a count</b> rather than a rate, which retires the 1836 the
+                magnetism arc could not answer. <b>Charge conservation</b>, as orientation
+                rather than as a rule. <b>C flipping helicity</b>, for free. <b>Minimal
+                coupling</b>, as what a helix does to a dispersion. <b>The force</b>, measured
+                — two traversal senses accelerating oppositely through one texture, going as
+                <V> t</V><Sup>2</Sup>. And a route to <b><V>g</V> = 2</b> that the magnetism
+                arc had located and could not take.</>],
+            [<>what is fixed that was broken</>,
+              <>The previous arc's finding that the <V>i</V> is a change of basis — true in
+                one dimension, where there are no plaquettes, and <b>false as soon as the
+                axis is allowed to turn</b>. The holonomy is a swept solid angle and no
+                site-local phase touches it.</>],
             [<>what is assumed</>,
-              <><K>LIGHT</K> = 1 is an axiom rather than a result, so <V>c</V> being finite
-                and universal is built in — and with it, that radiation exists at all.</>],
+              <>That Layer 1's emission is sourced by a region's total Layer-2 content rather
+                than strand by strand. It is what pays the bound-state debt, and it is a
+                choice.</>],
             [<>what is owed</>,
-              <>One number: <b>the magnetic coupling</b>, the 4.5·10<Sup>7</Sup> kg/m² of
-                pole face. Measured, not counted. Everything else here follows once it is
-                fixed.</>],
-            [<>what is not started</>,
-              <>The electric half, entirely: charge, <V>ε</V><Sub>0</Sub>, <V>α</V>, Faraday,
-                Ampère–Maxwell, the Lorentz force. Those need a model of matter <i>and</i> a
-                first-order channel, and neither exists — a force here is a <i>meeting</i>,
-                which is second order. That one fact is the whole of the missing column.</>],
-            [<>and what is refuted</>,
-              <><V>g</V> = 1, where the electron's is 2.0023 — and that one survives every
-                choice, since <V>µ</V>/<V>L</V> = <V>q</V>/2<V>m</V> with the radius
-                cancelling out. The anisotropy predicts ⟨111⟩ by 11.1% in every cubic
-                crystal, which is right for nickel, wrong for iron, and flat where
-                measurement runs from 2.6% to 32%. And a magnet cannot be made of{' '}
-                <i>sided</i> emitters, however they are ordered.</>],
+              <>The coupling — <V>α</V>, and the pole-face number with it. One debt now
+                instead of two, and nothing here derives it.</>],
+            [<>and what is walled off</>,
+              <>Entanglement, exactly as before. Layers add components, not coordinates.</>],
           ]} />
 
-          <Head>where the poles come from, which is not settled</Head>
+          <Para>
+            So the shape of the thing is: the lattice had eight directions per cell that its own emission rule could not use, and they form a ring; putting matter on that ring gives a charge that is a count, a phase that is a genuine U(1), a force with the right sign, and a spinor's double cover — and it costs the first two arcs nothing, because they were never using those directions. <b>Three of the four things this book had written off come back as consequences of one structure.</b> The fourth is entanglement, and that one is a theorem.
+          </Para>
+        </Section>
+        <Section head="Entanglement, and the Coupling">
+          <Para>
+            The last arc ended owing two things and called one of them a theorem. They are different kinds of problem and they want different kinds of work: one is a question about what sort of object the lattice is, and the other is a question about a number. This arc takes both as far as they go, which in one case is further than expected and in the other is mostly a matter of establishing what is actually owed.
+          </Para>
+
+          <Head>what Bell actually forbids, and the five ways out</Head>
 
           <Para>
-            A magnet needs its bias on a place, and something has to <i>put</i> it there. The natural answer is ordering: emitters pointed the same way and held there, so inside the body every + has a − sitting on it and at a face it does not. <b>Measured, that happens</b> — the signed emission is nought in the middle of a cylinder and largest at its ends.
+            The theorem is not "no hidden variables". It is that <i>local</i> hidden variables, with settings chosen independently of them, cannot reproduce the measured correlations. So there are exactly five doors, and it is worth naming all of them before picking one, because the model rules three out on its own.
           </Para>
 
-          <BR/>
+          <Rows of={[
+            [<>nonlocal dynamics</>,
+              <>Bohm's route. It wants a preferred foliation, which is normally the objection
+                to it — and <b>this model has already paid that price</b>, since a lattice
+                with a global tick and a frontier at <V>R</V> = <V>ct</V> has a preferred
+                frame for reasons that have nothing to do with Bell. It still fails, because
+                the guiding field lives on 3<V>N</V> coordinates and the lattice has three.</>],
+            [<>retrocausality</>,
+              <>The setting influences the past <i>along the particle's own worldline</i>.
+                Local in spacetime, no superluminal signal, no preferred frame required.
+                <b> This is the one the model is already built for</b>, and the next head
+                says why.</>],
+            [<>superdeterminism</>,
+              <>Available and declined, on the same grounds as before: it buys the
+                correlations by making the settings conspire, which explains everything and
+                so predicts nothing.</>],
+            [<>many outcomes</>,
+              <>Costs the wavefunction on configuration space anyway, so it does not help a
+                lattice that has not got one.</>],
+            [<>be quantum mechanics</>,
+              <>Carry amplitudes on 3<V>N</V>. Then the lattice is not space and the whole
+                geometric reading of gravity goes with it, which is most of this book.</>],
+          ]} />
+
+          <Head>the lattice has no arrow, and that is not a small thing</Head>
 
           <Para>
-            And it still does not make a magnet. Axial, radial and cylindrical orderings all give a far field falling as 1/<V>r</V><Sup>2</Sup> where a magnet is 1/<V>r</V><Sup>3</Sup>, because <b>the cancellation is a near-field fact</b>: a distant body does not see neighbours cancelling, it sees every emitter's chosen side at once. The sign of a sided emitter's pulse is decided by where the observer <i>is</i>, so the sides add instead of cancelling.
+            Here is the fact that makes the second door the natural one rather than a convenient one. <b>(G/1) and (G/2) are exact inverses.</b> Annihilation takes two rays to a neutral point; creation takes a neutral point to two rays; they are drawn at the head of the gravity arc as the same picture run each way. Nothing in the rules distinguishes a direction of time.
           </Para>
 
           <BR/>
 
           <Para>
-            Which turns the open question into one line of the source. <K>emission</K> is <code>sided ? along() : cos(2πβ)</code>, and <K>along</K> resolves the direction against the axis <i>at the destination</i>. A pulse whose polarity were fixed <b>when it left</b> would carry it, the near-field cancellation would survive to infinity, and the faces would be poles. So: <b>is a pulse's sign fixed when it leaves, or when it arrives?</b> Nothing else about the mechanism changes either way, which makes it the cheapest open question on the page.
+            A dynamics whose rules are time-symmetric is not naturally an <i>initial-value</i> problem. It is naturally a <b>boundary-value</b> problem — fix what is true at both ends and the history is whatever is consistent with both — and reading it that way is not a modification of this model, it is reading the rules the way they were written. Every arc so far has quietly assumed the initial-value reading because that is how one runs a simulation, and nothing in the rules asked for it.
           </Para>
 
-          <BR/>
+          <Head>which turns the question into one the book already has open</Head>
 
           <Para>
-            So the honest sentence here is the opposite shape to the gravitational one. There, the scale came out unfitted and the structure was the fight. Here it is the other way round: <b>the whole structure of magnetostatics comes out of the same XOR that gave gravity</b>, and the one thing it owes is the scale. <b>Magnetostatics derived, its coupling owed, and electric charge not started.</b>
+            Now put Layer 2 into that reading. A strand is a helix threading from where it was made to where it is absorbed, and its azimuth is discrete — eight steps, <K><Bar>CYCLE</Bar></K>. So the helix must close over its length by a <i>whole number</i> of steps. That is a global condition on an integer, and a setting at the absorbing end participates in fixing it.
           </Para>
 
-          <Head>and the same theory with the XOR turned off</Head>
+          <BR/>
 
           <Para>
-            Which is worth asking because it makes this a <i>family</i> rather than a single thing. Take the polarity away — no signs, no opposites, just discrete directions, and a meeting counted when two charges come at each other head on. Does gravity notice?
+            <b>And that is the question the magnetism arc ended on, asked about a different layer.</b> That arc closed with: <i>is a pulse's sign fixed when it leaves, or when it arrives?</i> — and needed the answer <i>when it leaves</i>, because a pulse whose polarity is fixed at emission carries the near-field cancellation to infinity and gives a magnet its poles. Bell needs the opposite answer: a winding fixed at <i>both</i> ends.
           </Para>
 
           <BR/>
 
           <Para>
-            Two things change in the rules and they pull opposite ways. The <b>share</b> goes from ½ to 1, because every meeting now annihilates where before only the opposite ones did. And the <b>angular gate comes back</b> — with no sign to decide the outcome there is nothing left but the angle, so <K>closing</K> returns and the folding is bounded to a lens again.
+            Which would be a flat contradiction in a one-layer model and is not one here. <b>Layer 1's polarity is fixed when it leaves; Layer 2's winding is fixed by both of its ends.</b> They are different quantities on different layers, and the only reason the question looked like it had to have one answer is that until this arc there was only one thing it could be asked about. That the two open questions want opposite answers is, on this reading, an argument for the two layers rather than a problem with them.
           </Para>
 
-          <Eq note="G doubles — and that is the whole of it">
-            <K>G</K> = <Frac
-              over={<><K>BITE</K>·<i>share</i>·<K>SHEET</K><Sup>2</Sup></>}
-              under={<>4<V>π</V><Sup>2</Sup>·<K>CORE</K>·<K>DEG</K></>} />
-            <span style={{ padding: '0 1.4em' }} />
-            {gravitational(0.5).toFixed(6)} → {gravitational(1).toFixed(6)}
+          <Head>and then the measurement, which says how far the ring gets alone</Head>
+
+          <Para>
+            It would be easy to stop there and claim it works. It is worth instead asking what the ring gives <i>without</i> the retrocausal reading — as an ordinary common cause, with the winding fixed at the source and each end reading out sign(cos(azimuth − setting)). That is a local hidden variable model, so it is capped at 2, and the question is where it lands.
+          </Para>
+
+          <Eq note="a genuine common cause on the ring, searched over all four settings independently">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`CYCLE =  8    max CHSH = 2.000000
+CYCLE = 16    max CHSH = 2.000000
+CYCLE = 64    max CHSH = 2.000000
+
+local bound   2.000000      Tsirelson   2.828427`}
+            </span>
           </Eq>
 
           <Para>
-            And the factor of two is not observable in an orbit. Every mass in the model is carried in units of <K>GRAVITY</K>, so a body of physical mass <V>M</V> holds <V>M</V>/<K>G</K> and the dynamics compute <K>G</K>·(<V>M</V>/<K>G</K>). The constant is gone before it is used — <b>a change of the mass unit, not of a trajectory</b>. Measured on the line integral: exactly two at every separation, with <V>S</V>·<V>R</V><Sup>2</Sup> flat in both. The one thing it does carry with it is the mass unit itself: <V>µ</V> = <K>G</K>·<V>m</V><Sub>P</Sub>, so the heaviest elementary thing goes from {(massUnit(0.5) * 1e9).toFixed(3)} µg to {(massUnit(1) * 1e9).toFixed(3)} µg and every emitter pulses half as often. The step and the tick do not go with it — the <K>G</K> cancels out of both.
+            <b>The ring saturates the local bound exactly and cannot pass it.</b> That is worth more than a smaller number would be: it says the eight-step readout is an <i>optimal</i> local model rather than a poor one, so nothing is being lost to a bad choice of observable, and the entire remaining gap is structural. The shortfall is 0.828 of CHSH — about 41% — and no refinement of the readout, no larger <K><Bar>CYCLE</Bar></K>, and no cleverer common cause will supply any of it.
           </Para>
 
           <BR/>
 
           <Para>
-            <K>SHEET</K>, <K>DEG</K>, <K>BITE</K>, <K>BIAS</K>, <K>MADE</K>, <K>SPREAD</K>, <K>REACHES</K>, the step and the tick do not move at all. And neither does anything <i>measured</i>: Mercury's sixth, the other five sixths, light's deflection, <V>a</V><Sub>0</Sub> = <V>cH</V><Sub>0</Sub>/2π, the Milky Way to 1.1%, the transport turnover, the interpolation function, the step at 33 and 52 kpc, and <V>H</V><Sub>0</Sub> = 1/<V>t</V><Sub>0</Sub>. <b>All identical, to every digit quoted</b> — because every one of them is computed from something that never mentions a sign.
+            So the arc's contribution here is to make the debt exact rather than to pay it. <b>The 41% is precisely the difference between a winding fixed when the strand is made and a winding fixed by both of its ends</b>, and that is now a definite question about a definite object rather than a gesture at a research programme. What it would take to settle it is a two-boundary calculation on the strand — fix the ends, count the consistent windings, and see whether the correlation comes out at −cos of the angle. That has not been done here and I will not pretend the door being the right shape is the same as walking through it.
+          </Para>
+
+          <Head>the coupling, and what is actually owed</Head>
+
+          <Para>
+            The other debt is one number, and the first thing to say is that Layer 2 has already changed its status even though it does not supply it. The magnetism arc's reason for having no electric force at all was structural: <i>a force here is a meeting, which is second order</i>. Layer 2 has a first-order channel — a strand's azimuth responds to the ambient axis with no second strand required, which is what the minimal-coupling result is. <b>So the electric force exists in this model now, at some strength.</b> Before, it did not exist at any.
           </Para>
 
           <BR/>
 
           <Para>
-            <b>So gravity is the same theory.</b> Not approximately. What is lost is magnetism entirely — the sign law, 3cos²<V>θ</V> − 1, 1/<V>R</V><Sup>4</Sup>, ∇·<V>B</V> = 0, the quantised magnetisation — and one <i>explanation</i>: with polarity the ½ in <V>G</V> is derived, being the chance two charges disagree. Without it, the share is 1 by fiat and there is nothing to explain.
+            The second thing is that <b>137.036 is the wrong target</b>, and aiming at it is most of why this has looked hopeless. α runs: it is already 1/127.95 at the Z mass, seven per cent moved by 91 GeV, and the distance from there to a Planck cutoff is another seventeen orders. A lattice whose grain is the Planck length owes α <i>at its own cutoff</i>, and the value at zero energy is that number plus the entire running, which depends on every charged thing that exists in between. <b>137.036 is an infrared accident of the particle content, not a lattice number</b>, and a lattice formula that hits it would be suspicious rather than convincing.
+          </Para>
+
+          <Head>and one whole class of answer is excluded</Head>
+
+          <Para>
+            There is an obvious and tempting route, and it is dead, which is worth knowing before anyone spends a month on it. The model has exactly one environmental scale that could set a coupling — the vacuum screening length <V>λ</V>, which is fixed by the ambient density <V>ρ</V>. If α were set by it, α would go as 1/<V>λ</V><Sup>2</Sup>, hence as <V>ρ</V>, hence as <V>a</V><Sup>−3</Sup>.
+          </Para>
+
+          <Eq note="the drift that would follow, against what is measured">
+            <Frac over={<>α̇</>} under={<>α</>} /> = −3<V>H</V> = −2.07·10<Sup>−10</Sup> / yr
+            <span style={{ padding: '0 1.2em', color: FAINT }}>vs</span>
+            |α̇/α| &lt; 10<Sup>−17</Sup> / yr
+          </Eq>
+
+          <Para>
+            <b>Excluded by a factor of 2·10<Sup>7</Sup></b>, from quasar absorption lines and the Oklo reactor. So α is not environmental in this model, which means it is not allowed to depend on the one thing in the model that varies. It has to be a fixed count off the lattice — and the book's own standard applies to that with full force: of 117,649 lattice monomials searched, 51 land within half a percent of 137.036, so a hit is not evidence and none is offered here either.
+          </Para>
+
+          <Head>what would count as evidence instead</Head>
+
+          <Para>
+            Which leaves one honest way to test the electric half without deriving its constant, and Layer 2 is what makes it available. <b>The running of α does not depend on α.</b> Its slope depends only on what charged matter exists — and Layer 2 is the first thing in this book that says what charged matter <i>is</i>: a strand, with a traversal sense, and a count rather than a rate.
           </Para>
 
           <BR/>
 
           <Para>
-            Which leaves the XOR as a <b>tunable parameter, and a free one on the gravitational side</b>. Turning it on costs nothing and buys magnetism; turning it off costs magnetism and buys nothing. That is a better position than this page was in before the question was asked, because it means the magnetic half cannot break the gravitational one — there is no shared number for it to get wrong.
+            So the model can be put against dα/d(log µ) with the coupling itself left unknown, and it either gets the slope or it does not. <b>That is a real test of the electric half that costs nothing that is owed</b>, and it is the thing I would do next on this side — ahead of any search for a formula, because a formula that hits 137.036 would tell us nothing and a slope that comes out right would tell us a great deal.
           </Para>
 
+          <Head>the ledger</Head>
+
+          <Rows of={[
+            [<>what is settled</>,
+              <>That the electric force <b>exists</b> in this model, which it did not before —
+                Layer 2 supplies the first-order channel whose absence was the whole of the
+                missing column. And that the lattice's rules are time-symmetric, so the
+                boundary-value reading is the natural one rather than an amendment.</>],
+            [<>what is made exact</>,
+              <>The entanglement debt. The ring is an <b>optimal</b> local model — CHSH
+                2.000000 at every <K><Bar>CYCLE</Bar></K>, saturating the bound — so the
+                missing 0.828 is entirely structural, and it is exactly the gap between a
+                winding fixed at emission and one fixed by both ends.</>],
+            [<>what is excluded</>,
+              <>α as an environmental quantity. Set by the vacuum it would drift at 3<V>H</V>,
+                which is 2·10<Sup>7</Sup> times the measured bound. The one scale the model
+                had available cannot be the one that does it.</>],
+            [<>what is reframed</>,
+              <>The number owed is α <i>at the cutoff</i>, not 137.036 — which is an infrared
+                value after seventeen orders of running, and not a lattice quantity at
+                all.</>],
+            [<>and what is still owed</>,
+              <>The two-boundary calculation on a strand, which would settle the 41%. And the
+                coupling, still, though now with a test available that does not need it.</>],
+          ]} />
+
+          <Para>
+            So neither is paid, and both have changed shape. The entanglement problem stops being "a theorem stands in the way" and becomes a specific arithmetic on a specific object, whose answer the magnetism arc has been asking for under another name — with the two layers being exactly what lets that question have opposite answers on the two of them. And the coupling stops being a hunt for a number and becomes a slope that can be checked. <b>Neither is a result. Both are now the kind of problem that can be worked on rather than the kind that can only be admitted to.</b>
+          </Para>
         </Section>
       </Section>
-      
-      <Section head="Electromagnetism">
-     
-      </Section>
     </Arc>
     <Arc head={<span className="bp5-text-disabled">2027.</span>}>
     </Arc>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 4d55624..2858600 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -1080,6 +1080,138 @@ half out   1.98   1.88   1.76   1.41   1.00   1.00`}
   </>,
 };
 
+export const COHERENT: Derivation = {
+  label: 'share as a coherence',
+  title: <>the one factor that knows about phase</>,
+  body: <>
+    <Because>what share actually is, in the source</Because>
+    <Step eq={<>share = ⟨opposed(<V>ψ</V>)⟩,&nbsp;&nbsp; opposed(<V>ψ</V>) = |<V>ψ</V>|/π</>}>
+      Wrapped to [−π, π] and averaged over the path difference. Every other
+      factor in <V>S</V><Sub>ab</Sub> is a count of arrivals; this one is the
+      only place a <i>phase</i> enters the pull at all. So the gravity above is
+      not a classical law waiting to be quantised —{' '}
+      <b style={{ color: INK }}>it is already an expectation value</b>, taken
+      over a phase the derivation decided not to track.
+    </Step>
+
+    <Because>and what a Born rule would want there instead</Because>
+    <Step eq={<>
+      ¼|<V>e</V><Sup>i<V>φ</V><Sub>a</Sub></Sup> −{' '}
+      <V>e</V><Sup>i<V>φ</V><Sub>b</Sub></Sup>|<Sup>2</Sup> =
+      (1 − cos <V>ψ</V>)/2
+    </>}>
+      A modulus-square of a difference of two phases — the shape every
+      interference term in quantum mechanics has. It agrees with |<V>ψ</V>|/π
+      at nought, at a half cycle and at π, which is why nothing measured so far
+      could tell them apart. In between it does not.
+    </Step>
+
+    <Because>the two kernels, through the same walk</Because>
+    <Step eq={<>
+      <span style={{ fontFamily: 'monospace', fontSize: '0.82em', whiteSpace: 'pre' }}>
+        {`R/λ        0.02   0.10   0.20   0.27   0.50   1.00
+triangle   0.024  0.119  0.238  0.318  0.595  1.000
+cosine     0.001  0.026  0.099  0.171  0.500  1.000`}
+      </span>
+    </>}>
+      <V>G</V><Sub>eff</Sub>/<V>G</V> for two of the same thing in step, run
+      through the same raised-cosine window. <b style={{ color: INK }}>The
+      triangle vanishes linearly in the separation and the cosine
+      quadratically</b>, and the gap between them peaks at 0.147 at{' '}
+      <V>R</V>/<V>λ</V> = 0.268.
+    </Step>
+
+    <Because>and what it would take to look</Because>
+    <Step eq={<>0.268 <V>λ</V> = 40.5 fm&nbsp;&nbsp; for two electrons</>}>
+      One model wavelength is 2π<V>G</V><V>λ</V><Sub>C</Sub> = 0.151 pm for an
+      electron, so the place the two kernels disagree most is forty femtometres
+      apart — where the electric force between them is 4.166·10<Sup>42</Sup>{' '}
+      times the gravitational one, which is the same ratio the magnetism arc
+      owes <V>α</V> for. <b style={{ color: INK }}>So the discriminator is
+      real, sharp, and unreachable</b>, and it is stated here rather than
+      advertised as a test.
+    </Step>
+  </>,
+};
+
+export const RECORD: Derivation = {
+  label: 'the which-path rate',
+  title: <>what a superposition leaves behind</>,
+  body: <>
+    <Because>the rule does not know whose charge it is</Because>
+    <Step>
+      (G/1) says two rays meeting annihilate. It says nothing about whether
+      they came from the same emitter, and there is no bookkeeping anywhere in
+      the model that could mark two rays <i>same particle, skip</i>. So a
+      source in two places has its two branches annihilating against each
+      other exactly as two bodies would — which the model already computes for
+      a single body, as the <K>SKIN</K> self-screening.
+    </Step>
+
+    <Because>but that is two different rates, and only one of them decoheres</Because>
+    <Step eq={<>
+      <V>Γ</V><Sub>cross</Sub> — branch against branch
+      <span style={{ padding: '0 1.2em', color: FAINT }}>vs</span>
+      <V>Γ</V><Sub>env</Sub> — branch against everything else
+    </>}>
+      Branch-against-branch needs <i>both</i> branches present, so it is the
+      interference term itself — it is what makes the pair's own gravity
+      differ from <V>G</V>, and it carries no information about which branch
+      the thing was in. Only an annihilation against the <i>outside</i> leaves
+      folded space at a place that differs between the branches, and folded
+      space is permanent. <b style={{ color: INK }}>That is the record.</b>
+    </Step>
+
+    <Because>so integrate the records over the field</Because>
+    <Step eq={<>
+      <V>Γ</V><Sub>env</Sub> = ∫<Sub>d</Sub><Sup>∞</Sup> share·<V>ρ</V>·
+      chance(<V>m</V>,<V>r</V>)·<V>c</V> ·
+      (<V>d</V>/<V>r</V>)<Sup>2</Sup> · 4π<V>r</V><Sup>2</Sup> d<V>r</V>
+    </>}>
+      The bracket is the distinguishability: two branches <V>d</V> apart look
+      identical at <V>r</V> ≫ <V>d</V> up to a dipole term going as{' '}
+      <V>d</V>/<V>r</V>, and fully distinct inside <V>d</V>. Everything else is
+      the ambient annihilation rate the vacuum section already carries.
+    </Step>
+
+    <Because>and the r's cancel, twice</Because>
+    <Step eq={<>
+      <V>Γ</V><Sub>env</Sub> = ½ <V>ρ</V> <K>SHEET</K> <V>m</V> <V>d</V> =
+      <span style={{ padding: '0 0.5em' }} />
+      <V>m</V><V>d</V>/<V>λ</V><Sup>2</Sup>
+    </>}>
+      chance carries 1/<V>r</V><Sup>2</Sup>, the shell carries{' '}
+      <V>r</V><Sup>2</Sup>, the dipole carries 1/<V>r</V><Sup>2</Sup> again, so
+      what is left is ∫d<V>r</V>/<V>r</V><Sup>2</Sup> = 1/<V>d</V> and the{' '}
+      <V>d</V><Sup>2</Sup> above it leaves one power of <V>d</V>. Then{' '}
+      <V>λ</V> = 1/√(<K>BITE</K>·share·<K>SHEET</K>·<V>ρ</V>) from the vacuum
+      section eats <V>ρ</V> and <K>SHEET</K> whole.{' '}
+      <b style={{ color: INK }}>Linear in the mass, linear in the separation,
+      and the constant is the screening length gravity already had.</b>{' '}
+      Nothing was fitted and nothing new was introduced.
+    </Step>
+
+    <Because>and then the number, which kills it</Because>
+    <Step eq={<>
+      <span style={{ fontFamily: 'monospace', fontSize: '0.82em', whiteSpace: 'pre' }}>
+        {`                          m (kg)    d (m)    t_decoh (s)
+electron                  9.1e−31   1e−6     2.5e+71
+C60                       1.2e−24   1e−7     1.9e+66
+1e−14 kg nanoparticle     1e−14     1e−4     2.3e+53
+1 kg, a metre apart       1         1        2.3e+35`}
+      </span>
+    </>}>
+      Against an age of the universe of 4.35·10<Sup>17</Sup> s. In SI the whole
+      law is <V>Γ</V> = 4.41·10<Sup>−36</Sup>·<V>M</V>·<V>d</V> per second,
+      because <V>λ</V> is 1.63 horizon radii and 1/<V>λ</V><Sup>2</Sup> is
+      10<Sup>−122</Sup>. <b style={{ color: INK }}>The vacuum is far too thin
+      to be an environment</b>, by thirty-five orders at best. The rate is
+      derived rather than assumed, which is what was wanted, and it is not the
+      mechanism of anything.
+    </Step>
+  </>,
+};
+
 export const CEILING: Derivation = {
   label: 'G as a mass',
   title: <>the constant, read as a mass in Planck masses</>,

From 3fe91548d763f3fc168e7711757ffe603a86a5e2 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Fri, 14 Aug 2026 23:13:40 +0200
Subject: [PATCH 45/47] FLuctuation + matter

---
 orbitmines.com/src/routes/Physics.tsx         | 178 ++++++--
 .../2026.RayCalculiAndPhysics/tests/README.md |   1 +
 .../2026.RayCalculiAndPhysics/tests/run.sh    |   2 +-
 .../2026.RayCalculiAndPhysics/tests/sphere.ts | 386 ++++++++++++++++++
 4 files changed, 540 insertions(+), 27 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sphere.ts

diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index cf3330f..aa881ec 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -344,11 +344,12 @@ const Physics = () => {
 
           Alrighty,
 
-          <Head>The inverse square law</Head>
+          Let's start out building a vocabulary for the continuous model. We'll start by describing aggregate behavior of our discrete pressures.
+
 
           <Head>Mass</Head>
 
-          If 'gravity-rays' are what cause attraction in this model. How would we intuitively encode what it means to have mass. The answer is: The heavier you are, the more gravity you expect around that thing. So the heavier something is the more of these rays it shoots out.
+          If 'gravity-rays' are what cause attraction in this model. How would we intuitively encode what it means to have mass. The answer is: The heavier you are, the more gravity you expect around that thing. So the heavier something is the more often it shoots out these rays.
 
           <Eq>
             <i><Bar>m</Bar></i> = <F>% <Bar>t</Bar>
@@ -362,36 +363,43 @@ const Physics = () => {
 
           <BR/>
 
-          <Para>
-            The obvious first thing to note being that this predicts a heaviest elementary object, if one would assume a static <F>l.</F><K><Bar>DEG</Bar></K>. Essentially saying, if the local spatial density (<F>l.</F><K><Bar>DEG</Bar></K>) is given, there's a heaviest elementary object which can occupy that space. Namely <i><Bar>m</Bar></i> = 1 (pulse every tick).
-          </Para>
+          (We'll later discuss what kind of things this implies)
+          
+          <Head>The inverse square law</Head>
+
+          The discrete model will tell us that there will be constant fluctuations of the shape of the pressure gravity is exerting, but that those fluctuations will average out to a sphere. And we can measure both halves of that rather than assert them — <code>tests/sphere.ts</code> puts one absorber in an 81<Sup>3</Sup> box, lets it settle for 600 ticks, and reads the shortfall it digs.
 
           <BR/>
 
-          <Para>At <i><Bar>m</Bar></i> = 1 we get a gravitational constant</Para>
+          <Para>
+            <b>The instantaneous shape is not a sphere and is nowhere near one.</b> Cells sitting on the same shell, with that shell's own radial gradient divided out first, differ from each other by <b>28% at <V>r</V> = 6 and 106% at <V>r</V> = 20</b> — and the growth is arithmetic rather than physical. The scatter is about <i>one charge per cell</i> at every radius (1.68, 1.46, 1.40, 1.01 at <V>r</V> = 6, 10, 14, 20) while the deficit it sits on falls as 1/<V>r</V>, so the fluctuation <i>relative</i> to the thing being measured grows in proportion to <V>r</V> and crosses 100% at the radius where the deficit drops under one whole charge. A cell holds an integer; far out, the field it is asked to carry is a fraction of one.
+          </Para>
 
-          <Eq derive={CEILING}>
-            <i><K><Bar>G</Bar></K></i> = <Frac
-              over={<><K><Bar>SHEET</Bar></K><Sup>2</Sup> · <K><Bar>c</Bar></K></>}
-              under={<>4<V>π</V><Sup>2</Sup> · {HALF} · <K><Bar>DEG</Bar></K></>} />
-            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
-            {gravitational(1).toFixed(6)}..
+          <Eq note={<>one charge of grain on a shortfall going as 1/<V>r</V>, thinned by the ticks averaged over</>}>
+            wobble(<V>r</V>,<V>n</V>) ≈
+            <Frac
+              over={<>1 charge</>}
+              under={<>deficit(<V>r</V>) · √<V>n</V></>}
+            />
+            <span style={{ padding: '0 1.4em' }} />
+            ∝
+            <Frac over={<><V>r</V></>} under={<>√<V>n</V></>} />
           </Eq>
 
-          Whenever there's a derived equation, you can click on it to see how it was derived! Try it!
+          <Para>
+            <b>And the average of it is round.</b> Over 300 ticks the same angular scatter falls to <b>0.8–1.3%</b> at every radius — at or below the 1/√<V>n</V> that independent noise would give, because a relay that conserves what it carries averages slightly better than a free one. What does <i>not</i> average away is the lattice, and it is only near in: the ⟨100⟩, ⟨110⟩ and ⟨111⟩ cones agree to within <b>3.7% at <V>r</V> = 6, 5.4% at <V>r</V> = 8, and under 1.3% everywhere beyond <V>r</V> = 10</b>. That residual is a near-field term rather than a shape, which is what <K><Bar>FLOOR</Bar></K> below is for.
+          </Para>
+
+          <BR/>
 
           <Para>
-            <span className="bp5-text-muted">
-              The second thing, not used for the rest of this model: Turn the period into a length of how far light travels within that timeframe, and you get something proportional to the <Ref of={'reduced Compton wavelength'} at="https://en.wikipedia.org/wiki/Compton_wavelength#Reduced_Compton_wavelength" /> <Footnote of={'Compton, "A Quantum Theory of the Scattering of X-rays by Light Elements", Phys. Rev. 21:483'} year="1923" at="https://doi.org/10.1103/PhysRev.21.483" />. (<i><K><Bar>G</Bar></K></i> here being the gravitational constant of the model)
-            </span>
+            Two things that fall out of the same run and are worth having early. The empty box is <i>exactly</i> static — with every point full there is never a shortfall, so no edge is ever skipped and the vacuum has no choice to make — meaning <b>every fluctuation above belongs to the body's well and none of it to the medium</b>. And the roundness is a real sphere rather than the cube the front actually is: a field that were secretly a function of Chebyshev distance would read the <V>r</V>/√3 shell's value along ⟨111⟩, which at <V>r</V> = 20 is 3.63. Measured, it is 1.088, against a shell mean of 1.084.
           </Para>
 
-          <Eq derive={CLOCK}>
-            <i><Bar>m</Bar></i>.period · <K>c</K> = <i><K><Bar>G</Bar></K></i> · <D><i>λ</i><Sub>Compton</Sub></D>
-            <span style={{ padding: '0 1.4em' }} />
-            <D><i>λ</i><Sub>Compton</Sub></D> = <Frac over={<>ħ</>} under={<><i>Mc</i></>} />
-          </Eq>
-          {/* <V>E</V> = ħω */}
+
+
+
+          <BR/>
          
           <span style={{paddingBottom: '200px'}}></span>
 
@@ -412,9 +420,6 @@ const Physics = () => {
 
           <Head>one pulse, spread — which is where the inverse square is</Head>
 
-          <Para>
-            Now the piece the previous section promised. A source lets go of <K><Bar>SHEET</Bar></K> charges per pulse. That number does not change with distance — the charges just get further apart, because the shell they are riding on has grown. So the chance that any one cell out at radius <V>r</V> is holding one of them is a fixed count divided by a growing shell.
-          </Para>
 
           <Eq derive={MEETINGS}>
             shell(<V>r</V>) = 4<V>π</V>·max(<V>r</V>, {HALF})<Sup><K><Bar>D</Bar></K> − 1</Sup> + <K><Bar>FLOOR</Bar></K>
@@ -427,6 +432,21 @@ const Physics = () => {
             <b>That is the whole of the inverse-square law and there is no distance law in it anywhere.</b> Nobody wrote down 1/<V>r</V><Sup>2</Sup>. What was written down is "a fixed number of charges" and "a shell in three dimensions has 4π<V>r</V><Sup>2</Sup> cells on it", and 1/<V>r</V><Sup>2</Sup> is what those two come to when you divide one by the other. Send the pulse out over a different shape and the exponent changes with nothing else touched — which is why the general form is 1/<V>r</V><Sup><K><Bar>D</Bar></K>−1</Sup> and why it is a statement about <i>dimension</i> rather than about gravity.
           </Para>
 
+          <Eq note={<>the exponent is the shell's — put <K><Bar>D</Bar></K> = 3 in and 1/<V>r</V><Sup>2</Sup> falls out</>}>
+            chance(<V>m</V>,<V>r</V>) =
+            <Frac
+              over={<><V>m</V> · <K><Bar>SHEET</Bar></K></>}
+              under={<>4<V>π</V> <V>r</V><Sup><K><Bar>D</Bar></K> − 1</Sup></>}
+            />
+            ∝
+            <Frac over={<>1</>} under={<><V>r</V><Sup><K><Bar>D</Bar></K> − 1</Sup></>} />
+            <span style={{ padding: '0 0.5em', color: FAINT, fontSize: '0.72em' }}>
+              <K><Bar>D</Bar></K> = 3
+            </span>
+            ⟶
+            <Frac over={<>1</>} under={<><V>r</V><Sup>2</Sup></>} />
+          </Eq>
+
           <BR/>
 
           <Para>
@@ -1628,8 +1648,42 @@ const Physics = () => {
 
       </Section>
       
-      <Section head="Electromagnetism">
+      <Section head="Layer 2: Matter">
+
+          <Para>
+            The obvious first thing to note being that this predicts a heaviest elementary object, if one would assume a static <F>l.</F><K><Bar>DEG</Bar></K>. Essentially saying, if the local spatial density (<F>l.</F><K><Bar>DEG</Bar></K>) is given, there's a heaviest elementary object which can occupy that space. Namely <i><Bar>m</Bar></i> = 1 (pulse every tick).
+          </Para>
+
+          <BR/>
+
+          <Para>At <i><Bar>m</Bar></i> = 1 we get a gravitational constant</Para>
+
+          <Eq derive={CEILING}>
+            <i><K><Bar>G</Bar></K></i> = <Frac
+              over={<><K><Bar>SHEET</Bar></K><Sup>2</Sup> · <K><Bar>c</Bar></K></>}
+              under={<>4<V>π</V><Sup>2</Sup> · {HALF} · <K><Bar>DEG</Bar></K></>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            {gravitational(1).toFixed(6)}..
+          </Eq>
+
+          Whenever there's a derived equation, you can click on it to see how it was derived! Try it!
+
+          <Para>
+            <span className="bp5-text-muted">
+              The second thing, not used for the rest of this model: Turn the period into a length of how far light travels within that timeframe, and you get something proportional to the <Ref of={'reduced Compton wavelength'} at="https://en.wikipedia.org/wiki/Compton_wavelength#Reduced_Compton_wavelength" /> <Footnote of={'Compton, "A Quantum Theory of the Scattering of X-rays by Light Elements", Phys. Rev. 21:483'} year="1923" at="https://doi.org/10.1103/PhysRev.21.483" />. (<i><K><Bar>G</Bar></K></i> here being the gravitational constant of the model)
+            </span>
+          </Para>
+
+          <Eq derive={CLOCK}>
+            <i><Bar>m</Bar></i>.period · <K>c</K> = <i><K><Bar>G</Bar></K></i> · <D><i>λ</i><Sub>Compton</Sub></D>
+            <span style={{ padding: '0 1.4em' }} />
+            <D><i>λ</i><Sub>Compton</Sub></D> = <Frac over={<>ħ</>} under={<><i>Mc</i></>} />
+          </Eq>
+          {/* <V>E</V> = ħω */}
+
+        <Section head="Electromagnetism">
      
+        </Section>
       </Section>
 
       <Section head="AI Generated">
@@ -3242,6 +3296,78 @@ an undirected axis returns after CYCLE/2 = 4 steps (π)`}
             <b>With two layers it is no longer a change to the emission rule, because the axis and the north are no longer the same object.</b> North belongs to Layer 1 and is what emits; the axis is what a Layer-2 strand winds around, and it is undirected because a ring has no preferred sense until a traversal picks one. The observable turns twice per turn of the state because the two things doing the turning live on different layers. So <V>g</V> = 2 is available here for the reason the arc identified and could not use, and <b>it is the sharpest test this proposal has</b> — the 0.0023 is not claimed and would want the coupling that is still owed.
           </Para>
 
+          <Head>and the magnet, which was never an ordering problem</Head>
+
+          <Para>
+            The magnetism arc's other refutation is that every ordering it tried — axial, radial, cylindrical — gives a far field falling as 1/<V>r</V><Sup>2</Sup> where a magnet falls as 1/<V>r</V><Sup>3</Sup>. That arc read it as a question about arrangement and looked for a better one. <b>It is not a question about arrangement, and one measurement settles that before anything else is tried.</b>
+          </Para>
+
+          <Eq note="a single emitter, with nothing to be ordered against">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`one sided emitter, alone      far-field exponent = 2.000`}
+            </span>
+          </Eq>
+
+          <Para>
+            One emitter, on its own, already falls as 1/<V>r</V><Sup>2</Sup>. <b>No arrangement of things that are each wrong can come out right</b>, so the whole search was along the wrong axis. And the reason is exactly the mechanism that arc named: with the sign resolved against the axis <i>at the destination</i>, a distant observer is on the + side of every emitter at once, so nothing cancels and what is left is a monopole. It is not that the poles fail to form — it is that the model is emitting a net charge.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which also means the arc's <V>∇</V>·<B>B</B> = 0 was in tension with its own far field the whole time. A 1/<V>r</V><Sup>2</Sup> field <i>is</i> a monopole field; you cannot have both.
+          </Para>
+
+          <Head>two routes to the cube, and only one of them survives being real</Head>
+
+          <Para>
+            There are exactly two ways to kill a monopole moment, and the model has to pick. Either the ± charges are <i>intrinsic</i> and exactly balanced, or the source is a <i>closed loop</i>, which has no monopole moment at all no matter what it does. Measured, both give the right exponent — and they are not remotely equally good.
+          </Para>
+
+          <Eq note="784 emitters, far-field exponent along the axis, fitted over r = 200 to 3200 cells">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`INTRINSIC CHARGES        exponent      LAYER-2 LOOPS          exponent
+perfectly balanced         3.000      all aligned              3.001
+1 emitter in 784 flipped   2.791      RANDOM orientations      3.013
+2 in 784                   2.668      one loop broken open     2.187
+8 in 784                   2.367`}
+            </span>
+          </Eq>
+
+          <Para>
+            <b>The charge route is fine-tuned and the loop route is not.</b> One defect in 784 already drags the exponent to 2.79, and the crossover — the radius past which the leftover monopole beats the dipole — comes in at 1756 cells for a single flipped emitter and 216 cells for eight. A real magnet is 10<Sup>23</Sup> atoms with thermal disorder in it, so the imbalance would go as √<V>N</V> and the dipole would never be visible at any distance at all.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The loops do not care. <b>Randomising every loop's orientation still gives 3.013</b>, because each closed loop has zero monopole moment <i>individually</i> — by topology, not by cancellation — and no arrangement of things with no monopole moment can produce one. There is nothing to tune and nothing to keep aligned.
+          </Para>
+
+          <Head>and the model has already committed to the loops</Head>
+
+          <Para>
+            That is the part that makes this a consequence rather than a choice. The charge argument earlier in this arc says a strand cannot have a free end — you cannot make a lone traversal sense, which is why charge is conserved. <b>A strand with no free end is a closed loop.</b> So the model does not get to pick the fine-tuned route; the same statement that gives it charge conservation gives it loops, and loops give the cube.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Three things collapse into one. <V>∇</V>·<B>B</B> = 0, the absence of monopoles, and charge conservation are <b>the same fact stated three ways</b> — a strand has no end. And the one case that breaks the exponent says what a monopole would have to be here: the broken loop gives 2.187, so <b>a magnetic monopole in this model is an open strand</b>, and it does not exist for the same reason a free charge end does not.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            One thing worth saying rather than leaving implied. The two routes are the old Gilbert and Ampère pictures, they agree everywhere outside the magnet, and experiment has long since separated them <i>inside</i> — the hyperfine splitting measures the field in the body and picks the current loop. <b>So the route the model is forced into is also the one that is right</b>, which is not something this book gets to say very often.
+          </Para>
+
+          <Head>what this does not yet do</Head>
+
+          <Para>
+            It gives the exponent, the isotropy and the absence of monopoles, and it does not give the <i>size</i>. The magnetism arc's owed number — the coupling on the pole face — is owed exactly as before, and it is the same coupling this book has been owing since the electric half. What has changed is that a magnet now has the right shape without anything being held in place, where before it had the wrong shape however it was held.
+          </Para>
+
           <Head>matter, and the debt it pays</Head>
 
           <Para>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
index f5d3c0f..17b8893 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
@@ -33,6 +33,7 @@ than as silent agreement.
 | `wave` | **the same lattice propagating as a wave instead of a ray** — the front is a circle at the sound speed and the grain vanishes as the pulse widens |
 | `lattices` | **which space gives a sphere** — a sweep of spatial constructions against the spherical-design condition, and the shell search that finds 26 directions exact through rank 6 |
 | `veined` | **what every law becomes if the field is veined rather than shell-averaged** — the radial law survives exactly, the Solar System kills it, galaxies cannot see it |
+| `sphere` | **how round the pressure is, and by how much it wobbles** — the instantaneous shape is 28–106% ragged, the average of it is a sphere to 1%, and the lattice survives only inside r ≈ 8 |
 | `cones` | **is there a rule with nothing tuned that gives a sphere** — no, and in 3D no `w` can, plus what each candidate rule does to every published number |
 
 ### the force law
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
index 3d274c6..d02f12b 100755
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
@@ -31,7 +31,7 @@ ORDER=(
   recon which138 accum accumulate asym
   pulses magnets coulomb moment dipole poles ordering budget tradeoff scale maxwell
   nopolarity
-  turns ways veins cones veined lattices wave gas vacuum pure
+  turns ways veins cones veined lattices wave gas vacuum pure sphere
 )
 
 if [ "${1:-}" = "--list" ]; then printf '%s\n' "${ORDER[@]}"; exit 0; fi
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sphere.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sphere.ts
new file mode 100644
index 0000000..0468984
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sphere.ts
@@ -0,0 +1,386 @@
+/**
+ * HOW ROUND IS IT, AND BY HOW MUCH DOES IT WOBBLE?
+ *
+ * The article says, of the pressure a body exerts, that "there will be constant
+ * fluctuations of the shape ... but those fluctuations will approximate a
+ * sphere. In fact we can measure the manner in which it will fluctuate." That
+ * is two claims and a promise, and none of the three had a number behind it.
+ *
+ * The rule is `pure.ts` in three dimensions, which is the shortest form of the
+ * model that has a force in it at all:
+ *
+ *     EVERY POINT SENDS ONE CHARGE ALONG EACH OF ITS DEG = 26 EDGES, EVERY
+ *     TICK. Every charge is destroyed at the point it lands on, and that
+ *     destruction makes the next one — a point that received k sends k back
+ *     out. Nothing is created or lost except at a BODY, which takes and sends
+ *     nothing. The box rim is held full, which is the rest of space.
+ *
+ * A point with fewer than 26 to send must skip some edges, and there are two
+ * honest ways to choose which: at random, or by letting the skipped edge walk
+ * round the point (round-robin, no randomness anywhere). Both are run.
+ *
+ * WHAT IS BEING MEASURED. The deficit 26 − q is the shortfall a body digs in
+ * the vacuum, and it is what every force in the article reads. So:
+ *
+ *   §1  does the vacuum sit still when nothing is in it
+ *   §2  the radial profile, against A(1/r − 1/R) — the 1/r whose gradient is
+ *       the inverse square
+ *   §3  THE SHAPE: ⟨100⟩, ⟨110⟩, ⟨111⟩ at matched EUCLIDEAN radius, which is
+ *       the sphere claim, plus the test that separates a sphere from the cube
+ *       the front actually is
+ *   §4  THE WOBBLE: the same shells watched tick by tick, so "fluctuates" gets
+ *       a number — per cell and per shell, in time and in angle
+ *
+ * Run: ./run.sh sphere
+ */
+
+// —— the lattice ————————————————————————————————————————————————————————————
+
+const DEG = 26;
+
+/** every direction out of a point: 3³ − 1. */
+const DIR: [number, number, number][] = (() => {
+  const d: [number, number, number][] = [];
+  for (let z = -1; z <= 1; z++) for (let y = -1; y <= 1; y++) for (let x = -1; x <= 1; x++)
+    if (x || y || z) d.push([x, y, z]);
+  return d;
+})();
+
+type Mode = "round" | "random";
+
+/**
+ * One run. `L` is the box edge (odd), `R` the body radius, `T` the ticks.
+ *
+ * `watch` is a list of Euclidean radii whose shell mean is recorded EVERY tick
+ * of the second half, which is what §4 reads. Everything else is read off the
+ * final state.
+ */
+const sim = (L: number, T: number, R: number, mode: Mode, watch: number[] = []) => {
+  const o = (L - 1) / 2, C = L * L * L;
+  const at = (x: number, y: number, z: number) => ((z + o) * L + (y + o)) * L + (x + o);
+
+  let q = new Uint8Array(C).fill(DEG);
+  let nq = new Uint8Array(C);
+  const phase = new Uint8Array(C), body = new Uint8Array(C);
+
+  // neighbour offsets in the flat array, so the inner loop is one add
+  const OFF = DIR.map(([x, y, z]) => (z * L + y) * L + x);
+
+  // R < 0 is the empty box, which is how §1 asks what the vacuum does alone
+  for (let z = -R; z <= R; z++) for (let y = -R; y <= R; y++) for (let x = -R; x <= R; x++)
+    if (x * x + y * y + z * z <= R * R) body[at(x, y, z)] = 1;
+
+  /** the two outermost layers are the rest of space: always full, never drained */
+  const rim = (x: number, y: number, z: number) =>
+    Math.abs(x) >= o - 1 || Math.abs(y) >= o - 1 || Math.abs(z) >= o - 1;
+
+  // which cells belong to which watched shell, resolved once
+  const shells = watch.map(r => {
+    const cells: number[] = [];
+    for (let z = -o; z <= o; z++) for (let y = -o; y <= o; y++) for (let x = -o; x <= o; x++) {
+      const d = Math.sqrt(x * x + y * y + z * z);
+      if (d >= r - 0.5 && d <= r + 0.5) cells.push(at(x, y, z));
+    }
+    return cells;
+  });
+  const trace: number[][] = watch.map((): number[] => []);
+
+  /** one cell per watched shell, on ⟨100⟩, followed on its own */
+  const probe = watch.map(r => at(Math.round(r), 0, 0));
+  const ptrace: number[][] = watch.map((): number[] => []);
+
+  let churn = 0, cn = 0, acn = 0;
+  const pick = new Int32Array(DEG);
+
+  /**
+   * The time average of the deficit, over the second half of the run.
+   *
+   * This is the field the article's laws read, and reading it is not the same
+   * as reading the last tick: a cell holds an INTEGER count, and at r = 20 the
+   * deficit is about one charge, so a single tick is a one-bit sample of a
+   * quantity that is 4% of a charge. §4 measures that noise; everything before
+   * §4 has to average it away or it measures nothing else.
+   */
+  const acc = new Float64Array(C);
+
+  for (let t = 1; t <= T; t++) {
+    nq.fill(0);
+    for (let z = -o; z <= o; z++) for (let y = -o; y <= o; y++) for (let x = -o; x <= o; x++) {
+      const c = at(x, y, z);
+      if (body[c]) continue;
+      const k = rim(x, y, z) ? DEG : q[c];
+      if (!k) continue;
+      if (mode === "round") {
+        const p = phase[c];
+        for (let j = 0; j < k; j++) nq[c + OFF[(p + j) % DEG]]++;
+        phase[c] = (p + k) % DEG;              // the skipped edge walks round
+      } else {
+        for (let i = 0; i < DEG; i++) pick[i] = i;
+        for (let j = DEG - 1; j > 0; j--) {
+          const r = (Math.random() * (j + 1)) | 0;
+          const tv = pick[j]; pick[j] = pick[r]; pick[r] = tv;
+        }
+        for (let j = 0; j < k; j++) nq[c + OFF[pick[j]]]++;
+      }
+    }
+    const tt = q; q = nq; nq = tt;
+
+    if (t > T / 2) {
+      for (let c = 0; c < C; c++) acc[c] += DEG - q[c];
+      acn++;
+      shells.forEach((cells, i) => {
+        let s = 0;
+        for (const c of cells) s += DEG - q[c];
+        trace[i].push(s / cells.length);
+        ptrace[i].push(DEG - q[probe[i]]);
+      });
+      // the vacuum away from the body and away from the rim, sampled coarsely
+      for (let z = -o + 6; z <= o - 6; z += 7) for (let y = -o + 6; y <= o - 6; y += 7)
+        for (let x = -o + 6; x <= o - 6; x += 7) {
+          if (R >= 0 && Math.sqrt(x * x + y * y + z * z) < o * 0.6) continue;
+          churn += Math.abs(q[at(x, y, z)] - DEG); cn++;
+        }
+    }
+  }
+
+  for (let c = 0; c < C; c++) acc[c] /= acn;
+  return { q, acc, o, L, at, churn: churn / cn, trace, ptrace, ticks: acn };
+};
+
+// —— reading it ——————————————————————————————————————————————————————————————
+
+/**
+ * Every cell of the Euclidean shell of radius r, half a cell either side, as
+ * [time-averaged deficit, cos of the angle to the nearest axis of each family].
+ *
+ * Everything in §2 and §3 is a weighted average over this one list.
+ */
+const ring = (s: ReturnType<typeof sim>, r: number) => {
+  const { acc, o, at } = s;
+  const out: { v: number, cos: [number, number, number] }[] = [];
+  for (let z = -o; z <= o; z++) for (let y = -o; y <= o; y++) for (let x = -o; x <= o; x++) {
+    const d = Math.sqrt(x * x + y * y + z * z);
+    if (d < r - 0.5 || d > r + 0.5) continue;
+    const a = [Math.abs(x), Math.abs(y), Math.abs(z)].sort((p, m) => m - p);
+    out.push({
+      v: acc[at(x, y, z)],
+      cos: [
+        a[0] / d,                                   // to ⟨100⟩
+        (a[0] + a[1]) / (Math.SQRT2 * d),           // to ⟨110⟩
+        (a[0] + a[1] + a[2]) / (Math.sqrt(3) * d),  // to ⟨111⟩
+      ],
+    });
+  }
+  return out;
+};
+
+const shell = (s: ReturnType<typeof sim>, r: number) => mean(ring(s, r).map(c => c.v));
+
+/**
+ * The radial profile of the time-averaged field, at 1/5-cell resolution, so a
+ * cell can be compared against what its OWN distance says rather than against
+ * its shell's mean.
+ *
+ * This matters more than it sounds. A shell one cell thick spans a real change
+ * in the field — at r = 6 the profile falls by about two charges per cell, so
+ * cells at the inner and outer faces of one shell differ by 20% for a reason
+ * that has nothing to do with shape. Measuring anisotropy as the spread around
+ * a shell mean charges that gradient to the lattice. Dividing it out first is
+ * the difference between measuring a sphere and measuring a derivative.
+ */
+const profile = (s: ReturnType<typeof sim>) => {
+  const { acc, o, at } = s, STEP = 0.2;
+  const sum: number[] = [], n: number[] = [];
+  for (let z = -o; z <= o; z++) for (let y = -o; y <= o; y++) for (let x = -o; x <= o; x++) {
+    const i = Math.round(Math.sqrt(x * x + y * y + z * z) / STEP);
+    sum[i] = (sum[i] || 0) + acc[at(x, y, z)]; n[i] = (n[i] || 0) + 1;
+  }
+  // a bin with too few cells in it is its own noise, so widen until it is not
+  return (d: number) => {
+    let i = Math.round(d / STEP), s = 0, c = 0;
+    for (let w = 0; c < 60 && w < 40; w++) {
+      s = 0; c = 0;
+      for (let j = Math.max(0, i - w); j <= i + w; j++) { s += sum[j] || 0; c += n[j] || 0; }
+    }
+    return s / c;
+  };
+};
+
+/**
+ * The deficit in a cone about one direction family, at matched EUCLIDEAN
+ * radius.
+ *
+ * A cone rather than the single cell that sits exactly on the axis: at r = 20
+ * that cell's own time average still carries several percent of noise, and six
+ * of them cannot tell a 2% shape from a 5% wobble. `HALF_ANGLE` of 20° puts a
+ * few hundred cells in each family and leaves the three cones disjoint — ⟨100⟩
+ * and ⟨111⟩ are 54.7° apart, ⟨100⟩ and ⟨110⟩ 45°.
+ *
+ * Matching EUCLIDEAN radius is the whole point: a ⟨111⟩ cell at Euclidean r
+ * sits at Chebyshev r/√3, so a field that was secretly a function of Chebyshev
+ * distance would read the r/√3 shell's value here, which §3 checks outright.
+ */
+const HALF_ANGLE = Math.cos(20 * Math.PI / 180);
+
+const cone = (s: ReturnType<typeof sim>, r: number, fam: 0 | 1 | 2) => {
+  const v = ring(s, r).filter(c => c.cos[fam] >= HALF_ANGLE).map(c => c.v);
+  return v.length ? mean(v) : NaN;
+};
+
+const mean = (a: number[]) => a.reduce((s, v) => s + v, 0) / a.length;
+const sd = (a: number[]) => {
+  const m = mean(a);
+  return Math.sqrt(a.reduce((s, v) => s + (v - m) * (v - m), 0) / a.length);
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+const L = 81, T = 600, R = 3;
+const WATCH = [6, 10, 14, 20];
+
+console.log("HOW ROUND IS THE PRESSURE, AND BY HOW MUCH DOES IT WOBBLE\n");
+console.log(`   ${L}³ box, body of radius ${R}, ${T} ticks, deficit = ${DEG} − q\n`);
+
+const runs: Record<Mode, ReturnType<typeof sim>> = {} as any;
+for (const mode of ["round", "random"] as Mode[]) runs[mode] = sim(L, T, R, mode, WATCH);
+
+console.log("─".repeat(76));
+console.log("1. THE FREE VACUUM IS STATIC — EXACTLY, AND FOR A DULL REASON\n");
+console.log("   Every point full sends 26 and receives 26, for ever. In a box with");
+console.log("   NO body in it there is never a shortfall, so no edge is ever skipped");
+console.log("   and the choice between the two rules is never made. Both read zero,");
+console.log("   which is worth stating because of what it implies: EVERY fluctuation");
+console.log("   below belongs to the body's well, and none of it to the vacuum.\n");
+console.log("   which edge is skipped     mean |q − 26|   as a fraction");
+for (const mode of ["round", "random"] as Mode[]) {
+  const c = sim(41, 200, -1, mode).churn;
+  console.log("   " + (mode === "round" ? "walks round the point" : "picked at random    ")
+    + c.toFixed(4).padStart(14) + (c / DEG).toFixed(5).padStart(16));
+}
+console.log();
+
+console.log("─".repeat(76));
+console.log("2. THE PROFILE IS 1/r\n");
+console.log("   Against A(1/r − 1/R) fitted on r ≥ 8 — the potential whose gradient");
+console.log("   is the inverse square, with nobody writing either down.\n");
+{
+  const s = runs.round;
+  const rs = [4, 6, 8, 10, 13, 16, 20, 24, 28];
+  const d = rs.map(r => shell(s, r));
+  // two-parameter least squares on A(1/r) + B, with R = −A/B
+  const fit = rs.map((r, i) => [1 / r, d[i]] as const).filter((_, i) => rs[i] >= 8);
+  const n = fit.length;
+  const sx = fit.reduce((t, [x]) => t + x, 0), sy = fit.reduce((t, [, y]) => t + y, 0);
+  const sxx = fit.reduce((t, [x]) => t + x * x, 0), sxy = fit.reduce((t, [x, y]) => t + x * y, 0);
+  const A = (n * sxy - sx * sy) / (n * sxx - sx * sx), B = (sy - A * sx) / n;
+  console.log(`   A = ${A.toFixed(3)}   R = ${(-A / B).toFixed(1)} cells (the box is ${L})\n`);
+  console.log("        r     deficit    A(1/r−1/R)     ratio");
+  rs.forEach((r, i) => {
+    const p = A / r + B;
+    console.log("      " + String(r).padStart(3) + d[i].toFixed(4).padStart(12)
+      + p.toFixed(4).padStart(14) + (d[i] / p).toFixed(3).padStart(10));
+  });
+}
+console.log();
+
+console.log("─".repeat(76));
+console.log("3. AND THE SHAPE IS A SPHERE, NOT THE CUBE THE FRONT IS\n");
+console.log("   Each direction family, in a 20° cone at matched EUCLIDEAN radius,");
+console.log("   over the shell mean there. 1.000 is round; the spread is the shape.");
+console.log("   Read off the TIME-AVERAGED field, which is what §4 says it has to be.\n");
+{
+  const s = runs.round;
+  console.log("        r    shell     ⟨100⟩    ⟨110⟩    ⟨111⟩     spread");
+  for (const r of [6, 8, 10, 14, 20, 26]) {
+    const sh = shell(s, r);
+    const f = ([0, 1, 2] as const).map(v => cone(s, r, v) / sh);
+    console.log("      " + String(r).padStart(3) + sh.toFixed(4).padStart(9)
+      + f.map(v => v.toFixed(3).padStart(9)).join("")
+      + ((Math.max(...f) - Math.min(...f)) * 100).toFixed(1).padStart(10) + "%");
+  }
+  console.log();
+  console.log("   The test that separates a sphere from a cube: a field that were");
+  console.log("   really a function of CHEBYSHEV distance would put a ⟨111⟩ cell at");
+  console.log("   Euclidean r at the r/√3 value, because that is its Chebyshev");
+  console.log("   distance. So compare, at each r:\n");
+  console.log("        r    ⟨111⟩ at r    shell at r/√3    shell at r");
+  for (const r of [10, 14, 20, 26]) {
+    console.log("      " + String(r).padStart(3)
+      + cone(s, r, 2).toFixed(4).padStart(13)
+      + shell(s, r / Math.sqrt(3)).toFixed(4).padStart(17)
+      + shell(s, r).toFixed(4).padStart(14));
+  }
+}
+console.log();
+
+console.log("─".repeat(76));
+console.log("4. AND HERE IS THE WOBBLE\n");
+console.log("   The same shells watched every tick of the second half. `shell` is");
+console.log("   the mean over the whole shell, `cell` one ⟨100⟩ cell on it, and the");
+console.log("   spread is over the last half of the run.\n");
+for (const mode of ["round", "random"] as Mode[]) {
+  const s = runs[mode];
+  console.log(`   ${mode === "round" ? "skipped edge walks round the point" : "skipped edge picked at random"}\n`);
+  console.log("        r   shell mean   shell sd    shell %    cell sd    cell %");
+  WATCH.forEach((r, i) => {
+    const tr = s.trace[i], pt = s.ptrace[i];
+    const m = mean(tr);
+    console.log("      " + String(r).padStart(3) + m.toFixed(4).padStart(13)
+      + sd(tr).toFixed(4).padStart(11) + (100 * sd(tr) / m).toFixed(2).padStart(10) + "%"
+      + sd(pt).toFixed(4).padStart(11) + (100 * sd(pt) / Math.abs(mean(pt))).toFixed(1).padStart(9) + "%");
+  });
+  console.log();
+}
+
+console.log("   and the same wobble read in ANGLE rather than in time — how much the");
+console.log("   cells AROUND one shell differ from each other, which is the SHAPE");
+console.log("   fluctuating rather than the size. Two readings of it: one instant,");
+console.log("   and the average of all " + runs.round.ticks + " ticks. If the shape were really");
+console.log("   ragged the second would be as big as the first; if the raggedness is");
+console.log("   noise it falls as 1/√n, and the last column is what it would be if");
+console.log("   it were pure noise. Every cell is divided by the radial profile at");
+console.log("   its own distance first, so the shell's own gradient is not counted.\n");
+{
+  const s = runs.round, { q, o, at } = s, p = profile(s);
+  console.log("        r   shell mean    one tick   averaged    if noise");
+  for (const r of WATCH) {
+    const now: number[] = [], av: number[] = [];
+    for (let z = -o; z <= o; z++) for (let y = -o; y <= o; y++) for (let x = -o; x <= o; x++) {
+      const d = Math.sqrt(x * x + y * y + z * z);
+      if (d < r - 0.5 || d > r + 0.5) continue;
+      // each cell against the profile at its OWN distance, so the shell's own
+      // radial gradient is not counted as a departure from roundness
+      const e = p(d);
+      now.push((DEG - q[at(x, y, z)]) / e); av.push(s.acc[at(x, y, z)] / e);
+    }
+    console.log("      " + String(r).padStart(3) + shell(s, r).toFixed(4).padStart(13)
+      + (100 * sd(now)).toFixed(1).padStart(11) + "%"
+      + (100 * sd(av)).toFixed(1).padStart(10) + "%"
+      + (100 * sd(now) / Math.sqrt(s.ticks)).toFixed(1).padStart(11) + "%");
+  }
+}
+console.log();
+
+console.log("─".repeat(76));
+console.log("WHAT THIS SETTLES");
+console.log("  · the sentence is right, and BOTH halves of it are large. The");
+console.log("    instantaneous shape is not a sphere and is not near one: cells on one");
+console.log("    shell differ from each other by 28% at r = 6 and by 106% at r = 20,");
+console.log("    with the shell's own radial gradient already divided out.");
+console.log("  · and the wobble grows with distance for an arithmetic reason, not a");
+console.log("    physical one. The scatter is about ONE CHARGE per cell at every");
+console.log("    radius (1.68, 1.46, 1.40, 1.01 at r = 6, 10, 14, 20) while the deficit");
+console.log("    it sits on falls as 1/r — so the RELATIVE wobble goes as r, and passes");
+console.log("    100% at the radius where the deficit drops below one whole charge.");
+console.log("  · what is spherical is the AVERAGE. Over 300 ticks the same angular");
+console.log("    scatter falls to 0.8–1.3%, at or under the 1/√n a pure noise would");
+console.log("    give — so it is noise, and it averages away slightly FASTER than");
+console.log("    independent noise would, the relay being conserving rather than free.");
+console.log("  · the shape is round to about 1% by r = 10 and the lattice survives only");
+console.log("    near in: the ⟨100⟩/⟨110⟩/⟨111⟩ spread is 3.7% at r = 6 and 5.4% at");
+console.log("    r = 8, under 1.3% at every radius beyond. A near-field term, not a");
+console.log("    shape — which is exactly what FLOOR is for.");
+console.log("  · and it is a sphere rather than the cube the FRONT is: a field that");
+console.log("    were a function of Chebyshev distance would read 3.63 at ⟨111⟩,");
+console.log("    r = 20, being the r/√3 shell. Measured, 1.088, against a shell mean");
+console.log("    of 1.084. The front is a cube; the field is round.");

From 24f5a3c7ec6b0de22a449debdb5c68850adc29e5 Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sat, 15 Aug 2026 00:48:40 +0200
Subject: [PATCH 46/47] Working on the wobble derevation

---
 orbitmines.com/next-env.d.ts                  |   2 +-
 orbitmines.com/src/routes/Physics.tsx         |  64 +++++++---
 .../archive/2026.RayCalculiAndPhysics/law.tsx |  17 +++
 .../2026.RayCalculiAndPhysics/tests/README.md |   2 +-
 .../2026.RayCalculiAndPhysics/tests/sphere.ts | 115 +++++++++++++++---
 5 files changed, 165 insertions(+), 35 deletions(-)

diff --git a/orbitmines.com/next-env.d.ts b/orbitmines.com/next-env.d.ts
index 1af4799..6ead643 100644
--- a/orbitmines.com/next-env.d.ts
+++ b/orbitmines.com/next-env.d.ts
@@ -1,5 +1,5 @@
 /// <reference types="next" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index aa881ec..8e51cb3 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -14,7 +14,7 @@ import {
   B, Bar, Because, CEILING, CLOCK, COHERENT, CONSTANTS, D, Eq, F, Frac, FULL, Hat, Head,
   IDENTICAL,
   IGNORANCE, K, Law, LAW, MADE_FROM, MEETINGS, MET, METRIC, Paren, R, REACH, RECORD, Rows,
-  SPACE, Step, Sub, Sup, TURNS, V,
+  SPACE, Step, Sub, Sup, TURNS, Type, V,
 } from "./archive/2026.RayCalculiAndPhysics/law";
 import { gravitational, massUnit } from "./archive/2026.RayCalculiAndPhysics/gravity";
 import { lineGroups } from "./archive/2026.RayCalculiAndPhysics/lines";
@@ -234,7 +234,9 @@ const Physics = () => {
 
         <BR/>
 
-        Next up we have dimensions, now the trouble with this, is that generally we could have a fraction in this number. So one would only be able to make a judgement on this number locally, or regionally. Instead these following variables will only be judged locally always (the current position). We denote that with a 'l.' in front of the variable. Unless otherwise mentioned the local variable has a default, which is the same variable name without the 'l.'.
+        <Para>
+           Next up we have dimensions, now the trouble with this, is that generally we could have a fraction in this number. So one would only be able to make a judgement on this number locally, or regionally. Instead these following variables will only be judged locally always (the current position). We denote that with a 'l.' in front of the variable. Unless otherwise mentioned the local variable has a default, which is the same variable name without the 'l.'. <span className="bp5-text-muted">(Local variables are also time-aware - as if it's the node's state at some point in time.)</span>
+        </Para>
 
         <Eq>
           <F>l.</F><K><Bar>D</Bar></K> = number of dimensions
@@ -367,35 +369,59 @@ const Physics = () => {
           
           <Head>The inverse square law</Head>
 
-          The discrete model will tell us that there will be constant fluctuations of the shape of the pressure gravity is exerting, but that those fluctuations will average out to a sphere. And we can measure both halves of that rather than assert them — <code>tests/sphere.ts</code> puts one absorber in an 81<Sup>3</Sup> box, lets it settle for 600 ticks, and reads the shortfall it digs.
+          The discrete model will tell us that there will be constant fluctuations of the shape of the pressure gravity is exerting, but that those fluctuations will average out to a sphere. And we can measure both halves of that rather than assert them.
 
           <BR/>
 
-          <Para>
-            <b>The instantaneous shape is not a sphere and is nowhere near one.</b> Cells sitting on the same shell, with that shell's own radial gradient divided out first, differ from each other by <b>28% at <V>r</V> = 6 and 106% at <V>r</V> = 20</b> — and the growth is arithmetic rather than physical. The scatter is about <i>one charge per cell</i> at every radius (1.68, 1.46, 1.40, 1.01 at <V>r</V> = 6, 10, 14, 20) while the deficit it sits on falls as 1/<V>r</V>, so the fluctuation <i>relative</i> to the thing being measured grows in proportion to <V>r</V> and crosses 100% at the radius where the deficit drops under one whole charge. A cell holds an integer; far out, the field it is asked to carry is a fraction of one.
-          </Para>
+          <Eq note={<><F>l.</F> is a time aware node</>}>
+            <Type of={<><F>l.</F><D>#active?</D></>} is={<>0..<F>l.</F><K><Bar>DEG</Bar></K></>} /> = <span style={{ fontSize: '1.3em' }}>Σ</span><Sub><V>ray</V> ∈ <F>l.</F><D>rays</D></Sub> <Type of={<><V>ray</V>.<D>active?</D></>} is={<>0 | 1</>} />
+          </Eq>
+
+          <Eq note={<><V>ray</V>.<D>terminal</D> is the neighbour the ray points at, and its <D>#active?</D> is what it had to send. A node makes <D>#active?</D> of its rays active and skips the rest, so any one of them carries with chance <D>terminal</D>.<D>#active?</D>/<F>l.</F><K><Bar>DEG</Bar></K> — and ⟨ ⟩, which is the only place in this section anything is averaged over ticks, a node is the mean of its neighbours. This is the only line that follows a ray past its own end; it is what makes the field harmonic, and everything below rests on it. The gap between the count and its mean is the grain <D>wobble</D> measures</>}>
+            ⟨<F>l.</F><D>#active?</D>⟩ =
+            <Frac over={<>1</>} under={<><F>l.</F><K><Bar>DEG</Bar></K></>} />
+            <span style={{ fontSize: '1.3em' }}>Σ</span><Sub><V>ray</V> ∈ <F>l.</F><D>rays</D></Sub>
+            <V>ray</V>.<D>terminal</D>.<D>#active?</D>
+          </Eq>
+
+          <Eq note={<>nothing is chosen here, it is the lattice. A node's next <F>l.</F><D>#active?</D> is the <i>mean</i> of its neighbours', which is a walk taking one step a tick uniformly over the 26 rays; 18 of the rays step <D>dx</D> = ±1 along a given axis and 8 step <D>dx</D> = 0, so a step has variance 18/26 an axis, and a diffusivity is half a step variance. The sum is a mean over the node's own rays and nothing is averaged over time here, which is why it carries no ⟨ ⟩. Lowercase, and not <F>l.</F><K><Bar>D</Bar></K>, which is already the number of dimensions</>}>
+            <F>l.</F><D>spread</D> =
+            <Frac over={<>1</>} under={<>2<F>l.</F><K><Bar>DEG</Bar></K></>} />
+            <span style={{ fontSize: '1.3em' }}>Σ</span><Sub><V>ray</V> ∈ <F>l.</F><D>rays</D></Sub>
+            <V>ray</V>.<D>dx</D><Sup>2</Sup>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            <Frac over={<>9</>} under={<>26</>} />
+          </Eq>
+
+          <Eq note={<>the body takes and sends nothing, so every charge that lands on it is destroyed. Two ways of counting the same number: on the left, read at the destination — every node <V>p</V> the body occupies, and what landed on it. On the right, read at the source — every ray out of every body node, each pulling <D>terminal</D>.<D>#active?</D>/<F>l.</F><K><Bar>DEG</Bar></K> back in and sending nothing the other way. A <D>terminal</D> that is itself body has no active rays and so contributes nothing, which is what makes the two sums the same number. Measured at 354.5 a tick for a radius-3 body of 123 nodes — and it is a <i>surface</i> quantity rather than a volume one, since 925 nodes eat only 865: an interior node is shadowed and eats nothing, so <F>l.</F><D>sink</D> grows about like the body's radius rather than like its count</>}>
+            <F>l.</F><D>sink</D> =
+            <span style={{ fontSize: '1.3em' }}>Σ</span><Sub><V>p</V> ∈ body</Sub> <V>p</V>.<D>#active?</D>
+            <span style={{ padding: '0 1.2em', color: FAINT }}>=</span>
+            <Frac over={<>1</>} under={<><F>l.</F><K><Bar>DEG</Bar></K></>} />
+            <span style={{ fontSize: '1.3em' }}>Σ</span><Sub><V>p</V> ∈ body</Sub>
+            <span style={{ fontSize: '1.3em' }}>Σ</span><Sub><V>ray</V> ∈ <V>p</V>.<D>rays</D></Sub>
+            <V>ray</V>.<D>terminal</D>.<D>#active?</D>
+          </Eq>
+
+          <Eq note={<>and the amplitude of the well is the body's <i>appetite</i>, its rate of destruction over the medium's willingness to carry. Measured, <F>l.</F><D>well</D>/<F>l.</F><D>sink</D> = 0.206 over bodies from 33 to 925 nodes — a 4.5× range of <F>l.</F><D>sink</D> — against 1/4π<F>l.</F><D>spread</D> = 0.230, the 11% being the fit band and the lattice's own Green's function rather than the continuum's. <V>p</V>.<D>r</D> is how far the node sits from the body</>}>
+            <F>l.</F><D>well</D> =
+            <Frac over={<><F>l.</F><D>sink</D></>} under={<>4π<F>l.</F><D>spread</D></>} />
+            <span style={{ padding: '0 1.2em', color: FAINT }}>so</span>
+            <F>l.</F><K><Bar>DEG</Bar></K> − <V>p</V>.<D>#active?</D> =
+            <F>l.</F><D>well</D>(1/<V>p</V>.<D>r</D> − 1/<V>R</V>)
+          </Eq>
 
-          <Eq note={<>one charge of grain on a shortfall going as 1/<V>r</V>, thinned by the ticks averaged over</>}>
-            wobble(<V>r</V>,<V>n</V>) ≈
+          <Eq note={<>one charge of grain on the shortfall itself — <F>l.</F><K><Bar>DEG</Bar></K> − <F>l.</F><D>#active?</D> is how many of a node's rays stayed idle, so how many charges short of full a node at <V>r</V> is, measured in §2 at <F>l.</F><D>well</D> = 70.3 and <V>R</V> = 29.5 cells — thinned by the <V>n</V> ticks averaged over. The <V>r</V> on the right is that 1/<V>r</V> inverted, and holds while <V>r</V> ≪ <V>R</V></>}>
+            <D>wobble</D>(<V>r</V>,<V>n</V>) ≈
             <Frac
               over={<>1 charge</>}
-              under={<>deficit(<V>r</V>) · √<V>n</V></>}
+              under={<><F>l.</F><D>well</D>(1/<V>r</V> − 1/<V>R</V>) · √<V>n</V></>}
             />
             <span style={{ padding: '0 1.4em' }} />
             ∝
             <Frac over={<><V>r</V></>} under={<>√<V>n</V></>} />
           </Eq>
 
-          <Para>
-            <b>And the average of it is round.</b> Over 300 ticks the same angular scatter falls to <b>0.8–1.3%</b> at every radius — at or below the 1/√<V>n</V> that independent noise would give, because a relay that conserves what it carries averages slightly better than a free one. What does <i>not</i> average away is the lattice, and it is only near in: the ⟨100⟩, ⟨110⟩ and ⟨111⟩ cones agree to within <b>3.7% at <V>r</V> = 6, 5.4% at <V>r</V> = 8, and under 1.3% everywhere beyond <V>r</V> = 10</b>. That residual is a near-field term rather than a shape, which is what <K><Bar>FLOOR</Bar></K> below is for.
-          </Para>
-
-          <BR/>
-
-          <Para>
-            Two things that fall out of the same run and are worth having early. The empty box is <i>exactly</i> static — with every point full there is never a shortfall, so no edge is ever skipped and the vacuum has no choice to make — meaning <b>every fluctuation above belongs to the body's well and none of it to the medium</b>. And the roundness is a real sphere rather than the cube the front actually is: a field that were secretly a function of Chebyshev distance would read the <V>r</V>/√3 shell's value along ⟨111⟩, which at <V>r</V> = 20 is 3.63. Measured, it is 1.088, against a shell mean of 1.084.
-          </Para>
-
 
 
 
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
index 2858600..42e6e85 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/law.tsx
@@ -105,6 +105,23 @@ export const Frac = ({ over, under }: { over: ReactNode, under: ReactNode }) =>
   </span>
 );
 
+/**
+ * A term with its type set quietly underneath it, the way a signature reads.
+ *
+ * Not a fraction and so no rule line: `of` is the thing, `is` is what it
+ * ranges over. Used where a name would otherwise need a sentence after it to
+ * say what kind of number comes back.
+ */
+export const Type = ({ of, is }: { of: ReactNode, is: ReactNode }) => (
+  <span style={{
+    display: 'inline-flex', flexDirection: 'column', alignItems: 'center',
+    verticalAlign: 'middle', lineHeight: 1.15, margin: '0 0.15em',
+  }}>
+    <span>{of}</span>
+    <span style={{ fontSize: '0.66em', color: FAINT, fontStyle: 'normal', marginTop: '0.15em' }}>{is}</span>
+  </span>
+);
+
 /**
  * Brackets big enough for what is inside them.
  *
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
index 17b8893..ea67f62 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
@@ -33,7 +33,7 @@ than as silent agreement.
 | `wave` | **the same lattice propagating as a wave instead of a ray** — the front is a circle at the sound speed and the grain vanishes as the pulse widens |
 | `lattices` | **which space gives a sphere** — a sweep of spatial constructions against the spherical-design condition, and the shell search that finds 26 directions exact through rank 6 |
 | `veined` | **what every law becomes if the field is veined rather than shell-averaged** — the radial law survives exactly, the Solar System kills it, galaxies cannot see it |
-| `sphere` | **how round the pressure is, and by how much it wobbles** — the instantaneous shape is 28–106% ragged, the average of it is a sphere to 1%, and the lattice survives only inside r ≈ 8 |
+| `sphere` | **how round the pressure is, and by how much it wobbles** — the per-cell instantaneous scatter is 28–106% but that is the *counting floor* (1.03–1.11× √Σp(1−p), both rules), one tick read at 26-patch resolution is already round to 10–15%, the average is a sphere to 0.1–0.5%, and the lattice survives only inside r ≈ 8 |
 | `cones` | **is there a rule with nothing tuned that gives a sphere** — no, and in 3D no `w` can, plus what each candidate rule does to every published number |
 
 ### the force law
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sphere.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sphere.ts
index 0468984..eb09764 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sphere.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/sphere.ts
@@ -30,6 +30,11 @@
  *       the front actually is
  *   §4  THE WOBBLE: the same shells watched tick by tick, so "fluctuates" gets
  *       a number — per cell and per shell, in time and in angle
+ *   §5  AND WHAT THAT WOBBLE IS: grain or shape. A single cell holding an
+ *       integer cannot carry 1.08 of a charge, so its scatter is arithmetic
+ *       before it is anything else. §5 separates the two by asking the same
+ *       instant at coarser angular resolution, and against the shot-noise
+ *       floor a counting relay is owed.
  *
  * Run: ./run.sh sphere
  */
@@ -144,7 +149,7 @@ const sim = (L: number, T: number, R: number, mode: Mode, watch: number[] = [])
   }
 
   for (let c = 0; c < C; c++) acc[c] /= acn;
-  return { q, acc, o, L, at, churn: churn / cn, trace, ptrace, ticks: acn };
+  return { q, acc, o, L, at, body, OFF, rim, churn: churn / cn, trace, ptrace, ticks: acn };
 };
 
 // —— reading it ——————————————————————————————————————————————————————————————
@@ -361,21 +366,103 @@ console.log("   its own distance first, so the shell's own gradient is not count
 }
 console.log();
 
+console.log("─".repeat(76));
+console.log("5. AND THAT RAGGEDNESS IS GRAIN, NOT SHAPE\n");
+console.log("   §4's angular column is a per-CELL number, and a cell is the worst");
+console.log("   instrument in the box: it holds an integer, and at r = 20 it is being");
+console.log("   asked to carry 1.084 of a charge. Two readings decide whether the");
+console.log("   raggedness is a fluctuating SHAPE or the arithmetic of counting.\n");
+console.log("   FIRST — against the floor. A cell's neighbour holding k sends one charge");
+console.log("   down each of k edges out of 26, so the count arriving is a sum of 26");
+console.log("   draws with p = k/26, and even a perfectly round field must scatter by");
+console.log("   √Σp(1−p). That floor is not fitted: it is read off the neighbours'");
+console.log("   own occupancies in the final state. In charges, not percent:\n");
+{
+  console.log("        r    shell mean   scatter/cell   shot-noise floor   measured/floor");
+  for (const mode of ["round", "random"] as Mode[]) {
+    const s = runs[mode], { q, o, at, body, OFF } = s, p = profile(s);
+    console.log(`     ${mode === "round" ? "walks round the point" : "picked at random"}`);
+    for (const r of WATCH) {
+      const dev: number[] = [], floor: number[] = [];
+      for (let z = -o; z <= o; z++) for (let y = -o; y <= o; y++) for (let x = -o; x <= o; x++) {
+        const d = Math.sqrt(x * x + y * y + z * z);
+        if (d < r - 0.5 || d > r + 0.5) continue;
+        const c = at(x, y, z);
+        dev.push((DEG - q[c]) - p(d));           // departure from the round field
+        let v = 0;                               // and what counting alone owes it
+        for (let i = 0; i < DEG; i++) {
+          const n = c + OFF[i];
+          const k = body[n] ? 0 : s.rim(x + DIR[i][0], y + DIR[i][1], z + DIR[i][2]) ? DEG : q[n];
+          v += (k / DEG) * (1 - k / DEG);
+        }
+        floor.push(Math.sqrt(v));
+      }
+      const m = Math.sqrt(mean(floor.map(v => v * v))), got = sd(dev);
+      console.log("      " + String(r).padStart(3) + shell(s, r).toFixed(4).padStart(13)
+        + got.toFixed(3).padStart(15) + m.toFixed(3).padStart(19)
+        + (got / m).toFixed(2).padStart(17));
+    }
+  }
+}
+console.log();
+console.log("   SECOND — the same instant, asked at an angular resolution a cell cannot");
+console.log("   give. Each shell is cut into 26 patches (nearest lattice direction) and");
+console.log("   the patch is averaged before the spread is taken. Grain falls as 1/√m");
+console.log("   with the patch size m; a shape does not fall at all. The averaged");
+console.log("   column is the SAME patches over all " + runs.round.ticks + " ticks — the residual shape.\n");
+{
+  const s = runs.round, { q, acc, o, at } = s, p = profile(s);
+  const HAT = DIR.map(([x, y, z]) => { const n = Math.hypot(x, y, z); return [x / n, y / n, z / n]; });
+  console.log("        r    m    per cell    per patch    if grain    averaged");
+  for (const r of WATCH) {
+    const now = DIR.map((): number[] => []), av = DIR.map((): number[] => []);
+    const cell: number[] = [];
+    for (let z = -o; z <= o; z++) for (let y = -o; y <= o; y++) for (let x = -o; x <= o; x++) {
+      const d = Math.sqrt(x * x + y * y + z * z);
+      if (d < r - 0.5 || d > r + 0.5) continue;
+      let best = 0, bd = -2;
+      for (let i = 0; i < DEG; i++) {
+        const t = (x * HAT[i][0] + y * HAT[i][1] + z * HAT[i][2]) / d;
+        if (t > bd) { bd = t; best = i; }
+      }
+      const e = p(d), c = at(x, y, z);
+      now[best].push((DEG - q[c]) / e); av[best].push(acc[c] / e);
+      cell.push((DEG - q[c]) / e);
+    }
+    const m = cell.length / DEG;
+    const pn = now.filter(v => v.length).map(mean), pa = av.filter(v => v.length).map(mean);
+    console.log("      " + String(r).padStart(3) + Math.round(m).toString().padStart(5)
+      + (100 * sd(cell)).toFixed(1).padStart(11) + "%"
+      + (100 * sd(pn)).toFixed(1).padStart(12) + "%"
+      + (100 * sd(cell) / Math.sqrt(m)).toFixed(1).padStart(11) + "%"
+      + (100 * sd(pa)).toFixed(1).padStart(11) + "%");
+  }
+}
+console.log();
+
 console.log("─".repeat(76));
 console.log("WHAT THIS SETTLES");
-console.log("  · the sentence is right, and BOTH halves of it are large. The");
-console.log("    instantaneous shape is not a sphere and is not near one: cells on one");
-console.log("    shell differ from each other by 28% at r = 6 and by 106% at r = 20,");
-console.log("    with the shell's own radial gradient already divided out.");
-console.log("  · and the wobble grows with distance for an arithmetic reason, not a");
-console.log("    physical one. The scatter is about ONE CHARGE per cell at every");
-console.log("    radius (1.68, 1.46, 1.40, 1.01 at r = 6, 10, 14, 20) while the deficit");
-console.log("    it sits on falls as 1/r — so the RELATIVE wobble goes as r, and passes");
-console.log("    100% at the radius where the deficit drops below one whole charge.");
-console.log("  · what is spherical is the AVERAGE. Over 300 ticks the same angular");
-console.log("    scatter falls to 0.8–1.3%, at or under the 1/√n a pure noise would");
-console.log("    give — so it is noise, and it averages away slightly FASTER than");
-console.log("    independent noise would, the relay being conserving rather than free.");
+console.log("  · the sentence is right, and the first half of it is a statement about");
+console.log("    the INSTRUMENT rather than about the shape. Cells on one shell differ");
+console.log("    from each other at one tick by 28% at r = 6 and 106% at r = 20, with");
+console.log("    the radial gradient already divided out — but a cell holds an INTEGER,");
+console.log("    and at r = 20 it is being asked to carry 1.084 of a charge.");
+console.log("  · that scatter is the counting floor and not a shape. In charges it is");
+console.log("    2.62, 2.14, 1.63, 1.15 at r = 6, 10, 14, 20, against a shot-noise floor");
+console.log("    √Σp(1−p) — what a PERFECTLY round field would still scatter by — of");
+console.log("    2.41, 1.94, 1.56, 1.11. Measured over floor: 1.03–1.11, on both rules.");
+console.log("    The 28% and the 106% are one charge of grain divided by a deficit");
+console.log("    falling as 1/r, which is why the RELATIVE wobble goes as r and passes");
+console.log("    100% where the deficit drops below one whole charge.");
+console.log("  · and asked at an angular resolution a cell can actually give — 26");
+console.log("    patches of m = 17…194 cells — a SINGLE TICK is already round to");
+console.log("    10–15%. The raggedness is grain; the shape under it never leaves.");
+console.log("  · what is spherical is the AVERAGE, and it is spherical to well under a");
+console.log("    percent: over 300 ticks the angular scatter falls to 0.8–1.3% per cell");
+console.log("    and 0.1–0.5% per patch, at or under the 1/√n a pure noise would give");
+console.log("    — it averages away slightly FASTER than independent noise would, the");
+console.log("    relay being conserving rather than free. A shape would not average");
+console.log("    away at all; this does.");
 console.log("  · the shape is round to about 1% by r = 10 and the lattice survives only");
 console.log("    near in: the ⟨100⟩/⟨110⟩/⟨111⟩ spread is 3.7% at r = 6 and 5.4% at");
 console.log("    r = 8, under 1.3% at every radius beyond. A near-field term, not a");

From b9777f252e8ddb03772a8503bf40a3d49f1685bc Mon Sep 17 00:00:00 2001
From: Fadi Shawki <fadi.shawki@orbitmines.com>
Date: Sun, 16 Aug 2026 00:14:07 +0200
Subject: [PATCH 47/47] Magnetism, efficiency, thinking visualizations

---
 orbitmines.com/next-env.d.ts                  |   2 +-
 orbitmines.com/src/routes/Physics.tsx         | 676 +++++++++++++++++-
 .../2026.RayCalculiAndPhysics/counts.tsx      | 192 +++++
 .../2026.RayCalculiAndPhysics/models.ts       |   4 +-
 .../2026.RayCalculiAndPhysics/rotation.tsx    | 180 +++--
 .../2026.RayCalculiAndPhysics/shelter.tsx     | 315 ++++++++
 .../2026.RayCalculiAndPhysics/sketch.tsx      | 342 +++++++++
 .../2026.RayCalculiAndPhysics/tests/README.md |  81 ++-
 .../tests/aggregate.ts                        | 320 +++++++++
 .../2026.RayCalculiAndPhysics/tests/align.ts  | 299 ++++++++
 .../2026.RayCalculiAndPhysics/tests/bloch.ts  | 280 ++++++++
 .../tests/departure.ts                        | 232 ++++++
 .../2026.RayCalculiAndPhysics/tests/divp.ts   | 331 +++++++++
 .../tests/domains.ts                          | 316 ++++++++
 .../tests/domainsize.ts                       | 221 ++++++
 .../2026.RayCalculiAndPhysics/tests/escape.ts | 276 +++++++
 .../tests/exchange.ts                         | 462 ++++++++++++
 .../tests/extrapolate.ts                      | 302 ++++++++
 .../tests/feedback.ts                         | 278 +++++++
 .../tests/holonomy.ts                         | 313 ++++++++
 .../tests/maxwell.ts                          |  80 ++-
 .../tests/permute.ts                          | 289 ++++++++
 .../tests/response.ts                         | 248 +++++++
 .../2026.RayCalculiAndPhysics/tests/ring.ts   | 193 +++++
 .../2026.RayCalculiAndPhysics/tests/run.sh    |   4 +-
 .../tests/texture.ts                          | 356 +++++++++
 26 files changed, 6494 insertions(+), 98 deletions(-)
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/counts.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/shelter.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/sketch.tsx
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/aggregate.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/align.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/bloch.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/departure.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/divp.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/domains.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/domainsize.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/escape.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/exchange.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/extrapolate.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/feedback.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/holonomy.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/permute.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/response.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ring.ts
 create mode 100644 orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/texture.ts

diff --git a/orbitmines.com/next-env.d.ts b/orbitmines.com/next-env.d.ts
index 6ead643..1af4799 100644
--- a/orbitmines.com/next-env.d.ts
+++ b/orbitmines.com/next-env.d.ts
@@ -1,5 +1,5 @@
 /// <reference types="next" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
diff --git a/orbitmines.com/src/routes/Physics.tsx b/orbitmines.com/src/routes/Physics.tsx
index 8e51cb3..e7ec24a 100644
--- a/orbitmines.com/src/routes/Physics.tsx
+++ b/orbitmines.com/src/routes/Physics.tsx
@@ -31,6 +31,12 @@ import {
   BarField, Ceiling, Fields, Kinds, Ladder, Lopsided, Pairs,
 } from "./archive/2026.RayCalculiAndPhysics/magnetism";
 
+// The lattice actually running — `vacuum.tsx` steps the rule of `tests/sphere.ts`
+// and measures what the vacuum does to gravity; `counts.tsx` is the arithmetic
+// those runs are read against. Both draw through `sketch.tsx` onto `canvas.tsx`.
+import { Shelter } from "./archive/2026.RayCalculiAndPhysics/shelter";
+import { Exits, Shells } from "./archive/2026.RayCalculiAndPhysics/counts";
+
 /** The colour the rest of the article uses for an aside inside a set line. */
 const FAINT = '#6c7080';
 
@@ -1654,9 +1660,13 @@ const Physics = () => {
             [<>what the signs buy</>,
               <>The sign law (1 − <V>P</V><Sub>a</Sub><V>P</V><Sub>b</Sub>), which explains
                 the ½ that was already sitting unexplained inside <V>G</V>. Magnetisation
-                quantised in quarters. ∇·<B>B</B> = 0 and no monopoles. The dipole
+                quantised in quarters — <i>on a face axis</i>; the equator of a corner axis
+                has six members and quantises in thirds, and an edge axis has no uniform
+                dwell at all. ∇·<B>B</B> = 0 and no monopoles. The dipole
                 3cos²<V>θ</V> − 1 and the 1/<V>R</V><Sup>4</Sup> force. That cutting a magnet
-                halves it. That the lightest constituent wins by the square.</>],
+                halves it — which holds for the emitted sign read as −<V>∇</V>·<b>p</b> and
+                fails for a sign assigned by which half of the body a node sits in. That the
+                lightest constituent wins by the square.</>],
             [<>what they cost</>,
               <>One coupling — 4.5·10<Sup>7</Sup> kg/m² of pole face — measured rather than
                 counted. And three refutations: <V>g</V> = 1, the flat 11.1% anisotropy, and
@@ -1714,7 +1724,88 @@ const Physics = () => {
 
       <Section head="AI Generated">
 
-        
+        <Section head="Why two things fall together">
+
+          <Para>
+            Everything else in this arc is a measurement. This is the mechanism,
+            at the scale you can watch it happen — and it is worth seeing before
+            any of the arithmetic, because the arithmetic is only a way of
+            counting what is going on in this picture.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>Space is full of charges going in every direction, all the
+            time.</b> A body eats the ones that reach it. So a body is a{' '}
+            <i>shadow</i>, and two of them stand in each other's — each is hit
+            less on the side facing the other, and being hit less on one side is
+            being pushed toward it.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            There is no attraction anywhere in that, and <b>nothing crosses the
+            gap</b>. Each body is pushed inward from outside, by rain that is{' '}
+            <i>missing</i> rather than by anything that arrives.
+          </Para>
+
+          <Shelter />
+
+          <Para>
+            The rule is unchanged — <i>tests/sphere.ts</i>'s exactly, run one
+            tick every few frames so the charges can be drawn sliding from the
+            cell they left to the cell they land on. Every dot is one of the
+            actual charges, sampled down to a number the eye can follow; the
+            orange ones are being eaten. The blue outline on each body is where
+            its hits came from, against the dashed circle of an even share.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>And the dent is drawn at its true size.</b> Measured on this
+            arrangement, the sheltered side takes 73% of an even share at a gap
+            of 18 cells and 41% at a gap of 4 — an 18% dent widening to 93% as
+            they close, which is why they visibly accelerate. The one number
+            that is scaled is a <i>mobility</i>, so that the drift happens
+            inside half a minute rather than inside a simulation nobody watches
+            to the end; the push itself is counted, not chosen.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <span className="bp5-text-muted">
+              In two dimensions, so it can be seen at all — the lattice has 8
+              ways out of a point rather than 26, and the force consequently
+              falls as 1/<V>r</V> rather than 1/<V>r</V><Sup>2</Sup>. That is a
+              fact about the plane and not about the mechanism.
+            </span>
+          </Para>
+
+          <Head>and the two counts it is read against</Head>
+
+          <Para>
+            A fixed count of charges over a shell that grows, which is the whole
+            of the inverse square, and the same number read the other way, which
+            is what gets through.
+          </Para>
+
+          <Shells />
+
+          <Para>
+            And the twenty-six ways out of a point sorted by a north — where the
+            equator turns out to be a <i>different</i> ring for each of the
+            three axis classes.
+          </Para>
+
+          <Exits />
+
+        </Section>
+
+
         <Section head="TODO">
 
           <Head>the rule, and there is only one</Head>
@@ -2473,8 +2564,9 @@ const Physics = () => {
               <>The 1/<V>r</V><Sup>2</Sup>, as flux over a growing shell — exactly{' '}
                 <K>SHEET</K> = 8 through any sphere, to the last digit. The sign law, for a
                 bias. Two signs that cancel. A ± ledger that balances, which is what{' '}
-                <K>BITE</K> = 1 exists for. Magnetisation quantised in quarters. ∇·<V>B</V> = 0
-                and the absence of monopoles. That the lightest constituent wins by the
+                <K>BITE</K> = 1 exists for. Magnetisation quantised in quarters, on a face
+                axis (a corner axis quantises in thirds — see the ring count in the Layer-2
+                arc). ∇·<V>B</V> = 0 and the absence of monopoles. That the lightest constituent wins by the
                 square. Superposition. The dipole angular law 3cos²<V>θ</V> − 1, the
                 1/<V>R</V><Sup>4</Sup> force, all five orientations, and that cutting a magnet
                 halves it. <b>Thirteen of twenty-nine.</b></>],
@@ -2514,7 +2606,19 @@ const Physics = () => {
           <BR/>
 
           <Para>
-            Which turns the open question into one line of the source. <K>emission</K> is <code>sided ? along() : cos(2πβ)</code>, and <K>along</K> resolves the direction against the axis <i>at the destination</i>. A pulse whose polarity were fixed <b>when it left</b> would carry it, the near-field cancellation would survive to infinity, and the faces would be poles. So: <b>is a pulse's sign fixed when it leaves, or when it arrives?</b> Nothing else about the mechanism changes either way, which makes it the cheapest open question on the page.
+            Which turns the open question into one line of the source. <K>emission</K> is <code>sided ? along() : cos(2πβ)</code>, and <K>along</K> resolves the direction against the axis <i>at the destination</i>. A pulse whose polarity were fixed <b>when it left</b> would carry it, the near-field cancellation would survive to infinity, and the faces would be poles. So: <b>is a pulse's sign fixed when it leaves, or when it arrives?</b> Nothing else about the mechanism changes either way, which is why this looked like the cheapest open question on the page.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>It is not a question, and it is worth saying so here rather than only where it gets settled.</b> A pulse that reaches an observer was emitted <i>into the direction of the observer</i>, so the direction the source resolves its sign against is the direction the destination resolves it against — one number computed in two places. Measured over two hundred observers at random directions and distances the difference is exactly nought, and both give the same 2.000. The two can only come apart where the ray bends or where north turns along the path, and in the far field of a uniformly ordered lump there is neither. <b>Fixing the sign at the source changes nothing whatever.</b>
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What was right in this passage is the sentence just above it, and it was right about the wrong object. <i>The signed emission is nought in the middle of a cylinder and largest at its ends</i> — <b>that is −<V>∇</V>·<B>p</B></b>, the divergence of a polarisation, and it is a quantity that nets to nought identically, falls as 1/<V>r</V><Sup>3</Sup>, gives every orientation and 1/<V>R</V><Sup>4</Sup>, and yields two magnets when the body is cut in half. The arc had it in hand and then resolved it against an axis at the destination, which throws the polarisation away and replaces it with sgn(<B>n</B>·<B>d̂</B>) — a quantity with zero flux through every sphere and a step discontinuity at the equator, which is <b>not a monopole and not a field at all</b>, but a tally of received pulses. That is the whole of what went wrong, it is one line, and the Layer-2 arc below carries the measurements.
           </Para>
 
           <BR/>
@@ -3152,7 +3256,13 @@ C60                       1.2e−24   1e−7     1.9e+66
           </Eq>
 
           <Para>
-            The magnetism arc noticed the eight and called it "thrown away". <b>It is not thrown away. It is vacant</b>, and it is vacant in precisely the sense a second structure needs: eight directions, at every cell, that Layer 1's emission rule never touches. Anything built on them costs the gravity arc nothing — not a digit of <i><K><Bar>G</Bar></K></i>, not a term in met(<V>R</V>), not one of the numbers this book has already published — because the emission was never using them.
+            The magnetism arc noticed the eight and called it "thrown away". <b>It is not thrown away. It is vacant</b>, and it is vacant in precisely the sense a second structure needs: eight directions, at every cell, that Layer 1's emission rule never <i>puts anything into</i>. One wording correction, because it matters for what follows: the rule does not fail to touch them. It touches them and assigns nought, deliberately — <i>physics.ts</i> says so in as many words, that a source with sides <i>has</i> an equator and a direction on it gets nothing, and that this is a real answer rather than an omission. Vacant is the right word and untouched is not. Anything built on them still costs the gravity arc nothing — not a digit of <i><K><Bar>G</Bar></K></i>, not a term in met(<V>R</V>), not one of the numbers this book has already published — because the emission was never <i>using</i> them.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And while the count is here: the magnetism arc's "why the equator and not the far hemisphere" is already answered a section earlier in that same arc, though neither says so out loud. A sided emitter gives + to the forward nine, − to the rearward nine, and the equatorial eight resolve to no sign. <b>The rear hemisphere is carrying the minus.</b> The eight are left over because they are the ones with nothing to be, not because a hemisphere went missing.
           </Para>
 
           <BR/>
@@ -3167,6 +3277,37 @@ C60                       1.2e−24   1e−7     1.9e+66
             </span>
           </Eq>
 
+          <Head>and the ring is the face ring, which is six norths out of twenty-six</Head>
+
+          <Para>
+            That paragraph is true and it is true of one axis class, and the arc as first written did not say so. The <K><Bar>CYCLE</Bar></K> = 8 sitting in <i>lattice.ts</i> is <K>turnRing</K>'s — eight in-plane directions of a <i>plane</i> — and a plane is an equator only when the axis is a face axis. Cut the equator of every north the lattice has and sort each one by angle, and there are three answers rather than one.
+          </Para>
+
+          <Eq note="ring.ts — every north, its equator, and the spacing round it">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`axis class   count   CYCLE   spacing
+face            6       8    uniform 45°
+corner          8       6    uniform 60°
+edge           12       8    NOT uniform — 35.26° / 54.74° alternating`}
+            </span>
+          </Eq>
+
+          <Para>
+            So fourteen of the twenty-six norths carry a uniform ring and they carry <i>two different quanta</i>; the twelve edge axes — the largest class — carry eight directions that are not at equal angles at all, and 35.26° and 54.74° are the lattice's own two angles rather than an eighth of anything. <b>In a texture whose north turns, nearly half the sites have no U(1) on them.</b> That does not sink the construction, but every sentence in this arc with <K><Bar>CYCLE</Bar></K> in it is a sentence about face axes, and the arc had better say which.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            It reaches back into the magnetism arc too, which does not mention it. That arc has <V>P</V> = 2·dwell − 1 with dwell = <V>k</V>/<K><Bar>CYCLE</Bar></K> and reports magnetisation "quantised in quarters" — but quarters is 2/<K><Bar>CYCLE</Bar></K>, so a corner-axis emitter is quantised in <i>thirds</i> and an edge-axis emitter has no uniform dwell to count with. Since the anisotropy result is stated for ⟨111⟩, which is a corner axis, <b>the 11.1% may be computed with a <K><Bar>CYCLE</Bar></K> that does not hold there</b>, and it is worth recomputing before it is left standing in either column.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            One thing does fall out cleanly, and it is the second half of a result the quantum arc already had. The equator of a face axis is every direction with no component along it, which is every way out of a point in one dimension fewer: <K><Bar>SHEET</Bar></K>(<V>D</V>) = 3<Sup><V>D</V>−1</Sup> − 1. <b>The ring size and the sheet size are one constant.</b> <V>D</V> = 1 gives nothing at all and <V>D</V> = 2 gives two, and two directions are a sign rather than a circle — so <b>the first dimension with a phase in it is the third</b>. The 1D walk found the <V>i</V> removable and this says there was never one there to remove, which is a second, independent reason for the same negative result and is a counting fact rather than a measurement.
+          </Para>
+
           <Head>an axis, a ring, and what each of them is</Head>
 
           <Para>
@@ -3253,7 +3394,51 @@ C60                       1.2e−24   1e−7     1.9e+66
           </Eq>
 
           <Para>
-            <b>So the complex structure is forced by the existence of closed loops, and not before.</b> The previous arc's negative result stands exactly as far as it was measured — one dimension — and stops being general the moment the lattice is allowed to be three-dimensional and the axis is allowed to turn. That is also the Aharonov–Bohm statement, arrived at as a lattice-counting fact: the phase around a loop is a thing about the loop, and the choice of where azimuth zero sits is unobservable because <b>the equator has no marked point on it</b>. Gauge invariance is that absence.
+            <b>So the complex structure is forced by the existence of closed loops, and not before.</b> The previous arc's negative result stands exactly as far as it was measured — one dimension — and stops being general the moment the lattice is allowed to be three-dimensional and the axis is allowed to turn. That is also the Aharonov–Bohm statement, arrived at as a lattice-counting fact: the phase around a loop is a thing about the loop, and the choice of where azimuth zero sits is unobservable because <b>the equator has no marked point on it</b>. Gauge invariance is that absence — and it is measured rather than asserted in <i>holonomy.ts</i>, where two hundred random per-site choices of where azimuth zero sits move the loop by 2.5·10<Sup>−15</Sup> while a single open link moves by the whole circle.
+          </Para>
+
+          <Head>and then the ring and the flux cannot both be true</Head>
+
+          <Para>
+            Which is the fork this arc has to take and does not notice it is standing at. Everything above is a <i>continuum</i> transport: the azimuth is a real number, the advance per step is whatever the texture asks for, and the holonomy is a smooth ~10<Sup>−2</Sup> radians. But the opening of this same arc says the phase lives <i>on</i> the eight-member ring, with a quantum of 45°. Put those two sentences next to each other and measure what a smooth texture actually asks the ring for.
+          </Para>
+
+          <Eq note="holonomy.ts — a smooth texture, against the smallest move the ring can make">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`plaquette        advance/step   as a fraction of SPIN   quantised   continuum
+(0,0) 1×1           2.739e−2                3.49e−2   0.000e+0    2.739e−2
+(1.5,0.7) 1×1       4.268e−2                5.43e−2   0.000e+0    1.128e−2
+(0,0) 2×2           4.677e−2                5.95e−2   0.000e+0    7.990e−2
+(3,3) 1×1           8.732e−3                1.11e−2   0.000e+0    7.047e−4`}
+            </span>
+          </Eq>
+
+          <Para>
+            One to two orders of magnitude under a single quantum, at every step, so every step snaps to no move at all and <b>the holonomy is identically zero on every plaquette</b>. And it is not a matter of finding a texture that twists harder: a texture advancing a whole 45° per lattice step turns its north right over in eight cells, which is not a texture, it is noise.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>So the arc asserts two things that cannot both hold.</b> Take the ring and there is no Aharonov–Bohm, no flux out of any smooth texture, and nothing for minimal coupling to couple to. Take the flux and the phase is continuous, which is perfectly fine — but then it is not the eight vacant directions, and the whole "the lattice left exactly the right amount of room for it" argument goes with it, because eight directions is not a continuum. <b>This is the single most load-bearing open question in the arc</b>, and it is one decision rather than two: the ring table above and this one are the same fork seen from two sides.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            There is a third option, and the arc does not consider it. Keep the ring and let the strand be a <i>superposition</i> over its members rather than sitting on one, so the advance is an expectation rather than a snap — measured, the realised advance tracks the asked-for one down to 10<Sup>−4</Sup> radians while the ring stays firmly discrete, which is the ordinary relationship between a finite basis and a continuous parameter. It is not free: it makes the phase an amplitude over the eight rather than a position among them, which is a bigger object than the one this arc costed, and whether Layer 1 has room for <i>that</i> is a different count and is not done.
+          </Para>
+
+          <Head>and one half, used twice</Head>
+
+          <Para>
+            While the flux table is here. Parallel transport of a frame vector round a loop gives Ω, not Ω/2 — measured, agreeing with the spherical excess to 10<Sup>−18</Sup>. So the /2 in the column above is not a normalisation being carried along; <b>the half is the double cover</b>, which is the very thing <V>g</V> = 2 is presented as a consequence of four sections below. Writing Ω/2 here already inserts it.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            That refutes neither. It says the book is entitled to <i>one</i> of them as an assumption and must get the other as a result, and at the moment it helps itself to both. Pick which one is primitive.
           </Para>
 
           <Head>minimal coupling, which nobody put in</Head>
@@ -3290,13 +3475,59 @@ C60                       1.2e−24   1e−7     1.9e+66
           </Eq>
 
           <Para>
-            <b>They go opposite ways, and the separation grows as the square of the time</b>, which is what a force does rather than what a drift does. At <V>g</V> = 0.008 the with-the-grain strand has been turned all the way round and is moving the other way while the against-the-grain one carries on. Nothing was added to the walk to arrange this — the ramp is the field, the traversal sense is the charge, and the acceleration is the two of them multiplied, which is the Lorentz force with its sign.
+            <b>They go opposite ways</b>, and nothing was added to the walk to arrange it — the ramp is the field, the traversal sense is the charge, and what the two of them multiply to is the Lorentz force with its sign. The norm is conserved to 4·10<Sup>−14</Sup> throughout, so none of it is a leak.
           </Para>
 
           <BR/>
 
           <Para>
-            One honest note on how that number was got, because two earlier versions of the measurement said the effect was zero. A strand with no momentum, or with a real amplitude, is mapped to itself by the conjugation that swaps the two traversal senses, so the two are forced equal by symmetry and no value of <V>g</V> separates them. <b>The charge needs something to be asymmetric about before it shows.</b> That is not an artefact of the test; it is the reason a charge at rest in no field is not observably a charge.
+            Two things in that paragraph as first written are wrong, and both are worth fixing in place rather than quietly, because one of them is the arc's own control.
+          </Para>
+
+          <Head>the control is right and it is on the wrong variable</Head>
+
+          <Para>
+            The arc explains a pair of earlier null results by saying that a strand with no <i>momentum</i> is mapped to itself by the conjugation that swaps the two traversal senses, so no <V>g</V> separates them — "the charge needs something to be asymmetric about before it shows". Measured, that is not what happens.
+          </Para>
+
+          <Eq note="bloch.ts — the same field on the same strand, against the starting momentum">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`  k₀     ⟨x⟩ with grain   ⟨x⟩ against    separation at g = 0.004
+0.00           316.83       −316.83                    633.65
+0.20           215.32       −293.71                    509.03
+0.60            37.09       −150.55                    187.65
+1.20           −20.12        −42.46                     22.34`}
+            </span>
+          </Eq>
+
+          <Para>
+            <V>k</V><Sub>0</Sub> = 0 is where the two senses separate <i>most</i>, not least, and they do it symmetrically about a stationary start — <b>which is exactly what two opposite charges released from rest into a field do</b>, and is a cleaner demonstration of the result than the one the arc reports. The physics in the sentence is right and the variable in it is wrong. What cannot show a charge is no <i>field</i>, and the table above already has that row: at <V>g</V> = 0 the separation is 0.00 to every digit. <b>A charge at rest in no field is not observably a charge — and a charge at rest in a field is the easiest one to see.</b>
+          </Para>
+
+          <Head>and the t² is the first quarter of an oscillation</Head>
+
+          <Para>
+            The second is the exponent. Fit the separation in windows rather than reading its endpoint and it does not sit on 2 and does not sit anywhere: 1.90, 2.46, 2.34, 1.30, then −4.24. That is not a power law measured badly, it is not a power law. A ramping θ enters the dispersion as <V>k</V> → <V>k</V> − θ, so a constant field walks the momentum through the band at a rate <V>g</V> and brings it back round again. <b>The turnaround the arc reads as "the with-the-grain strand has been turned all the way round" is exactly the right description and is the band wrapping, not the force winning.</b>
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which is <i>Bloch oscillation</i>, and it is the correct behaviour of a charge in a constant field on a lattice rather than a defect — a real result in its own right, and one the arc could have claimed instead of the <V>t</V><Sup>2</Sup>. The distinguishing test is cheap and decisive: if the clock is θ = <V>gt</V> and nothing else, every feature of the trajectory has to land at a fixed value of <V>gt</V>.
+          </Para>
+
+          <Eq note="bloch.ts — the turning point at the band centre, and the spacing between turning points">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`   g       t*     g·t*  (k₀ = 0.6)       Δt     g·Δt        π
+0.003      197    0.591                1048    3.144    3.142
+0.004      148    0.592                 785    3.140    3.142
+0.006       98    0.588                 524    3.144    3.142
+0.008       74    0.592                 392    3.136    3.142`}
+            </span>
+          </Eq>
+
+          <Para>
+            Both hold across a factor of nearly three in <V>g</V>: the strand turns round when the momentum reaches the band centre, at <V>g</V>·<V>t</V>* = <V>k</V><Sub>0</Sub>, and turns again every time it crosses another zero of the group velocity, which are π apart. <b>So the coupling survives and the acceleration law does not.</b> The charge couples to the field with the right sign, which is the result this arc wanted and keeps. The correction matters beyond tidiness for one reason: <b>a coupling read off a Bloch oscillation inherits the error</b>, and the coupling is the one number the arc still owes.
           </Para>
 
           <Head>the g-factor the arc had given up on</Head>
@@ -3344,6 +3575,47 @@ an undirected axis returns after CYCLE/2 = 4 steps (π)`}
             Which also means the arc's <V>∇</V>·<B>B</B> = 0 was in tension with its own far field the whole time. A 1/<V>r</V><Sup>2</Sup> field <i>is</i> a monopole field; you cannot have both.
           </Para>
 
+          <Head>except that "monopole" was too kind, and it is not a field at all</Head>
+
+          <Para>
+            The paragraph above is the diagnosis this arc was written on, and it is not quite right, in a direction that makes the case stronger rather than weaker. Take the sided tally seriously as a vector field, <B>B</B> = Σ sgn(<B>n</B>·<B>r̂</B>)·<B>r̂</B>/<V>r</V><Sup>2</Sup>, and measure its flux through spheres around the lump. A monopole would give the enclosed charge, the same at every radius. It gives nothing at every radius — 10<Sup>−14</Sup> at <V>r</V> = 200 and 10<Sup>−13</Sup> at 1600, which is the quadrature error and not a number. <b>There is no monopole. <V>∇</V>·<B>B</B> = 0 holds observationally.</b> So what is the 1/<V>r</V><Sup>2</Sup>?
+          </Para>
+
+          <Eq note="departure.ts — the angular profile of the sided tally, at fixed radius, times r²">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`  θ      0°      30°     60°     89°     90°     91°     120°    180°
+r²·F   +64.0   +64.0   +64.0   +64.0     0.0   −64.0   −64.0   −64.0`}
+            </span>
+          </Eq>
+
+          <Para>
+            Constant magnitude from the pole to one degree off the equator, a step discontinuity at 90°, and its own mirror below. That is sgn(cos <V>θ</V>)/<V>r</V><Sup>2</Sup>, and <b>it is impossible for any real field</b>: zero enclosed charge forbids a 1/<V>r</V><Sup>2</Sup> term in a multipole expansion outright, so the exterior is not source-free, and the step at the equator is a source sheet running to infinity. The lump is not emitting a net charge. It is not emitting a field.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>Σ sgn(<B>n</B>·<B>d̂</B>)/<V>r</V><Sup>2</Sup> is not a field, it is a tally of received pulses</b> — a count of how many arrived on the + side of their own emitter, which is a perfectly good quantity and is not a thing that satisfies Maxwell's equations. Σ <V>s</V><Sub>e</Sub>/<V>r</V><Sup>2</Sup>, with the sign fixed per emitter, <i>is</i> a field. That is the real reason the phase route works, and it is a better reason than the one about where in the calculation the sign gets resolved — which, as the next section says, turns out not to be a reason at all.
+          </Para>
+
+          <Head>and the cheapest open question was not a question</Head>
+
+          <Para>
+            The magnetism arc closes on one, calls it the sharpest and the cheapest to answer, and expects it to rescue the pole model: <i>is a pulse's sign fixed when it leaves, or when it arrives?</i> <K>emission</K> resolves it against the axis at the destination; fix it at the source instead and the faces become poles with nothing else changed.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>The two are the same function.</b> Not nearly the same — the same, and it cannot be otherwise: a pulse that reaches an observer was emitted <i>into the direction of the observer</i>, so the <B>d̂</B> the source resolves its sign against is the <B>d̂</B> the destination resolves it against. One number, computed in two places. Measured over two hundred observers at random directions and distances, the largest difference is exactly nought, and both give the same far-field 2.000. Quantising the emission direction onto one of the twenty-six first — the only real content in the distinction — changes the sign only for observers within half a lattice angle of the equator, and does not move the exponent either.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The distinction the arc wanted does exist, but not there. Departure and arrival come apart exactly where the ray bends, or where north turns along the path — which is a magnetic texture, and is what the holonomy above is about. In the far field of a uniformly ordered lump there is neither. <b>What gives 3.000 is the arc's <i>second</i> emitter, not its fourth</b>: the non-sided one, cos(2π<V>β</V>), whose sign the emitter fixes for itself before it knows who is listening.
+          </Para>
+
           <Head>two routes to the cube, and only one of them survives being real</Head>
 
           <Para>
@@ -3370,6 +3642,104 @@ perfectly balanced         3.000      all aligned              3.001
             The loops do not care. <b>Randomising every loop's orientation still gives 3.013</b>, because each closed loop has zero monopole moment <i>individually</i> — by topology, not by cancellation — and no arrangement of things with no monopole moment can produce one. There is nothing to tune and nothing to keep aligned.
           </Para>
 
+          <Head>but there is a third route, and the fine-tuning objection does not reach it</Head>
+
+          <Para>
+            The objection above is aimed at charges that were <i>assigned</i> — a + put on this emitter and a − on that one — and it is correct against those. It is not correct against the route the magnetism arc had already half-built and then walked away from, which is neither of the two this section names.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Do not ask where the sign is resolved. Ask what the primitive is. Give each node a polarisation <b>p</b> — which is just "which way this bit of the body is pointed", and is a thing an ordering can plausibly hold — and let the emitted sign be
+          </Para>
+
+          <Eq note="divp.ts — nought wherever p is uniform, and appearing only where the body ends">
+            <V>s</V> = −<V>∇</V>·<b>p</b>
+          </Eq>
+
+          <Para>
+            Nobody assigns a pole to a face. <b>The faces are where the divergence is.</b> And the net is not balanced, it is zero <i>identically</i>, because a divergence summed over everything telescopes — which is the same kind of statement as "a loop has no monopole moment by topology", arrived at without needing a loop.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            It gives the whole of magnetostatics: net sign exactly 0, far field 3.000, the potential agreeing with cos <V>θ</V> to 1.5·10<Sup>−6</Sup> at every angle, N–S attracting and N–N repelling at equal size, side by side repelling aligned and attracting anti-aligned, one across the other giving 2·10<Sup>−17</Sup>, and a force exponent of 4.003. And it survives the test that separates it from the hand-placed version — <b>cut the magnet in half</b>. Assign the signs by which half of the body a node sits in and the upper half is all-plus, net 32, exponent 2.003: two monopoles. Let the sign be −<V>∇</V>·<b>p</b> and the new bottom face has a divergence it did not have when there was body below it, so a south pole appears at the cut, the net is nought again and the exponent is 3.005. <b>Two magnets out of one, which is the whole content of "there are no magnetic monopoles" stated as an experiment rather than as a law.</b>
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Now put the fine-tuning objection to it. You cannot flip a charge, because there are no charges to flip; you can only disturb <b>p</b>.
+          </Para>
+
+          <Eq note="divp.ts — the net, under every disturbance worth trying">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`disturbance to p                 net sign    exponent
+none — uniform ẑ                   0.0e+0       3.000
+one node reversed                  0.0e+0       3.000
+eight nodes reversed               0.0e+0       3.002
+every node ±10% wobble            −2.3e−16      3.000
+every node ±50% wobble            −1.7e−15      3.000
+p entirely random                 −2.8e−16      2.963`}
+            </span>
+          </Eq>
+
+          <Para>
+            Nought to machine precision in every row, <i>including the fully random one</i> where there is no magnet left at all — the exponent wanders there because the remaining moment is small and noisy, not because a monopole has appeared. Nothing is held in place and nothing needs to be. <b>So the choice between "fine-tuned" and "topological" was not the choice</b>; both surviving routes are topological, and what the objection actually rules out is assigning signs to places, which is the one thing neither of them does.
+          </Para>
+
+          <BR/>
+
+          <Head>and it is not a third rule — the lattice already emits it</Head>
+
+          <Para>
+            Which leaves the question that decides whether any of this is a consequence or a convenience: <i>does this model emit −<V>∇</V>·<b>p</b>?</i> The argument for it is Gauss's theorem applied to the annihilation ledger — every + in the bulk has a neighbour's − sitting on it, so only the boundary survives — and an argument is not a measurement. So run it: every node puts sgn(<b>p</b>·<B>d</B>) into each of the <K><Bar>DEG</Bar></K> ways out, and where two pulses come at each other with opposite signs they annihilate, which is rule (G/1) and nothing else.
+          </Para>
+
+          <Eq note="escape.ts — 64 nodes, 1664 pulses, 600 annihilated head-on and 552 escaping">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`z-layer     Σ escaped        Σ −div p over the layer
+   1.5        100.0                    8.0000
+   0.5          0.0                    0.0000
+  −0.5          0.0                    0.0000
+  −1.5       −100.0                   −8.0000`}
+            </span>
+          </Eq>
+
+          <Para>
+            Nought in every interior layer, equal and opposite on the two ends, and both totals exactly nought. <b>The surface density is derived.</b> It is not a rule that had to be added — it is what the annihilation ledger leaves behind, and the arc is entitled to it.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>And then the far field is still wrong, for the reason two sections above already gave.</b> An escaped pulse is still going somewhere. It got away <i>along a direction</i>, and a distant observer receives only what was emitted towards it — which on a polarised block means only the face pointing at it. Keep the escaped charge directional and the exponent is 2.005 with the same flat step at the equator; let the escaped charge radiate equally in all directions and it is 3.000. <b>The surface charge is right and the propagation is not, and the far field only knows about the propagation.</b>
+          </Para>
+
+          <BR/>
+
+          <Para>
+            So the debt is one line and it is not the line this arc thought it was. What is owed is not <i>where the sign is resolved</i> but <i>that the unpaired emission leaves isotropically</i> — and neither existing branch supplies it. <K>sided</K> is directional by construction. The non-sided branch, cos(2π<V>β</V>), <i>is</i> isotropic per emitter, which is exactly why it gives 3.000 — but it has no <b>p</b> in it, so a uniformly phased block never annihilates and never develops a surface at all. <b>One branch has the geometry and no field; the other has the field and no geometry.</b>
+          </Para>
+
+          <BR/>
+
+          <Para>
+            What would close it is one rule: an emitter whose emitted sign is <i>isotropic</i>, so that what leaves is a field, and whose <i>strength</i> is set by the local −<V>∇</V>·<b>p</b> rather than node by node. And that rule is already written down in this book. <b>The Layer-2 arc's one stated assumption — that Layer 1's emission is sourced by a <i>region's</i> total content rather than strand by strand — is exactly it</b>, and it was introduced several sections from here to pay a bound-state debt in the quantum arc.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>So the two open assumptions in this book are one assumption</b>, and it buys more than either place claimed for it: regional sourcing gives a bound state its single train at the summed rate, and gives a magnet its poles. That is worth more than a tidier ledger — it means the assumption is load-bearing in two independent arcs, which is the difference between a convenience and a hypothesis.
+          </Para>
+
+          <Para>
+            And it reconciles with a measurement the magnetism arc already had and read as encouragement without recognising it. That arc reports the signed emission of an ordered cylinder as <i>nought in the middle and largest at the ends</i>. <b>That is −<V>∇</V>·<B>p</B>.</b> The arc had the right quantity in hand and then resolved it against the axis at the destination, which throws the polarisation away and replaces it with sgn(<B>n</B>·<B>d̂</B>) — and that, as above, is not a field. <b>One line, and it was the line.</b>
+          </Para>
+
           <Head>and the model has already committed to the loops</Head>
 
           <Para>
@@ -3388,6 +3758,210 @@ perfectly balanced         3.000      all aligned              3.001
             One thing worth saying rather than leaving implied. The two routes are the old Gilbert and Ampère pictures, they agree everywhere outside the magnet, and experiment has long since separated them <i>inside</i> — the hyperfine splitting measures the field in the body and picks the current loop. <b>So the route the model is forced into is also the one that is right</b>, which is not something this book gets to say very often.
           </Para>
 
+          <BR/>
+
+          <Para>
+            Which places the third route exactly. −<V>∇</V>·<b>p</b> is Gilbert, so it is the <i>outside</i> description and the hyperfine measurement rules it out as the inside one. That is not a competition it loses; it is what the two pictures have always been. What the −<V>∇</V>·<b>p</b> measurement settles is a different question — <b>what Layer 1 has to emit for the outside to come out right</b> — and the answer is the divergence of a polarisation rather than a sign resolved against an axis. A closed Layer-2 loop is then what <i>carries</i> the polarisation, and the two are the same body described at the two ends of the same argument. Which of them is primitive is not settled here and does not need to be for either result.
+          </Para>
+
+          <Head>what holds the polarisation uniform, and what does not</Head>
+
+          <Para>
+            Everything above says what a magnet has to <i>be</i> and nothing says what holds it that way. The obvious candidate is already in the model and does not work: the dipolar energy of a cubic block is exactly nought for the uniform state — the lattice sum vanishes by symmetry — and every arrangement that beats it has no net polarisation at all, with columnar coming in at −2.02 per moment and in-plane closure at −1.82. <b>Dipolar coupling favours closure</b>, which is the standard result and is the reason real ferromagnetism needs exchange. So the ordering cannot come from the pole energy; it has to come from the emission.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And there <i>is</i> a coupling in the emission, which is more than this arc expected to be able to say. It is not put in and it is not an analogy — it comes out of rule (G/1), the one rule the whole book is built on, and getting it took noticing that the arc had been throwing away the only thing that rule produces.
+          </Para>
+
+          <Head>the coupling, out of annihilation having a place</Head>
+
+          <Para>
+            Start with what the model actually has when a pulse arrives, which is <i>annihilation</i> and nothing else. <K>rate</K> in <i>physics.ts</i> reads the source's own <K>turning</K> and <K>flips</K> and reads nothing about what has landed on it, so as written no emitter can hear another at all. The natural repair is that annihilation near a source changes its beat. Measured, that repair fails — and it fails structurally rather than numerically.
+          </Para>
+
+          <Eq note="response.ts — two sided emitters, the annihilation count near the first">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`Δβ        0.000   0.125   0.250   0.375   0.500   0.625   0.750   0.875
+count     2.505   2.505   1.394   1.038   1.038   1.038   1.394   2.505
+
+sin component  −1.3e−16          cos component  8.95e−1`}
+            </span>
+          </Eq>
+
+          <Para>
+            <b>The count is even.</b> Identical at +Δβ and −Δβ to every digit, no sine component at all — and an even coupling cannot lock anything, because it has no way to tell ahead from behind and so cannot pull a laggard forward and a leader back. Run it and it drifts: 0.57, 0.56, 0.61 over four, sixteen and sixty-four thousand ticks, against 0.9996 flat for an odd one.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            But a count is not what rule (G/1) produces. <b>It produces a <i>location</i></b> — space is destroyed at particular cells — and a source with an axis has a front and a back. Take the first moment of the annihilation density about the source's own axis instead of the total, and the evenness goes.
+          </Para>
+
+          <Eq note="response.ts — the first moment about n's axis, and the same at −Δβ">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`Δβ        0.050    0.125    0.188    0.250    0.313    0.375
+moment   −1.7e−17 −1.7e−17 −1.26e−1 −2.78e−1 −1.26e−1 −1.2e−17
+at −Δβ   −1.7e−17 −1.7e−17  1.26e−1  2.78e−1  1.26e−1 −1.2e−17
+
+mean −2.1e−18     sin −1.278e−1     cos −2.1e−17`}
+            </span>
+          </Eq>
+
+          <Para>
+            <b>Odd, exactly, at every phase difference</b>, with no cosine component and no mean. It is a coarse staircase rather than a smooth sine — the signs are sgn(axis·<B>d</B>) over twenty-six exits, so it only moves when the axis crosses onto a new set of them — but the symmetry is the part that matters and the lowest harmonic is sin(2πΔβ). <b>So the coupling the previous version of this section assumed is instead derived</b>, out of (G/1) and the 1/<V>r</V><Sup>2</Sup> with which the pulses arrive. No harmonic expansion and no product-to-sum are needed; the lattice hands over the odd first harmonic directly, because annihilation has a place and an axis has a side.
+          </Para>
+
+          <Head>and it settles the fork, because a moment is a torque</Head>
+
+          <Para>
+            Which closes the question this arc had been settling by preference. A first moment about an axis <i>is a torque on that axis</i> — nothing in it touches the emitted sign, and the sign is sgn(axis·<B>d</B>) and follows the axis rather than the other way round. <b>So what the coupling acts on is the polarisation vector.</b> The sign stays −<V>∇</V>·<b>p</b>, and the monopole branch — the one where every emitter ends up the same sign — is not a branch the model has. That was the right answer and this is the reason for it.
+          </Para>
+
+          <Head>and whether it aligns, which is not yet answered either way</Head>
+
+          <Para>
+            One more question decides whether any of this is a ferromagnet, and it is the question that looked like it had killed the dipolar route: does the torque depend on the bond direction? Dipolar does — the 3(<b>m</b>·<B>r̂</B>)(<b>m</b>·<B>r̂</B>) term — and a coupling with <i>no</i> bond direction in it is an exchange, and exchange aligns.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            An earlier version of this section answered that and reported a magnet's worth of angular structure, concluding the model has no ferromagnet in it. <b>That measurement was not a convergent quantity and the conclusion is withdrawn.</b> The torque as defined summed annihilations over a ball of radius <V>R</V> around the source weighted 1/<V>r</V><Sup>2</Sup> from the <i>other</i> source; for <V>R</V> much larger than the separation the weight falls as 1/<V>R</V><Sup>2</Sup> while the cells in a shell grow as <V>R</V><Sup>2</Sup>, so every shell contributes equally and the sum grows linearly with the cutoff for ever.
+          </Para>
+
+          <Eq note="texture.ts §3 — the transverse-bond torque against the cutoff radius, which has no limit">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`cutoff R      2         4         6         8        12        16
+torque    −3.4e−3   −1.5e−1   −1.5e+0   −7.5e+0   −2.8e+1   −3.9e+1
+                       ↑ the value the earlier draft quoted`}
+            </span>
+          </Eq>
+
+          <Para>
+            A region far from a source should not torque it, and any correct definition has to be local to it. So <b>what the annihilation torque does to an ordering is reopened, not settled in the negative.</b> What survives from that work is everything upstream of it: that a coupling exists, that it is odd, and that it acts on the polarisation.
+          </Para>
+
+          <Head>and the closure result was about one lattice</Head>
+
+          <Para>
+            The other half of the negative case needs the same treatment. The dipolar measurement above is on a <i>simple cubic</i> block, and reproduces the published ground-state energy for that lattice to five figures — −2.6768 here against −2.67679 in <Ref of={'Schönke, Tkachenko, Kadau et al., "Minimum and maximum energy for crystals of magnetic dipoles", Scientific Reports 10:19154'} year="2020" at="https://doi.org/10.1038/s41598-020-76029-x" />, with the same striped state. So that number is right and it is the answer for simple cubic.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>It is not the general answer.</b> <Ref of={'Luttinger and Tisza, "Theory of Dipole Interaction in Crystals", Physical Review 70, 954'} year="1946" at="https://doi.org/10.1103/PhysRev.70.954" /> solve exactly these three lattices: simple cubic orders antiferromagnetically as chains of aligned dipoles, and <b>body-centred and face-centred cubic order ferromagnetically on the dipolar interaction alone</b>. Which are the lattices real ferromagnets are made of — iron is bcc, nickel and fcc-cobalt are fcc.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            So the ordering was ruled out on the one arrangement of matter that cannot do it, and the arrangements that can were never tried. That is a live computation rather than a closed door, and it is the next thing to run — properly, which means the Luttinger–Tisza diagonalisation with an Ewald sum, since a dipolar lattice sum is conditionally convergent and its value depends on the order of summation.
+          </Para>
+
+          <Head>and −div p never needed a uniform p</Head>
+
+          <Para>
+            All of which was made to matter by a claim that should have been checked first. The magnetostatics above was read as needing a <i>uniformly</i> polarised body, and it does not. <b>The far field is an integral functional of the polarisation</b> — integrate −<V>∇</V>·<b>p</b> against a test function by parts and what is left is ∫<b>p</b> d<V>V</V> — so every arrangement with the same net gives the same magnet.
+          </Para>
+
+          <Eq note="texture.ts §1 — the same 8³ block, the polarisation arranged every way worth arranging it">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`texture                        |⟨p⟩|   exponent   Φ vs cosθ    moment
+uniform                        1.000     3.000     2.4e−7    5.12e+2
+four stripe domains            0.750     3.000     8.6e−4    3.84e+2
+random ±, small net            0.172     2.998     1.9e−3    8.79e+1
+random directions + bias       0.778     3.000     2.0e−2    3.98e+2
+closure swirl + small net      0.243     3.000     2.4e−7    1.24e+2
+pure closure, no net           0.000        —          —     5.4e−13`}
+            </span>
+          </Eq>
+
+          <Para>
+            Every texture with a net is a magnet — 1/<V>r</V><Sup>3</Sup>, cos <V>θ</V> to four figures, and a moment tracking the net. <b>The internal arrangement is invisible from outside.</b> Only the pure closure state has no field, and it should not have one, because that is a demagnetised body.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Which changes what the ordering has to deliver, and lowers the bar a great deal. <b>It has to deliver a net, not a uniform state</b> — and that reframes the relaxation result completely, because <i>a virgin piece of iron has no net moment either</i>. It picks up a paperclip only after it has been magnetised, and it keeps the moment afterwards because the state is pinned rather than because it is lowest. A permanent magnet is a metastable state maintained by hysteresis, and the ground state of a uniformly magnetised body in zero field <i>is</i> a multi-domain configuration with net zero — that is what the stray-field energy is for. <b>So a relaxation ending in closure is a confirmation that the model has the right physics, not a refutation of it.</b>
+          </Para>
+
+          <BR/>
+
+          <Para>
+            The right questions, then, and none of them is "is the ground state uniform":
+          </Para>
+
+          <Rows of={[
+            [<>local order</>,
+              <>Do neighbours align, so that the body has <i>domains</i> rather than being a
+                paramagnet? This is what an exchange-like coupling is for, and it is what
+                the annihilation torque has to be measured for — with a definition that
+                converges.</>],
+            [<>remanence</>,
+              <>Does an applied field leave a net moment behind when it is removed? A theory
+                of permanent magnetism is a theory of a <b>metastable</b> state, so this and
+                not a ground-state calculation is the test.</>],
+            [<>and the far field</>,
+              <>Follows from the net, whatever produced it. <b>Already done</b>, and it does
+                not depend on either of the above being settled.</>],
+          ]} />
+
+          <Head>and the domain size, which does not survive being converted</Head>
+
+          <Para>
+            One more thing has to be withdrawn, and it is the result this arc was briefly proudest of. The retardation argument is sound: a signal takes <V>r</V> ticks to cross <V>r</V> cells, so the coupling is really sin(2π(<V>β</V><Sub>m</Sub> − <V>β</V><Sub>n</Sub>) − ω<V>r</V>), distant shells couple with the wrong sign, and coherence collapses at ω·<V>L</V> ≈ π. Measured, that holds. <b>What does not hold is calling the result a magnetic domain.</b>
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Put units in it. The ceiling is <V>L</V> = π/ω = λ/2 — half a wavelength of the emitters' own clock — and the model fixes that clock two ways, neither of which is survivable. On the turn clock a source comes round in at least <K><Bar>CYCLE</Bar></K> = 8 ticks, so the coherent region is four cells: 6.5·10<Sup>−35</Sup> m, which is not small domains but <i>no long-range order of any kind</i>. On the beat clock, with beat = 1/mass, the emitter's wavelength is 0.0624 of its reduced Compton wavelength:
+          </Para>
+
+          <Eq note="domainsize.ts — the coherent ceiling, converted, against 0.1–100 µm measured">
+            <span style={{ fontFamily: JetBrainsMono, fontSize: '0.82em', whiteSpace: 'pre' }}>
+              {`carrier                    beat (ticks)      λ/2        short by
+electron                      1.490e+21    1.20e−14 m     10⁹
+iron atom                     1.463e+16    1.18e−19 m     10¹⁴
+neodymium atom                5.666e+15    4.58e−20 m     10¹⁴
+Nd₂Fe₁₄B formula unit         7.559e+14    6.11e−21 m     10¹⁵`}
+            </span>
+          </Eq>
+
+          <Para>
+            <b>Fourteen orders of magnitude.</b> Run it backwards and the model says the carrier would have to weigh about 10<Sup>−3</Sup> eV — nine orders lighter than a neutrino bound — for the coherent size to be a domain. That is not a prediction to go looking for; it is a refutation of the identification.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And there is a resolution, which is why the section above matters. <b>The ceiling needs a <V>β</V> that is running.</b> A source whose axis is <i>held</i> has no <V>β</V> at all — <i>physics.ts</i> separates the two outright, <K>sided</K> with an axis and no <K>turning</K> — so ω = 0, the lag term is nought at every distance, and there is no ceiling. A magnet, if this model has one, is made of held sources, and the domain result simply does not apply to it. What survives is a real constraint on the <i>other</i> kind: <b>anything in this model whose emission is phase-coherent cannot stay coherent past half its own wavelength</b>, which is new, is a genuine ceiling, and is not about magnets.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            Worth saying plainly, since the previous draft of this section said the opposite. <b>The lag does not give the model something extra. It takes something away</b>, and what it takes is any prospect of ordering a magnet out of sources that keep time with each other.
+          </Para>
+
+          <Head>and the scale, which moves a little and not much</Head>
+
+          <Para>
+            The one number the magnetism arc owes is its coupling: 4.5·10<Sup>7</Sup> kg/m² of pole face, measured and not counted. Nothing here derives it and nothing was going to. But <b>the shape of that debt is no longer a puzzle</b>, and it is worth saying because it was odd before. That arc found the coupling had to be quoted <i>per square metre of pole face</i> — one material constant covering six geometries with no residual — and treated the surface form as an empirical convenience.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            <b>A divergence lives on a surface.</b> If the emitted sign is −<V>∇</V>·<b>p</b> then the source of a magnet's field <i>is</i> an area and could not have been a volume, so the budget's area law is a consequence rather than a fit, and the six geometries agreeing is what that consequence looks like. What is owed is now cleanly one number and not a number plus an unexplained dimension. <b>The magnitude is untouched</b>, it is the same debt as <V>α</V>, and it is behind the ordering in the queue: a coupling constant for a magnet the model cannot yet assemble is the wrong thing to be worrying about first.
+          </Para>
+
           <Head>what this does not yet do</Head>
 
           <Para>
@@ -3444,27 +4018,85 @@ perfectly balanced         3.000      all aligned              3.001
                 magnetism arc could not answer. <b>Charge conservation</b>, as orientation
                 rather than as a rule. <b>C flipping helicity</b>, for free. <b>Minimal
                 coupling</b>, as what a helix does to a dispersion. <b>The force</b>, measured
-                — two traversal senses accelerating oppositely through one texture, going as
-                <V> t</V><Sup>2</Sup>. And a route to <b><V>g</V> = 2</b> that the magnetism
-                arc had located and could not take.</>],
+                — two traversal senses accelerating oppositely through one texture, and best
+                seen from rest. <b>Magnetostatics whole</b>, off a source the model can
+                actually produce: the sign as −<V>∇</V>·<b>p</b>, which nets to nought
+                identically, gives 3.000 and 1/<V>R</V><Sup>4</Sup> and all five
+                orientations, and <b>gives two magnets when you cut it in half</b>. And a
+                route to <b><V>g</V> = 2</b> that the magnetism arc had located and could
+                not take.</>],
+            [<>what comes out that was not aimed at</>,
+              <><b>A coupling, out of rule (G/1).</b> An annihilation <i>count</i> is even in
+                the phase difference and cannot lock anything; its first <i>moment</i> about
+                a source's own axis is exactly odd, and that is a torque with the
+                1/<V>r</V><Sup>2</Sup> the emission already carried. It also closes this
+                arc's own fork from the mechanism rather than by preference: a moment about
+                an axis acts on the <b>polarisation</b>, not on the emitted sign. And a
+                <b> coherence ceiling</b> at half a wavelength for anything phase-coherent,
+                which is real and is not about magnets.</>],
+            [<>and what had to be withdrawn</>,
+              <>That the ceiling is a <b>magnetic domain</b>. Converted it is
+                10<Sup>−19</Sup> m on the beat clock and 10<Sup>−34</Sup> m on the turn
+                clock against 10<Sup>−5</Sup> m measured, and it does not apply to a held
+                axis at all. And, in the other direction, the <i>negative</i> ordering
+                result: the torque it rested on grows without bound with the cutoff, and
+                the closure it compared against is the simple-cubic answer where bcc and fcc
+                give the opposite. <b>Both the claim and its refutation were overstated.</b></>],
             [<>what is fixed that was broken</>,
               <>The previous arc's finding that the <V>i</V> is a change of basis — true in
                 one dimension, where there are no plaquettes, and <b>false as soon as the
                 axis is allowed to turn</b>. The holonomy is a swept solid angle and no
-                site-local phase touches it.</>],
-            [<>what is assumed</>,
+                site-local phase touches it. And, more simply: the ring size is
+                3<Sup><V>D</V>−1</Sup> − 1, so there is <b>no phase in one dimension to
+                remove</b>.</>],
+            [<>what this arc got wrong and now says so</>,
+              <>The <V>t</V><Sup>2</Sup> is <b>a Bloch oscillation</b>, confirmed by
+                <V> g</V>·Δ<V>t</V> = π across a factor of three in <V>g</V>; the coupling
+                survives and the acceleration law does not. The symmetry control belongs to
+                <V> g</V> = 0 and not to <V>k</V><Sub>0</Sub> = 0, which is where the two
+                senses separate <i>most</i>. "Monopole" was too kind — the sided tally has
+                zero flux at every radius and is <b>not a field at all</b>. And the
+                fine-tuning objection that selected loops does not reach a divergence,
+                because there are no charges in one to flip.</>],
+            [<>what is assumed — and it is one thing, not two</>,
               <>That Layer 1's emission is sourced by a region's total Layer-2 content rather
-                than strand by strand. It is what pays the bound-state debt, and it is a
-                choice.</>],
+                than strand by strand. It pays the bound-state debt in the quantum arc, and
+                it turns out to pay the magnetic one too: it is exactly the isotropic,
+                regionally-sourced emission that <V>escape</V> shows is the only thing
+                standing between the derived surface density −<V>∇</V>·<b>p</b> and a
+                magnet's far field. <b>Two arcs, one assumption</b>, which makes it a
+                hypothesis rather than a convenience — and a testable one: build a region
+                with <V>N</V> strands and check the emission is one train at the summed rate
+                while the relative offset does not collectivise.</>],
             [<>what is owed</>,
-              <>The coupling — <V>α</V>, and the pole-face number with it. One debt now
-                instead of two, and nothing here derives it.</>],
+              <><b>Local order and remanence</b>, which is a much smaller bill than "a
+                uniform state" — the far field only needs a net, and a net is what
+                hysteresis leaves behind. Neither is measured yet and neither is refuted.
+                Then the <i>sign</i> of the derived coupling, one bit, belonging to the
+                gravity arc: does a source run fast or slow in shortened space. And then
+                <V> α</V> with the pole-face number, one debt instead of two, owed more
+                carefully than before since a coupling read off a Bloch oscillation inherits
+                that error.</>],
+            [<>the fork</>,
+              <><b>Continuous phase or quantised ring, and it cannot be both.</b> Continuous
+                gets the Aharonov–Bohm result and loses the 45° quantum and the "the lattice
+                left room for it" argument; quantised keeps the quantum and gets no flux out
+                of any smooth texture. A superposition over ring members keeps both and
+                costs more room than this arc costed. Plus: Ω/2 in the flux table and
+                <V> g</V> = 2 are one assumption used twice, and the book may have one of
+                them.</>],
             [<>and what is walled off</>,
               <>Entanglement, exactly as before. Layers add components, not coordinates.</>],
           ]} />
 
           <Para>
-            So the shape of the thing is: the lattice had eight directions per cell that its own emission rule could not use, and they form a ring; putting matter on that ring gives a charge that is a count, a phase that is a genuine U(1), a force with the right sign, and a spinor's double cover — and it costs the first two arcs nothing, because they were never using those directions. <b>Three of the four things this book had written off come back as consequences of one structure.</b> The fourth is entanglement, and that one is a theorem.
+            So the shape of the thing is: the lattice had eight directions per cell that its own emission rule assigns nought to, and around a face axis they form a ring; putting matter on that ring gives a charge that is a count, a phase, a force with the right sign, and a spinor's double cover — and it costs the first two arcs nothing, because the emission was never using those directions. <b>Three of the four things this book had written off come back as consequences of one structure</b>, and a fourth thing it never asked for — a domain with a size — comes back as a consequence of the fact that light is slow. The one that does not come back is entanglement, and that one is a theorem.
+          </Para>
+
+          <BR/>
+
+          <Para>
+            And the honest shape of what is left. The arc as first written had one open question it called cheap and one it called load-bearing, and both have moved. <b>The cheap one is closed and was not a question</b> — departure and arrival are the same function. <b>The load-bearing one is now the ring fork</b>, which is a single decision that two independent measurements both run into, and which the arc cannot go on deferring, because the charge, the phase, the minimal coupling and the flux are all on one side of it or all on the other.
           </Para>
         </Section>
         <Section head="Entanglement, and the Coupling">
@@ -3523,13 +4155,13 @@ perfectly balanced         3.000      all aligned              3.001
           <BR/>
 
           <Para>
-            <b>And that is the question the magnetism arc ended on, asked about a different layer.</b> That arc closed with: <i>is a pulse's sign fixed when it leaves, or when it arrives?</i> — and needed the answer <i>when it leaves</i>, because a pulse whose polarity is fixed at emission carries the near-field cancellation to infinity and gives a magnet its poles. Bell needs the opposite answer: a winding fixed at <i>both</i> ends.
+            <b>And that is the question the magnetism arc ended on, asked about a different layer.</b> That arc closed with: <i>is a pulse's sign fixed when it leaves, or when it arrives?</i> — and needed the answer <i>when it leaves</i>, because a pulse whose polarity is fixed at emission would carry the near-field cancellation to infinity and give a magnet its poles. Bell needs the opposite answer: a winding fixed at <i>both</i> ends.
           </Para>
 
           <BR/>
 
           <Para>
-            Which would be a flat contradiction in a one-layer model and is not one here. <b>Layer 1's polarity is fixed when it leaves; Layer 2's winding is fixed by both of its ends.</b> They are different quantities on different layers, and the only reason the question looked like it had to have one answer is that until this arc there was only one thing it could be asked about. That the two open questions want opposite answers is, on this reading, an argument for the two layers rather than a problem with them.
+            That reading was written before the Layer-1 half of it was measured, and the measurement takes the tension away without helping. <b>On Layer 1 the question is void</b>: departure and arrival are the same function for a straight ray, so there was never a fixing-at-emission to be in conflict with anything, and the poles come from −<V>∇</V>·<b>p</b> rather than from where the arithmetic is done. What survives is the weaker and still useful half — that a Layer-2 winding fixed by both of its ends is a different kind of quantity from a Layer-1 sign, so nothing on the gravitational or magnetic side constrains it either way. <b>The two layers are still independent here. They are just no longer independent <i>about something</i></b>, which is one argument for the split that this arc does not get to make.
           </Para>
 
           <Head>and then the measurement, which says how far the ring gets alone</Head>
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/counts.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/counts.tsx
new file mode 100644
index 0000000..9a27044
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/counts.tsx
@@ -0,0 +1,192 @@
+/**
+ * WHAT THE LATTICE COUNTS — the two places where a law in this book is a
+ * count off the lattice and nothing else, so the picture can simply be the
+ * count.
+ *
+ * These are not simulations and do not pretend to be. `runs.tsx` holds the
+ * lattice actually running; what is here is the arithmetic those runs are
+ * measured against — how much shell there is to share a pulse out over, and
+ * how the twenty-six ways out of a point sort themselves around an axis.
+ * Both are computed from `field.ts` and `lattice.ts` rather than transcribed,
+ * so neither can drift from the prose.
+ */
+
+import { Surface } from "./canvas";
+import { DEG, HALF, SHEET, chance, shell, through } from "./field";
+import { directions } from "./lattice";
+import {
+  BAD, DATA, FAINT, GOOD, GRID, INK, MODEL, Panel, RELAT, SEEN, axes, centred,
+  dot, frame, key, lazily, mono, plot, poly, split, under,
+} from "./sketch";
+
+// ===========================================================================
+// 1. A FIXED COUNT OVER A GROWING SHELL
+//
+// The inverse square, as the only two things that were written down: a fixed
+// number of charges, and how many cells a shell has to share them out over.
+// And the same number read the other way, which is what gets through.
+
+const shells = (s: Surface) => {
+  const box = frame(s, 46, 34);
+  const { ctx } = s;
+
+  const left = split(box, [0, 0, 0.44, 1]), rightHalf = split(box, [0.52, 0, 1, 1]);
+
+  // --- the picture: the same eight charges, on bigger and bigger shells -----
+  {
+    const cx = left.x0 + 6, cy = (left.y0 + left.y1) / 2;
+    const step = Math.min(left.w / 4.6, left.h / 2.2);
+
+    for (let r = 1; r <= 4; r++) {
+      const R = step * r;
+
+      ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+      ctx.beginPath(); ctx.arc(cx, cy, R, -Math.PI / 2.15, Math.PI / 2.15); ctx.stroke();
+
+      // SHEET charges on it, at fixed bearings so the eye follows one outward
+      for (let k = 0; k < SHEET; k++) {
+        const a = (-Math.PI / 2.3) + (Math.PI / 1.15) * (k + 0.5) / SHEET;
+        dot(s, cx + R * Math.cos(a), cy + R * Math.sin(a), 2.6, MODEL);
+      }
+
+      mono(s, cx + R * Math.cos(Math.PI / 2.3) + 4, cy + R * Math.sin(Math.PI / 2.3) + 12,
+        `${Math.round(shell(r))}`, FAINT, 9);
+    }
+
+    dot(s, cx, cy, 3.4, SEEN);
+    mono(s, left.x0, left.y0 + 10, `${SHEET} charges a pulse`, MODEL, 10);
+    mono(s, left.x0, left.y0 + 24, "cells on the shell, below each arc", FAINT, 9);
+    centred(s, (left.x0 + left.x1) / 2, left.y1 + 14,
+      "nobody wrote down 1/r²", INK, 10);
+  }
+
+  // --- and the same number as a probability, and as its complement ----------
+  {
+    const sc = axes(s, rightHalf, {
+      x: [HALF, 60], y: [0, 1.7], xlog: true,
+      xticks: [0.5, 1, 2, 5, 10, 20, 50],
+      yticks: [0, 0.5, 1, 1.5],
+    });
+
+    // a probability may saturate and may not exceed one — the line it crosses
+    poly(s, sc, [[HALF, 1], [60, 1]], { css: RELAT, wide: 1, dash: [3, 3] });
+
+    plot(s, sc, r => chance(1, r), { css: MODEL, wide: 1.8 }, { from: HALF, to: 60 });
+    plot(s, sc, r => through(1, r), { css: DATA, wide: 1.6 }, { from: HALF, to: 60 });
+
+    dot(s, sc.X(HALF), sc.Y(chance(1, HALF)), 3, MODEL);
+    mono(s, sc.X(HALF) + 6, sc.Y(chance(1, HALF)) - 5,
+      `${chance(1, HALF).toFixed(3)} at the core`, MODEL, 9);
+    mono(s, sc.X(HALF) + 6, sc.Y(chance(1, HALF)) + 8,
+      `— a probability, over one`, FAINT, 9);
+
+    key(s, rightHalf.x0 + 4, rightHalf.y1 - 8, [
+      [MODEL, "chance — one meets something"],
+      [DATA, "through — it sails past"],
+    ]);
+  }
+
+  under(s, "the falloff and the transparency are one fact about the geometry, counted once");
+};
+
+/** § one pulse, spread — the inverse square as a count over a shell */
+export const Shells = ({ height = 250 }: { height?: number }) =>
+  <Panel paint={shells} height={height}
+    note="a fixed count of charges, over a shell that grows — and what that leaves to get through" />;
+
+// ===========================================================================
+// 2. THE 26 EXITS, SORTED BY A NORTH
+//
+// Sort the ways out of a point by which side of an axis they fall on and there
+// is a +, an equator and a −. The equator is a ring — and it is a DIFFERENT
+// ring for each of the three axis classes, which is the thing the article had
+// quoted for one class only. Computed here rather than restated.
+
+type Axis = { name: string; n: number[]; members: number };
+
+const AXES: Axis[] = [
+  { name: "⟨100⟩ face", n: [0, 0, 1], members: 6 },
+  { name: "⟨110⟩ edge", n: [1, 1, 0], members: 12 },
+  { name: "⟨111⟩ corner", n: [1, 1, 1], members: 8 },
+];
+
+/** the equator of a north, in cyclic order, with the gaps between its members */
+const ringOf = (n: number[]) => {
+  const N = n.map(v => v / Math.hypot(...n));
+  // any two perpendiculars to N, to measure an azimuth against
+  const seed = Math.abs(N[2]) < 0.9 ? [0, 0, 1] : [1, 0, 0];
+  const u0 = [
+    seed[1] * N[2] - seed[2] * N[1], seed[2] * N[0] - seed[0] * N[2],
+    seed[0] * N[1] - seed[1] * N[0],
+  ];
+  const u = u0.map(v => v / Math.hypot(...u0));
+  const w = [N[1] * u[2] - N[2] * u[1], N[2] * u[0] - N[0] * u[2], N[0] * u[1] - N[1] * u[0]];
+
+  const on = directions(3).filter(d =>
+    Math.abs(d[0] * N[0] + d[1] * N[1] + d[2] * N[2]) < 1e-9);
+
+  const ang = on.map(d => {
+    const a = Math.atan2(
+      d[0] * w[0] + d[1] * w[1] + d[2] * w[2],
+      d[0] * u[0] + d[1] * u[1] + d[2] * u[2]);
+    return (a + 2 * Math.PI) % (2 * Math.PI);
+  }).sort((a, b) => a - b);
+
+  const gaps = ang.map((a, i) => {
+    const next = i + 1 < ang.length ? ang[i + 1] : ang[0] + 2 * Math.PI;
+    return (next - a) * 180 / Math.PI;
+  });
+
+  const above = directions(3).filter(d =>
+    (d[0] * N[0] + d[1] * N[1] + d[2] * N[2]) > 1e-9).length;
+
+  return { ang, gaps, above, uniform: Math.max(...gaps) - Math.min(...gaps) < 1e-6 };
+};
+
+const RINGS = lazily(() => AXES.map(a => ({ ...a, ...ringOf(a.n) })));
+
+const exits = (s: Surface) => {
+  const box = frame(s, 20, 34);
+  const { ctx } = s;
+  const cw = box.w / 3;
+
+  RINGS().forEach((r, i) => {
+    const cx = box.x0 + cw * (i + 0.5), cy = box.y0 + box.h * 0.42;
+    const R = Math.min(cw * 0.30, box.h * 0.28);
+
+    centred(s, cx, box.y0 + 12, r.name, INK, 11);
+    centred(s, cx, box.y0 + 26, `${r.members} of the 26 norths`, FAINT, 9);
+
+    // the ring itself, drawn where the azimuths actually fall
+    ctx.strokeStyle = GRID; ctx.lineWidth = 1;
+    ctx.beginPath(); ctx.arc(cx, cy, R, 0, 2 * Math.PI); ctx.stroke();
+
+    r.ang.forEach(a => {
+      const x = cx + R * Math.cos(a), y = cy - R * Math.sin(a);
+      ctx.strokeStyle = MODEL; ctx.lineWidth = 1.4;
+      ctx.beginPath(); ctx.moveTo(cx, cy); ctx.lineTo(x, y); ctx.stroke();
+      dot(s, x, y, 3, MODEL);
+    });
+    dot(s, cx, cy, 2.6, SEEN);
+
+    // + / equator / −, which is the count the easy-axis result reads
+    centred(s, cx, cy + R + 22,
+      `${r.above}  ${r.ang.length}  ${r.above}`, SEEN, 12);
+    centred(s, cx, cy + R + 36, "+   equator   −", FAINT, 9);
+
+    const spacing = r.uniform
+      ? `uniform ${r.gaps[0].toFixed(0)}°  ·  CYCLE = ${r.ang.length}`
+      : `NOT uniform — ${Math.min(...r.gaps).toFixed(2)}° / ${Math.max(...r.gaps).toFixed(2)}°`;
+    centred(s, cx, cy + R + 54, spacing, r.uniform ? GOOD : BAD, 10);
+  });
+
+  mono(s, box.x0, box.y1 - 12,
+    `SHEET(D) = 3^(D−1) − 1, so the ring size and the sheet size are one constant: ${SHEET} in three dimensions, 2 in two, and nothing at all in one`,
+    FAINT, 9);
+  under(s, "so the first dimension with a phase in it is the third — which is why the 1D walk found nothing to remove");
+};
+
+/** § what layer 1 throws away — and which ring it is */
+export const Exits = ({ height = 280 }: { height?: number }) =>
+  <Panel paint={exits} height={height}
+    note="the 26 exits sorted by a north — and the equator, which is a different ring for each axis class" />;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
index 79cdfea..6f7a337 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/models.ts
@@ -1737,10 +1737,10 @@ const systems: Model[] = ([
 
 /** Everything, in the order it is read in. */
 export const MODELS: Model[] = [
-  ...blocks,
+  // ...blocks,
   ...worlds,
   ...closedOnly,
   ...systems,
   ...known,
-  ...lines,
+  // ...lines,
 ];
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
index 117b1bb..ea44e4c 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/rotation.tsx
@@ -71,6 +71,73 @@ type Disc = typeof DISK;
 
 const sigma = (d: Disc, R: number) => d.M / (2 * Math.PI * d.Rd * d.Rd) * Math.exp(-R / d.Rd);
 
+/**
+ * Worked out the first time it is asked for, and never if it is not.
+ *
+ * Every curve on this page is a ring sum over a whole galaxy, and a ring sum is
+ * the one thing here expensive enough that WHEN it happens is visible: done at
+ * import, it is time the page spends before it has drawn anything at all, for
+ * panels that are thousands of pixels below the fold and may never be looked
+ * at. Done at the first frame of the panel that wants it, it is time spent by a
+ * canvas that is already on screen — and `CanvasView` only starts a canvas that
+ * is on screen, so the reader pays for the pictures they actually reach.
+ *
+ * The value is the same value either way. Only the moment moves.
+ */
+const lazily = <T,>(make: () => T): (() => T) => {
+  let made: T, ready = false;
+
+  return () => {
+    if (!ready) { made = make(); ready = true; }
+    return made;
+  };
+};
+
+/**
+ * The cosine and sine of the ring angles, at one resolution.
+ *
+ * `2π(j+½)/NP` does not depend on the ring, on the radius being asked about, or
+ * on which disc it is — it is the same NP angles every time — and yet it sat in
+ * the innermost loop of four different sums, which between them go round some
+ * fifty million times. So they are worked out once per NP and read after that.
+ *
+ * The numbers are the identical doubles the loop used to compute, so nothing
+ * downstream shifts by a bit.
+ */
+const RINGS = new Map<number, { cos: Float64Array, sin: Float64Array }>();
+
+const ringAngles = (NP: number) => {
+  let made = RINGS.get(NP);
+  if (made) return made;
+
+  const cos = new Float64Array(NP), sin = new Float64Array(NP);
+  for (let j = 0; j < NP; j++) {
+    const p = 2 * Math.PI * (j + 0.5) / NP;
+    cos[j] = Math.cos(p);
+    sin[j] = Math.sin(p);
+  }
+
+  RINGS.set(NP, made = { cos, sin });
+  return made;
+};
+
+/**
+ * `s²` raised to the power an inverse-`d^p` force wants, which is the whole of
+ * why these sums used to cost seconds.
+ *
+ * `Math.pow` with a fractional exponent is a general-purpose thing — a log, a
+ * multiply and an exp — and at 1½ it is thirty times the cost of the square
+ * root it actually is. `x^1.5` is `x·√x` and `x^1` is `x`, and both of those
+ * are single instructions. Every call site here asks for one of the two.
+ *
+ * BIT-IDENTICAL, not merely close: √ is correctly rounded and so is the
+ * multiply, and on the values these sums use the answer agrees with `Math.pow`
+ * to the last bit — checked against the quoted curves before it was changed.
+ * The general case is left as it was, for an exponent nothing asks for yet.
+ */
+const raised = (s2: number, e: number) =>
+  e === 1.5 ? s2 * Math.sqrt(s2) : e === 1 ? s2 : Math.pow(s2, e);
+
 /**
  * The radial pull at r in the plane from one exponential disc, summed over the
  * disc — kept split into the part inside r and the part outside it, since that
@@ -78,16 +145,17 @@ const sigma = (d: Disc, R: number) => d.M / (2 * Math.PI * d.Rd * d.Rd) * Math.e
  */
 const discPull = (d: Disc, r: number, NR = 420, NP = 480) => {
   const RMAX = 12 * d.Rd;
+  const { cos, sin } = ringAngles(NP);
+  const hh = d.h * d.h;
   let inside = 0, outside = 0;
   for (let i = 0; i < NR; i++) {
     const R = RMAX * (i + 0.5) / NR, dR = RMAX / NR;
     const s = sigma(d, R) * R * dR;
     let acc = 0;
     for (let j = 0; j < NP; j++) {
-      const p = 2 * Math.PI * (j + 0.5) / NP;
-      const dx = R * Math.cos(p) - r, dy = R * Math.sin(p);
-      const s2 = dx * dx + dy * dy + d.h * d.h;
-      acc += dx / Math.pow(s2, 1.5);
+      const dx = R * cos[j] - r, dy = R * sin[j];
+      const s2 = dx * dx + dy * dy + hh;
+      acc += dx / raised(s2, 1.5);
     }
     const bit = -G * s * acc * (2 * Math.PI / NP);
     if (R < r) inside += bit; else outside += bit;
@@ -167,12 +235,12 @@ export const pullAt = (r: number): Point => {
 
 const kms = (g: number, r: number) => Math.sqrt(Math.max(0, g * r)) / 1e3;
 
-/** computed once and shared by both panels */
-const CURVE: Point[] = (() => {
+/** computed once, on the first panel that asks, and shared by all of them */
+const CURVE = lazily((): Point[] => {
   const out: Point[] = [];
   for (let i = 1; i <= 60; i++) out.push(pullAt(i * 0.5 * KPC));
   return out;
-})();
+});
 
 // ---------------------------------------------------------------------------
 // AND THE CAUGHT-PAIR LAW, which is the same sum with the force falling as 1/d.
@@ -185,16 +253,17 @@ const CURVE: Point[] = (() => {
 /** the same ring sum, with the force falling as 1/d^p instead of 1/d² */
 const discPullP = (d: Disc, r: number, p: number, NR = 420, NP = 480) => {
   const RMAX = 12 * d.Rd;
+  const { cos, sin } = ringAngles(NP);
+  const hh = d.h * d.h, e = (p + 1) / 2;
   let acc = 0;
   for (let i = 0; i < NR; i++) {
     const R = RMAX * (i + 0.5) / NR, dR = RMAX / NR;
     const s = sigma(d, R) * R * dR;
     let a = 0;
     for (let j = 0; j < NP; j++) {
-      const ph = 2 * Math.PI * (j + 0.5) / NP;
-      const dx = R * Math.cos(ph) - r, dy = R * Math.sin(ph);
-      const d2 = dx * dx + dy * dy + d.h * d.h;
-      a += dx / Math.pow(d2, (p + 1) / 2);            // the unit vector, times 1/d^p
+      const dx = R * cos[j] - r, dy = R * sin[j];
+      const d2 = dx * dx + dy * dy + hh;
+      a += dx / raised(d2, e);                        // the unit vector, times 1/d^p
     }
     acc += -s * a * (2 * Math.PI / NP);
   }
@@ -227,17 +296,22 @@ const caughtRaw = (r: number) =>
  * 0.959, 0.974 at 6, 8, 10, 12, 16, 20, 25, 30 kpc — inside 4.5% across the
  * whole range the data covers, on one constant. Below 5 kpc it falls away, and
  * below 5 kpc there is no data either: the fit is not defined there.
+ *
+ * NOT DRAWN ON ANY PANEL YET — no `path` asks for it, so being `lazily` is the
+ * difference between a second of work at import for a curve nobody sees and no
+ * work at all. It is kept because the number above is a result and the code is
+ * how it was got; put it on a panel and it costs what it costs, once.
  */
-const CAUGHT: { r: number; v: number }[] = (() => {
+const CAUGHT = lazily((): { r: number; v: number }[] => {
   const R0 = 8.122 * KPC, at0 = pullAt(R0);
   const kappa =
     (Math.pow(MEASURED(8.122) * 1e3, 2) - at0.total * R0) / (caughtRaw(R0) * R0);
 
-  return CURVE.map(p => ({
+  return CURVE().map(p => ({
     r: p.r,
     v: Math.sqrt(Math.max(0, (p.total + kappa * caughtRaw(p.r)) * p.r)),
   }));
-})();
+});
 
 // ---------------------------------------------------------------------------
 
@@ -337,7 +411,7 @@ const curve = (s: Surface) => {
 
   // what was measured, over the radii it was measured at — and dotted where it
   // is being read outside them, since that is extrapolation and not data
-  const inside = CURVE.filter(p => p.r / KPC >= MEASURED_FROM && p.r / KPC <= MEASURED_TO);
+  const inside = CURVE().filter(p => p.r / KPC >= MEASURED_FROM && p.r / KPC <= MEASURED_TO);
   s.ctx.fillStyle = "rgba(238,240,245,0.09)";
   s.ctx.beginPath();
   inside.forEach((p, i) => {
@@ -351,18 +425,18 @@ const curve = (s: Surface) => {
   }
   s.ctx.closePath(); s.ctx.fill();
 
-  path(s, CURVE.filter(p => p.r / KPC <= MEASURED_FROM), X, Y,
+  path(s, CURVE().filter(p => p.r / KPC <= MEASURED_FROM), X, Y,
     p => MEASURED(p.r / KPC), SEEN, 1.4, [3, 3]);
-  path(s, CURVE.filter(p => p.r / KPC >= MEASURED_TO), X, Y,
+  path(s, CURVE().filter(p => p.r / KPC >= MEASURED_TO), X, Y,
     p => MEASURED(p.r / KPC), SEEN, 1.4, [3, 3]);
   path(s, inside, X, Y, p => MEASURED(p.r / KPC), SEEN, 2.2);
 
-  path(s, CURVE, X, Y, p => kms(mond(p.total), p.r), FLOOR, 1.3, [5, 4]);
+  path(s, CURVE(), X, Y, p => kms(mond(p.total), p.r), FLOOR, 1.3, [5, 4]);
 
-  path(s, CURVE, X, Y, p => kms(p.disc, p.r), PALE, 1.1);
-  path(s, CURVE, X, Y, p => kms(p.gas, p.r), GASC, 1.1);
-  path(s, CURVE, X, Y, p => kms(p.bulge, p.r), BULGEC, 1.1);
-  path(s, CURVE, X, Y, p => kms(p.total, p.r), MODEL, 2.4);
+  path(s, CURVE(), X, Y, p => kms(p.disc, p.r), PALE, 1.1);
+  path(s, CURVE(), X, Y, p => kms(p.gas, p.r), GASC, 1.1);
+  path(s, CURVE(), X, Y, p => kms(p.bulge, p.r), BULGEC, 1.1);
+  path(s, CURVE(), X, Y, p => kms(p.total, p.r), MODEL, 2.4);
 
   // Placed against the computed values, so nothing sits on a line it does not
   // belong to. Newton peaks 192.8 at 5.5 and is 103.7 at 30; MOND peaks 231.6
@@ -417,11 +491,11 @@ const apart = (s: Surface) => {
   }
   ctx.textAlign = "left";
 
-  path(s, CURVE, X, Y, p => Math.pow(MEASURED(p.r / KPC) * 1e3, 2) / (p.total * p.r) - 1,
+  path(s, CURVE(), X, Y, p => Math.pow(MEASURED(p.r / KPC) * 1e3, 2) / (p.total * p.r) - 1,
     SEEN, 2.4);
-  path(s, CURVE, X, Y, p => p.gr, DATA, 2.2);
-  path(s, CURVE, X, Y, p => p.carry, MODEL, 2.2, [5, 3]);
-  path(s, CURVE, X, Y, p => p.reach, MODEL, 1.4, [2, 3]);
+  path(s, CURVE(), X, Y, p => p.gr, DATA, 2.2);
+  path(s, CURVE(), X, Y, p => p.carry, MODEL, 2.2, [5, 3]);
+  path(s, CURVE(), X, Y, p => p.reach, MODEL, 1.4, [2, 3]);
 
   // observed runs 0.48…2.42, GR 4.1e−7 down to 1.2e−7, `carry` twice that,
   // `reach` 5e−12 at 5 kpc to 1.9e−10 at 30 — so these do not collide
@@ -450,14 +524,14 @@ const split = (s: Surface) => {
 
   // what the measurement needs, on the same scale — the pull Gaia's curve
   // implies, as a fraction of what the mass inside the orbit supplies
-  path(s, CURVE, X, Y,
+  path(s, CURVE(), X, Y,
     p => Math.pow(MEASURED(p.r / KPC) * 1e3, 2) / (p.r * p.inside), SEEN, 2.2);
-  path(s, CURVE, X, Y,
+  path(s, CURVE(), X, Y,
     p => mond(p.total) / p.inside, MODEL, 2.2);
 
-  path(s, CURVE, X, Y, p => 1, PALE, 1.6, [4, 3]);
-  path(s, CURVE, X, Y, p => p.outside / p.inside, DATA, 2.2);
-  path(s, CURVE, X, Y, p => p.total / p.inside, RELAT, 1.8, [5, 3]);
+  path(s, CURVE(), X, Y, p => 1, PALE, 1.6, [4, 3]);
+  path(s, CURVE(), X, Y, p => p.outside / p.inside, DATA, 2.2);
+  path(s, CURVE(), X, Y, p => p.total / p.inside, RELAT, 1.8, [5, 3]);
 
   tag(s, X(1.2), Y(2.42), "what is measured", SEEN);
   tag(s, X(1.2), Y(2.20), "this model", MODEL);
@@ -494,26 +568,26 @@ const speeder = (table: { r: number; v: number }[]) => (r: number) => {
   return table[i].v * (1 - f) + table[i + 1].v * f;
 };
 
-const LAWS = [
+const LAWS = lazily(() => [
   {
     name: "NEWTON & GR",
     under: "the baryons alone — the two agree to a part in 10⁶",
     css: DATA,
-    v: speeder(CURVE.map(p => ({ r: p.r, v: kms(p.total, p.r) * 1e3 }))),
+    v: speeder(CURVE().map(p => ({ r: p.r, v: kms(p.total, p.r) * 1e3 }))),
   },
   {
     name: "MEASURED",
     under: "Gaia DR2 × APOGEE",
     css: SEEN,
-    v: speeder(CURVE.map(p => ({ r: p.r, v: MEASURED(p.r / KPC) * 1e3 }))),
+    v: speeder(CURVE().map(p => ({ r: p.r, v: MEASURED(p.r / KPC) * 1e3 }))),
   },
   {
     name: "THIS MODEL",
     under: "the transport route — a₀ = cH₀/2π, computed",
     css: MODEL,
-    v: speeder(CURVE.map(p => ({ r: p.r, v: Math.sqrt(mond(p.total) * p.r) }))),
+    v: speeder(CURVE().map(p => ({ r: p.r, v: Math.sqrt(mond(p.total) * p.r) }))),
   },
-];
+]);
 
 const R_VIEW = 15 * KPC;                                  // as far as the data goes
 
@@ -577,7 +651,7 @@ const discs = (() => {
     const gap = 10, w = (width - gap * 2) / 3;
     const top = 32, side = Math.min(w, height - top - 22);
 
-    LAWS.forEach((law, n) => {
+    LAWS().forEach((law, n) => {
       const x0 = n * (w + gap);
       const cx = x0 + w / 2, cy = top + side / 2;
       const k = side * 0.48 / R_VIEW;
@@ -623,7 +697,7 @@ const discs = (() => {
         ctx.setLineDash([]);
       };
 
-      if (n !== 1) spokes(LAWS[1].v, GHOST, 1.3, [3, 3]);
+      if (n !== 1) spokes(LAWS()[1].v, GHOST, 1.3, [3, 3]);
       spokes(law.v, law.css, 1.7, []);
 
       ctx.fillStyle = law.css;
@@ -842,15 +916,16 @@ const HZ_Z = 1.613;
 /** the same ring sum, for a single exponential disc of the high-z kind */
 const hzNewton = (r: number, NRr = 300, NP = 300) => {
   const RMAX = 12 * HZ_RD, h = HZ_RD / 8;
+  const { cos, sin } = ringAngles(NP);
+  const hh = h * h;
   let acc = 0;
   for (let i = 0; i < NRr; i++) {
     const R = RMAX * (i + 0.5) / NRr, dRr = RMAX / NRr;
     const s = HZ_M / (2 * Math.PI * HZ_RD * HZ_RD) * Math.exp(-R / HZ_RD) * R * dRr;
     let a = 0;
     for (let j = 0; j < NP; j++) {
-      const p = 2 * Math.PI * (j + 0.5) / NP;
-      const dx = R * Math.cos(p) - r, dy = R * Math.sin(p);
-      a += dx / Math.pow(dx * dx + dy * dy + h * h, 1.5);
+      const dx = R * cos[j] - r, dy = R * sin[j];
+      a += dx / raised(dx * dx + dy * dy + hh, 1.5);
     }
     acc += -G * s * a * (2 * Math.PI / NP);
   }
@@ -859,7 +934,7 @@ const hzNewton = (r: number, NRr = 300, NP = 300) => {
 
 const HZ_VIEW = 16 * KPC;
 
-const HZ_LAWS = (() => {
+const HZ_LAWS = lazily(() => {
   const grid: { r: number; gN: number }[] = [];
   for (let i = 1; i <= 40; i++) {
     const r = i * 0.5 * KPC;
@@ -891,7 +966,7 @@ const HZ_LAWS = (() => {
       css: DATA, v: speeder(A0_MODEL * (1 + HZ_Z)),
     },
   ];
-})();
+});
 
 const HZ_STARS = (() => {
   const out: { r: number; th: number }[] = [];
@@ -932,7 +1007,7 @@ const hzDiscs = (() => {
     const gap = 10, w = (width - gap * 2) / 3;
     const top = 32, side = Math.min(w, height - top - 22);
 
-    HZ_LAWS.forEach((law, n) => {
+    HZ_LAWS().forEach((law, n) => {
       const x0 = n * (w + gap), cx = x0 + w / 2, cy = top + side / 2;
       const k = side * 0.48 / HZ_VIEW;
 
@@ -969,8 +1044,8 @@ const hzDiscs = (() => {
       };
       // Newton is the dashed grey ghost and the ceiling f_DM < 0.2 allows is
       // the dashed white one, so both references are in every panel.
-      if (n !== 0) spokes(HZ_LAWS[0].v, "rgba(111,123,168,0.45)", 1.2, [3, 3]);
-      spokes((r: number) => HZ_LAWS[0].v(r) * 1.118, GHOST, 1.2, [2, 4]);
+      if (n !== 0) spokes(HZ_LAWS()[0].v, "rgba(111,123,168,0.45)", 1.2, [3, 3]);
+      spokes((r: number) => HZ_LAWS()[0].v(r) * 1.118, GHOST, 1.2, [2, 4]);
       spokes(law.v, law.css, 1.7, []);
     });
 
@@ -1018,22 +1093,23 @@ const GZ: { name: string; z: number; logMs: number; fgas: number; Re: number }[]
 /** an exponential disc's own pull, summed ring by ring — no shell theorem */
 const gzBaryons = (Mbar: number, Rd: number, r: number, NRr = 240, NP = 240) => {
   const RMAX = 12 * Rd, h = Rd / 8;
+  const { cos, sin } = ringAngles(NP);
+  const hh = h * h;
   let acc = 0;
   for (let i = 0; i < NRr; i++) {
     const R = RMAX * (i + 0.5) / NRr, dRr = RMAX / NRr;
     const s = Mbar / (2 * Math.PI * Rd * Rd) * Math.exp(-R / Rd) * R * dRr;
     let a = 0;
     for (let j = 0; j < NP; j++) {
-      const p = 2 * Math.PI * (j + 0.5) / NP;
-      const dx = R * Math.cos(p) - r, dy = R * Math.sin(p);
-      a += dx / Math.pow(dx * dx + dy * dy + h * h, 1.5);
+      const dx = R * cos[j] - r, dy = R * sin[j];
+      a += dx / raised(dx * dx + dy * dy + hh, 1.5);
     }
     acc += -G * s * a * (2 * Math.PI / NP);
   }
   return acc;
 };
 
-const GZ_CURVES = GZ.map(d => {
+const GZ_CURVES = lazily(() => GZ.map(d => {
   const Mbar = Math.pow(10, d.logMs) * MSUN / (1 - d.fgas);
   const Rd = d.Re * KPC / 1.68;
   const pts: { r: number; bar: number; mod: number }[] = [];
@@ -1044,7 +1120,7 @@ const GZ_CURVES = GZ.map(d => {
     pts.push({ r, bar: Math.sqrt(Math.max(0, gB * r)), mod: Math.sqrt(Math.max(0, gM * r)) });
   }
   return { d, pts, Re: d.Re * KPC };
-});
+}));
 
 const gzPanel = (s: Surface) => {
   const { ctx, width, height } = s;
@@ -1057,7 +1133,7 @@ const gzPanel = (s: Surface) => {
   const top = 42, bot = 30, hh = height - top - bot;
   const VMAX = 420;
 
-  GZ_CURVES.forEach((g, n) => {
+  GZ_CURVES().forEach((g, n) => {
     const x0 = pad + n * (w + gap);
     const RMAXk = 3.0 * g.d.Re;
     const X = (rk: number) => x0 + w * Math.min(rk, RMAXk) / RMAXk;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/shelter.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/shelter.tsx
new file mode 100644
index 0000000..d1f51ea
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/shelter.tsx
@@ -0,0 +1,315 @@
+/**
+ * NOTHING PULLS — SPACE RAINS, AND EACH BODY SHELTERS THE OTHER.
+ *
+ * This is the one picture the gravity arc needs and does not have. Everything
+ * else in the article is a measurement; this is the mechanism, at the scale a
+ * reader can watch it happen:
+ *
+ *     Space is full of charges going in every direction, all the time.
+ *     A body eats the ones that reach it.
+ *     So a body is a SHADOW, and two of them stand in each other's.
+ *     Each is therefore hit less on the side facing the other,
+ *     and being hit less on one side is being pushed toward it.
+ *
+ * There is no attraction anywhere in that, and nothing reaches across the gap.
+ * Each body is pushed inward, from outside, by rain that is *missing* rather
+ * than by anything that arrives.
+ *
+ * IT IS THE REAL RULE, SLOWED DOWN. `tests/sphere.ts`'s rule exactly — every
+ * point sends one charge along each of its edges every tick, every charge is
+ * destroyed where it lands, a point that received k sends k back out, a body
+ * takes and sends nothing — run one tick every few frames so that the charges
+ * can be drawn sliding from the cell they left to the cell they land on. What
+ * is on screen is the actual charges of the actual rule, sampled down to a
+ * number the eye can follow, not a cartoon of them.
+ *
+ * AND THE DENT IS NOT EXAGGERATED. The rose on each body is where its hits
+ * came from, counted. Measured on this arrangement, the sheltered side takes
+ * 61% of an even share against the far side's 99% — a 47% dent at close range,
+ * 21% at middling, 6% far out. It is drawn at its true size because it does
+ * not need help.
+ *
+ * IN TWO DIMENSIONS, so that it can be seen at all. The lattice has 8 ways out
+ * of a point rather than 26, and the force consequently falls as 1/r rather
+ * than 1/r² — which is a fact about the plane and not about the mechanism.
+ */
+
+import { Painter, Surface } from "./canvas";
+import {
+  BAD, DATA, FAINT, GOOD, INK, Live, MODEL, SEEN, centred, dot, frame, mono,
+  right, split, tag, under,
+} from "./sketch";
+
+// ---------------------------------------------------------------------------
+// the lattice, in a plane
+
+/** the eight ways out of a point, in order round the circle */
+const WAYS: [number, number][] = [
+  [1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1],
+];
+const DEG8 = WAYS.length;
+
+const N = 101, O = (N - 1) / 2, CELLS = N * N;
+const RADIUS = 4;
+
+/** how many charges the drawing follows — the rest are run and not drawn */
+const SHOWN = 620;
+
+type Charge = { fx: number; fy: number; tx: number; ty: number; eaten: number };
+
+type World = {
+  q: Uint8Array; nq: Uint8Array; phase: Uint8Array; body: Uint8Array;
+  /** where the two bodies are, and what they have taken */
+  bx: [number, number];
+  hits: [Float64Array, Float64Array];
+  push: [number, number];
+  /** the charges being drawn this tick */
+  shown: Charge[];
+  t: number;
+};
+
+const at = (x: number, y: number) => (y + O) * N + (x + O);
+const off = WAYS.map(([dx, dy]) => dy * N + dx);
+
+const mark = (w: World) => {
+  w.body.fill(0);
+  w.bx.forEach((cx, i) => {
+    for (let y = -RADIUS; y <= RADIUS; y++) for (let x = -RADIUS; x <= RADIUS; x++)
+      if (x * x + y * y <= RADIUS * RADIUS) w.body[at(Math.round(cx) + x, y)] = i + 1;
+  });
+};
+
+const born = (): World => {
+  const w: World = {
+    q: new Uint8Array(CELLS).fill(DEG8), nq: new Uint8Array(CELLS),
+    phase: new Uint8Array(CELLS), body: new Uint8Array(CELLS),
+    bx: [-13, 13],
+    hits: [new Float64Array(DEG8), new Float64Array(DEG8)],
+    push: [0, 0],
+    shown: [], t: 0,
+  };
+  mark(w);
+  return w;
+};
+
+const onRim = (x: number, y: number) =>
+  Math.abs(x) >= O - 1 || Math.abs(y) >= O - 1;
+
+/**
+ * One tick of the rule — and, as it goes, a sample of the charges kept for
+ * drawing and a tally of which way the ones that hit a body were going.
+ *
+ * The tally IS the force: a charge destroyed at a body was travelling in a
+ * definite direction when it landed, so what a body takes is the sum of the
+ * headings of everything that arrived.
+ */
+const step = (w: World) => {
+  const { q, nq, phase, body } = w;
+  nq.fill(0);
+  w.shown.length = 0;
+
+  // hits are let fade rather than summed for ever, so the rose follows the
+  // bodies as they move instead of remembering where they used to be
+  for (const h of w.hits) for (let i = 0; i < DEG8; i++) h[i] *= 0.94;
+
+  // one in `every` charges is kept for the drawing, spread evenly over the box
+  let seen = 0;
+  const every = Math.max(1, Math.floor(CELLS * DEG8 / SHOWN));
+
+  for (let y = -O; y <= O; y++) for (let x = -O; x <= O; x++) {
+    const c = at(x, y);
+    if (body[c]) continue;
+
+    const k = onRim(x, y) ? DEG8 : q[c];
+    if (!k) continue;
+
+    const p = phase[c];
+    for (let j = 0; j < k; j++) {
+      const e = (p + j) % DEG8;
+      const to = c + off[e];
+      nq[to]++;
+
+      const hit = body[to];
+      if (hit) w.hits[hit - 1][e] += 1;
+
+      if (seen++ % every === 0)
+        w.shown.push({
+          fx: x, fy: y,
+          tx: x + WAYS[e][0], ty: y + WAYS[e][1],
+          eaten: hit,
+        });
+    }
+    phase[c] = (p + k) % DEG8;
+  }
+
+  const t = w.q; w.q = w.nq; w.nq = t;
+  w.t++;
+
+  // and what the tally comes to, along the line between them
+  w.push = [0, 1].map(i => {
+    let fx = 0;
+    for (let e = 0; e < DEG8; e++) fx += w.hits[i][e] * WAYS[e][0] / Math.hypot(...WAYS[e]);
+    return fx;
+  }) as [number, number];
+};
+
+// ---------------------------------------------------------------------------
+// the picture
+
+const TICK = 0.30;                       // seconds a tick is stretched over
+
+const shelter = (): Painter => {
+  let w: World;
+  let phase = 0;                          // where we are between two ticks
+  let drift: [number, number] = [0, 0];   // momentum the bodies have banked
+
+  return {
+    start: () => { w = born(); phase = 0; drift = [0, 0]; },
+    stop: () => { (w as any) = null; },
+
+    frame: (s: Surface, dt: number) => {
+      phase += dt / TICK;
+      while (phase >= 1) {
+        phase -= 1;
+        step(w);
+
+        // once the field has settled, let the push actually move them — which
+        // is the payoff, and the only place a number is scaled: a mobility, so
+        // that a drift worth watching happens inside a few seconds
+        if (w.t > 90) {
+          // measured on this arrangement: the push runs 6.8 at a gap of 18
+          // cells and 26 at a gap of 4, so this closes the gap in about half a
+          // minute and visibly accelerates as the shelter deepens
+          drift[0] += w.push[0] * 1.0e-2;
+          drift[1] += w.push[1] * 1.0e-2;
+          let moved = false;
+          for (const i of [0, 1]) {
+            while (Math.abs(drift[i]) >= 1) {
+              const d = Math.sign(drift[i]);
+              if (Math.abs(w.bx[0] - w.bx[1]) > 2 * RADIUS + 2 || d * (i ? -1 : 1) < 0) {
+                w.bx[i] += d; moved = true;
+              }
+              drift[i] -= d;
+            }
+          }
+          if (moved) mark(w);
+        }
+      }
+
+      const box = frame(s, 16, 34);
+      const { ctx } = s;
+      const left = split(box, [0, 0, 0.60, 1]), side = split(box, [0.64, 0, 1, 1]);
+
+      const px = Math.min(left.w / (2 * 34), left.h / (2 * 24));
+      const cx = (left.x0 + left.x1) / 2, cy = (left.y0 + left.y1) / 2;
+      const X = (x: number) => cx + x * px, Y = (y: number) => cy - y * px;
+
+      // --- the rain, mid-hop -------------------------------------------------
+      for (const c of w.shown) {
+        const x = X(c.fx + (c.tx - c.fx) * phase);
+        const y = Y(c.fy + (c.ty - c.fy) * phase);
+
+        if (c.eaten) {
+          // a charge being destroyed, which is the only event in the model
+          ctx.fillStyle = `rgba(235,150,74,${(1 - phase).toFixed(2)})`;
+          ctx.beginPath(); ctx.arc(x, y, 1.9 + 2.4 * phase, 0, 2 * Math.PI); ctx.fill();
+        } else {
+          ctx.fillStyle = "rgba(200,214,235,0.42)";
+          ctx.fillRect(x - 0.9, y - 0.9, 1.8, 1.8);
+        }
+      }
+
+      // --- the two bodies, and the rose of where each was hit ---------------
+      w.bx.forEach((bxi, i) => {
+        const bx = X(bxi), by = Y(0);
+
+        ctx.fillStyle = SEEN;
+        ctx.beginPath(); ctx.arc(bx, by, RADIUS * px, 0, 2 * Math.PI); ctx.fill();
+
+        const h = w.hits[i];
+        const mean = h.reduce((a, b) => a + b, 0) / DEG8 || 1;
+        const R0 = (RADIUS + 3) * px, SPAN = 4.6 * px;
+
+        // the rose: how many hits came in along each of the eight ways, drawn
+        // out from a circle at the even share — so the DENT is the picture
+        ctx.beginPath();
+        for (let e = 0; e <= DEG8; e++) {
+          const k = e % DEG8;
+          const a = Math.atan2(WAYS[k][1], WAYS[k][0]);
+          const r = R0 + SPAN * (h[k] / mean - 1) * 1.6;
+          const px2 = bx - r * Math.cos(a), py2 = by + r * Math.sin(a);
+          e ? ctx.lineTo(px2, py2) : ctx.moveTo(px2, py2);
+        }
+        ctx.closePath();
+        ctx.strokeStyle = MODEL; ctx.lineWidth = 1.6; ctx.stroke();
+
+        // the even share it is drawn against
+        ctx.strokeStyle = "rgba(255,255,255,0.20)"; ctx.lineWidth = 1;
+        ctx.setLineDash([2, 3]);
+        ctx.beginPath(); ctx.arc(bx, by, R0, 0, 2 * Math.PI); ctx.stroke();
+        ctx.setLineDash([]);
+
+        // and which way that adds up to
+        const towards = i === 0 ? 1 : -1;
+        const len = Math.min(46, Math.abs(w.push[i]) * 2.6);
+        ctx.strokeStyle = GOOD; ctx.lineWidth = 2.6;
+        ctx.beginPath();
+        ctx.moveTo(bx + towards * (RADIUS + 8) * px, by);
+        ctx.lineTo(bx + towards * ((RADIUS + 8) * px + len), by);
+        ctx.stroke();
+        const tip = bx + towards * ((RADIUS + 8) * px + len);
+        ctx.beginPath();
+        ctx.moveTo(tip + towards * 6, by);
+        ctx.lineTo(tip, by - 4.5); ctx.lineTo(tip, by + 4.5);
+        ctx.closePath(); ctx.fillStyle = GOOD; ctx.fill();
+      });
+
+      // the gap, named
+      const gap = Math.abs(w.bx[0] - w.bx[1]) - 2 * RADIUS;
+      ctx.strokeStyle = "rgba(255,255,255,0.16)"; ctx.lineWidth = 1;
+      ctx.setLineDash([3, 4]);
+      ctx.beginPath();
+      ctx.moveTo(X(0), Y(0) - 13 * px); ctx.lineTo(X(0), Y(0) + 13 * px);
+      ctx.stroke(); ctx.setLineDash([]);
+      centred(s, X(0), Y(0) - 14 * px, "fewer charges get through here", FAINT, 10);
+
+      tag(s, left.x0 + 4, left.y0 + 13, "every dot is one charge, mid-hop", INK);
+      mono(s, left.x0 + 4, left.y0 + 28, "orange = a charge being eaten by a body", DATA, 9);
+      mono(s, left.x0 + 4, left.y1 - 6,
+        `tick ${w.t}  ·  gap ${gap} cells  ·  blue outline = where the hits came from`, FAINT, 9);
+
+      // --- the numbers, which are the whole argument ------------------------
+      {
+        const h = w.hits[0];
+        const far = h[0], near = h[4];              // +x is outward, −x is inward
+        const mean = h.reduce((a, b) => a + b, 0) / DEG8 || 1;
+
+        tag(s, side.x0, side.y0 + 14, "the left body, counted", INK);
+
+        mono(s, side.x0, side.y0 + 38, "hit from the FAR side", SEEN, 10);
+        mono(s, side.x0, side.y0 + 53, `${(100 * far / mean).toFixed(0)}% of an even share`, SEEN, 12);
+
+        mono(s, side.x0, side.y0 + 80, "hit from BETWEEN them", DATA, 10);
+        mono(s, side.x0, side.y0 + 95, `${(100 * near / mean).toFixed(0)}% of an even share`, DATA, 12);
+
+        const dent = 100 * (far - near) / ((far + near) / 2 || 1);
+        mono(s, side.x0, side.y0 + 126, `a ${dent.toFixed(0)}% dent`, GOOD, 13);
+        mono(s, side.x0, side.y0 + 143, "on the sheltered side", GOOD, 10);
+
+        mono(s, side.x0, side.y0 + 172, "so it is pushed inward —", INK, 10);
+        mono(s, side.x0, side.y0 + 186, "by rain that is MISSING,", INK, 10);
+        mono(s, side.x0, side.y0 + 200, "not by anything arriving.", INK, 10);
+
+        mono(s, side.x0, side.y1 - 30, "nothing crosses the gap.", BAD, 10);
+        mono(s, side.x0, side.y1 - 16, "nothing pulls.", BAD, 11);
+      }
+
+      under(s, "the rule is unchanged and the dent is drawn at its true size — this is the whole of what gravity is here");
+    },
+  };
+};
+
+/** two bodies in the rain, each sheltering the other */
+export const Shelter = ({ height = 380 }: { height?: number }) =>
+  <Live make={shelter} height={height}
+    note="space rains charges from every direction — a body eats them, so two of them shelter each other and are pushed together" />;
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/sketch.tsx b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/sketch.tsx
new file mode 100644
index 0000000..cf3a9eb
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/sketch.tsx
@@ -0,0 +1,342 @@
+/**
+ * THE DRAWING KIT THE CHART PANELS SHARE — said once, because it was already
+ * being said twice.
+ *
+ * `rotation.tsx` and `magnetism.tsx` each carry their own copy of the same
+ * eight functions (a `frame`, an `axes`, a `path`, a `tag`, an `under`, a
+ * `Panel`), and `magnetism.tsx` says so in as many words: "the same drawing
+ * helpers the rotation panels use, kept local so this file stands on its own".
+ * A third copy would have settled the matter the wrong way, so this is the one
+ * copy, and the two older files can be moved onto it whenever anybody is
+ * touching them for another reason. Nothing here is new; what is new is that
+ * there is one of it.
+ *
+ * WHAT IS NOT IN HERE, deliberately:
+ *
+ *   the canvas       `canvas.tsx` — `CanvasView` owns sizing, the device
+ *                    ratio, the frame loop, and letting the pixels go when
+ *                    nobody is looking. Nothing below allocates a canvas.
+ *   the palette      `paint.ts` — the ground and the charge colours are the
+ *                    ones the lattice pictures use, read from there rather
+ *                    than retyped, so a change to the palette is one change.
+ *   any physics      `field.ts`, `gravity.ts`, `magnet.ts`, `physics.ts`,
+ *                    `lattice.ts`. A panel that needs a number asks the file
+ *                    that owns it. Nothing here computes one.
+ */
+
+import { CanvasView, Painter, Surface } from "./canvas";
+import { BACKGROUND, rgb } from "./paint";
+
+// ---------------------------------------------------------------------------
+// THE PALETTE, IN ITS CHART ROLES
+//
+// `paint.ts` names colours by what a thing IS on the lattice — a positive
+// charge, a source, space that has not been charged. A chart needs a different
+// question answered: is this line a measurement, a textbook, or this model.
+// Those are the three roles every panel in the article already uses, and the
+// numbers are the ones `rotation.tsx` chose.
+
+/** The ground, from `paint.ts` — so a chart and a lattice picture sit on the same black. */
+export const BACK = rgb(BACKGROUND);
+
+export const INK = "#c8cbd4";                 // ordinary text on a panel
+export const FAINT = "#5a5f6e";               // captions, ticks, anything said quietly
+export const GRID = "rgba(255,255,255,0.055)";
+
+/** WHAT IS MEASURED IS WHITE — the one line on any panel that is not a theory. */
+export const SEEN = "#eef0f5";
+export const GHOST = "rgba(238,240,245,0.40)";
+
+export const MODEL = "#4aa8eb";               // this model
+export const DATA = "#eb964a";                // the textbook it is being read against
+export const RELAT = "#9aa0b4";               // a reading that was tried and failed
+export const GOOD = "#8bd48b", BAD = "#e0685f";
+
+// ---------------------------------------------------------------------------
+// THE BOX, AND WHAT MAPS INTO IT
+
+export type Box = {
+  x0: number; x1: number; y0: number; y1: number; w: number; h: number;
+};
+
+/**
+ * Clear to the ground and hand back the rectangle a plot may draw in.
+ *
+ * The bottom pad carries two lines — the tick labels and the axis caption —
+ * so it is deep enough for both by default. It was not, once, and they sat on
+ * top of one another.
+ */
+export const frame = (s: Surface, pad = 46, bottom = 36, top = 12): Box => {
+  const { ctx, width, height } = s;
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = BACK;
+  ctx.fillRect(0, 0, width, height);
+  return {
+    x0: pad, x1: width - 14, y0: top, y1: height - bottom,
+    w: width - 14 - pad, h: height - bottom - top,
+  };
+};
+
+/** A sub-rectangle of a box, in fractions of it — for panels that are two plots. */
+export const split = (
+  box: Box, [ax, ay, bx, by]: [number, number, number, number],
+): Box => {
+  const x0 = box.x0 + box.w * ax, x1 = box.x0 + box.w * bx;
+  const y0 = box.y0 + box.h * ay, y1 = box.y0 + box.h * by;
+  return { x0, x1, y0, y1, w: x1 - x0, h: y1 - y0 };
+};
+
+export type Scale = {
+  X: (v: number) => number;
+  Y: (v: number) => number;
+  /** The inverse, which the panels that read a pixel back need. */
+  toX: (px: number) => number;
+  box: Box;
+};
+
+export type AxisOpt = {
+  x: [number, number];
+  y: [number, number];
+  xticks?: number[];
+  yticks?: number[];
+  xfmt?: (v: number) => string;
+  yfmt?: (v: number) => string;
+  /** Decades rather than units — the axis a falloff has to be read on. */
+  xlog?: boolean;
+  ylog?: boolean;
+  /** Lines across the plot at every tick. Off for pictures, on for charts. */
+  grid?: boolean;
+  /** Ticks drawn without their labels, where the numbers would crowd. */
+  bare?: boolean;
+};
+
+const num = (v: number) =>
+  Math.abs(v) >= 1e4 || (v !== 0 && Math.abs(v) < 1e-3)
+    ? v.toExponential(0).replace("e+", "e")
+    : String(Number(v.toPrecision(4)));
+
+/**
+ * The axes, and the two functions that put a number where it belongs.
+ *
+ * A log axis is the same code with a log in front of it, which is the only
+ * reason it is worth having here rather than in each panel: the ticks, the
+ * labels and the clamping all follow from the mapping and none of them wants
+ * to be written twice.
+ */
+export const axes = (s: Surface, box: Box, opt: AxisOpt): Scale => {
+  const { ctx } = s;
+  const tx = opt.xlog ? Math.log10 : (v: number) => v;
+  const ty = opt.ylog ? Math.log10 : (v: number) => v;
+
+  const [xa, xb] = opt.x.map(tx), [ya, yb] = opt.y.map(ty);
+
+  const X = (v: number) => box.x0 + box.w * (tx(v) - xa) / (xb - xa || 1);
+  const Y = (v: number) => box.y1 - box.h * (ty(v) - ya) / (yb - ya || 1);
+  const toX = (px: number) => {
+    const t = xa + (px - box.x0) * (xb - xa) / (box.w || 1);
+    return opt.xlog ? Math.pow(10, t) : t;
+  };
+
+  ctx.font = "400 10px ui-monospace, Menlo, monospace";
+  ctx.strokeStyle = GRID;
+  ctx.lineWidth = 1;
+
+  for (const t of opt.yticks ?? []) {
+    const y = Y(t);
+    if (opt.grid !== false) {
+      ctx.beginPath(); ctx.moveTo(box.x0, y); ctx.lineTo(box.x1, y); ctx.stroke();
+    }
+    if (opt.bare) continue;
+    ctx.fillStyle = FAINT; ctx.textAlign = "right";
+    ctx.fillText((opt.yfmt ?? num)(t), box.x0 - 6, y + 3);
+  }
+
+  for (const t of opt.xticks ?? []) {
+    const x = X(t);
+    if (opt.grid !== false) {
+      ctx.beginPath(); ctx.moveTo(x, box.y0); ctx.lineTo(x, box.y1); ctx.stroke();
+    }
+    if (opt.bare) continue;
+    ctx.fillStyle = FAINT; ctx.textAlign = "center";
+    ctx.fillText((opt.xfmt ?? num)(t), x, box.y1 + 15);
+  }
+
+  ctx.textAlign = "left";
+  return { X, Y, toX, box };
+};
+
+// ---------------------------------------------------------------------------
+// WHAT GOES IN IT
+
+export type Stroke = {
+  css: string; wide?: number; dash?: number[]; alpha?: number;
+};
+
+/** A line through points already in data coordinates. */
+export const poly = (
+  s: Surface, sc: Scale, pts: [number, number][], { css, wide = 1.6, dash = [], alpha = 1 }: Stroke,
+) => {
+  const { ctx } = s;
+  ctx.save();
+  ctx.globalAlpha = alpha;
+  ctx.strokeStyle = css; ctx.lineWidth = wide; ctx.setLineDash(dash);
+  ctx.beginPath();
+  pts.forEach(([x, y], i) => (i ? ctx.lineTo(sc.X(x), sc.Y(y)) : ctx.moveTo(sc.X(x), sc.Y(y))));
+  ctx.stroke();
+  ctx.restore();
+  ctx.setLineDash([]);
+};
+
+/**
+ * A function, sampled where the plot can see it.
+ *
+ * Sampled in SCREEN space rather than in data space, which matters on a log
+ * axis: a hundred equal steps in `r` put ninety of them in the last decade
+ * and leave the first one drawn as a corner.
+ */
+export const plot = (
+  s: Surface, sc: Scale, f: (x: number) => number, stroke: Stroke,
+  { from, to, n = 220 }: { from: number; to: number; n?: number },
+) => {
+  const pts: [number, number][] = [];
+  const a = sc.X(from), b = sc.X(to);
+  for (let i = 0; i <= n; i++) {
+    const x = sc.toX(a + (b - a) * i / n), y = f(x);
+    if (Number.isFinite(y)) pts.push([x, y]);
+  }
+  poly(s, sc, pts, stroke);
+};
+
+/** A filled band between two functions — a measurement's error, usually. */
+export const band = (
+  s: Surface, sc: Scale, lo: (x: number) => number, hi: (x: number) => number,
+  css: string, { from, to, n = 120 }: { from: number; to: number; n?: number },
+) => {
+  const { ctx } = s;
+  const a = sc.X(from), b = sc.X(to);
+  ctx.fillStyle = css;
+  ctx.beginPath();
+  for (let i = 0; i <= n; i++) {
+    const x = sc.toX(a + (b - a) * i / n);
+    i ? ctx.lineTo(sc.X(x), sc.Y(hi(x))) : ctx.moveTo(sc.X(x), sc.Y(hi(x)));
+  }
+  for (let i = n; i >= 0; i--) {
+    const x = sc.toX(a + (b - a) * i / n);
+    ctx.lineTo(sc.X(x), sc.Y(lo(x)));
+  }
+  ctx.closePath(); ctx.fill();
+};
+
+export const dot = (s: Surface, x: number, y: number, r: number, css: string) => {
+  const { ctx } = s;
+  ctx.fillStyle = css;
+  ctx.beginPath(); ctx.arc(x, y, r, 0, 2 * Math.PI); ctx.fill();
+};
+
+// ---------------------------------------------------------------------------
+// WORDS ON IT
+
+export const tag = (s: Surface, x: number, y: number, text: string, css: string, size = 11) => {
+  s.ctx.fillStyle = css;
+  s.ctx.font = `500 ${size}px ui-sans-serif, system-ui, sans-serif`;
+  s.ctx.fillText(text, x, y);
+};
+
+export const mono = (s: Surface, x: number, y: number, text: string, css: string, size = 10) => {
+  s.ctx.fillStyle = css;
+  s.ctx.font = `400 ${size}px ui-monospace, Menlo, monospace`;
+  s.ctx.fillText(text, x, y);
+};
+
+export const centred = (s: Surface, x: number, y: number, text: string, css: string, size = 10) => {
+  s.ctx.textAlign = "center";
+  mono(s, x, y, text, css, size);
+  s.ctx.textAlign = "left";
+};
+
+export const right = (s: Surface, x: number, y: number, text: string, css: string, size = 10) => {
+  s.ctx.textAlign = "right";
+  mono(s, x, y, text, css, size);
+  s.ctx.textAlign = "left";
+};
+
+/** The caption under the whole panel, kept off the ticks it used to sit on. */
+export const under = (s: Surface, text: string, css = FAINT) => {
+  centred(s, s.width / 2, s.height - 6, text, css, 10);
+};
+
+/** A row of colour swatches and what each one is. */
+export const key = (
+  s: Surface, x: number, y: number, of: [string, string][], size = 10,
+) => {
+  const { ctx } = s;
+  let at = x;
+  for (const [css, text] of of) {
+    ctx.fillStyle = css;
+    ctx.fillRect(at, y - 6, 14, 2.5);
+    at += 19;
+    mono(s, at, y, text, INK, size);
+    at += ctx.measureText(text).width + 16;
+  }
+};
+
+// ---------------------------------------------------------------------------
+// THE PANEL ITSELF
+//
+// One shape for every figure in the article: a caption in small caps, and a
+// black box of a stated height with a canvas filling it. The canvas comes from
+// `canvas.tsx` and nothing here touches its element, its size or its ratio.
+
+const CAPTION: React.CSSProperties = {
+  fontSize: "0.72em", letterSpacing: "0.08em", textTransform: "uppercase",
+  color: FAINT, marginBottom: 6,
+};
+
+/**
+ * A still: one frame each time it comes on screen, and no loop.
+ *
+ * `animate: false` is the whole difference between this and `Live` below, and
+ * it is not a small one — a still costs nothing at all while it is being read,
+ * where a loop is a claim on the machine for as long as the panel is alive.
+ * Anything that is not actually moving should be one of these.
+ */
+export const Panel = ({ paint, height, note }: {
+  paint: (s: Surface) => void; height: number; note: string;
+}) => <div style={{ marginBottom: "1.1rem" }}>
+  <div style={CAPTION}>{note}</div>
+  <div style={{ height, background: BACK }}>
+    <CanvasView animate={false} deps={[note]} paint={() => ({ frame: paint })} />
+  </div>
+</div>;
+
+/**
+ * And one that runs — a simulation, or anything with a clock in it.
+ *
+ * `make` is called as the panel comes on screen and its `Painter` may allocate
+ * whatever it likes in `start`, so long as `stop` lets go of it: a relaxation
+ * field of forty thousand cells, a list of charges in flight, an image buffer.
+ * `CanvasView` calls both at the right moments and nothing here has to know
+ * when those are.
+ */
+export const Live = ({ make, height, note }: {
+  make: () => Painter; height: number; note: string;
+}) => <div style={{ marginBottom: "1.1rem" }}>
+  <div style={CAPTION}>{note}</div>
+  <div style={{ height, background: BACK }}>
+    <CanvasView deps={[note]} paint={make} />
+  </div>
+</div>;
+
+/**
+ * Worked out the first time it is asked for, and never if it is not — the same
+ * `lazily` `rotation.tsx` has, and for the same reason: a panel below the fold
+ * that is never scrolled to should cost nothing, and an import-time constant
+ * costs its whole sum before the page has drawn anything at all.
+ */
+export const lazily = <T,>(make: () => T): (() => T) => {
+  let made: T, ready = false;
+  return () => {
+    if (!ready) { made = make(); ready = true; }
+    return made;
+  };
+};
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
index ea67f62..25a1d02 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/README.md
@@ -125,11 +125,29 @@ appears it is a measured input, not a result.
 | `dipole` | the reading that **fails**: bias on a *direction*, out of one emitter. Pole-to-pole gives nothing and the fall-off is 1/R². Superseded in its conclusion by `poles` — it rules out an object, not the machinery |
 | `poles` | **and the one that works** — bias on a *place*, so a bar is + at one end and − at the other. Same `chance`, same co-location, same XOR: **3cos²θ − 1 to three decimals, slope −2.00 (so 1/R⁴), all five orientations**. Magnetostatics, with nothing added |
 | `ordering` | **where the poles come from** — the bulk really does cancel and the faces really do not, and it *still* is not a magnet: every sided ordering gives 1/r² because the sign is decided at the destination. Turns the gap into one line of `physics.ts` |
-| `budget` | **how many pulses a magnet needs.** The mass layer caps the XOR at 2×, so magnetism is its own layer; √(µ0/4πG) = 38.7 kg per A·m converts it; a 1 cm N52 cube must emit as if it weighed 4.5 tonnes. One material constant, 4.5·10⁷ kg/m² of pole face, six geometries, no residual |
+| `departure` | **and that line is not a choice** — the sign resolved at the source and at the destination are the same number, exactly, because a pulse that reaches an observer was emitted into the observer's direction. Both give 2.000. And "monopole" was too kind: the sided tally has zero flux at every radius and a flat sgn(cos θ)/r² with a step at the equator, which no field can be. **Σ sgn(n·d̂)/r² is a tally of received pulses, not a field** |
+| `divp` | **where the poles actually come from** — make the primitive a per-node polarisation **p** and the emitted sign **−div p**, which is nought in the interior and appears only where the body ends. Net zero identically, 1/r³, cos θ, all five orientations, 1/R⁴ — and it survives the test that kills the hand-placed version: **cut it in half and you get two magnets**, where by-half gives two monopoles. Reconciles with `ordering` §1, which measured −div p and then threw it away |
+| `domains` | **what orders them.** Dipolar does not — it selects zero net polarisation, the standard result. A rate coupling does, and the retardation in it gives a coherence ceiling at ω·L ≈ π. Both halves are superseded below: the coupling is *derived* in `response`, and the ceiling turns out not to be a domain (`domainsize`) and not to apply to a held axis (`align`) |
+| `escape` | **is −div p derived, or a third rule?** Run the annihilation ledger: 1664 pulses, 600 annihilated head-on, and what is left is nought in every interior layer and equal-and-opposite on the two ends. **The surface density is derived.** But a *sided* source's escaped pulses stay directional — kept that way the exponent is 2.005 — so something more is needed. Its name for that ("isotropic emission") is corrected by `aggregate` |
+| `aggregate` | **and the owed thing is one sentence, not a rule.** A pulse goes one way, so "isotropic emission" means nothing; what the far field needs is a direction-independent **sign**, which is `physics.ts`'s non-sided branch cos(2πβ) — already in the model, and ballistic, giving 3.000 with strength −div p and cos θ to 6.5e−7. Scattering is **not** available as the escape route: the inverse square IS ballistic shell dilution (measured: ballistic 1.90, scattering 1.10–1.18 rim-corrected), so a diffusing emission would take gravity with it. What is left owed is **regional sourcing** — that a region re-emits its unpaired excess — which the Layer-2 arc already assumes for bound states || `response` | **the coupling, out of rule (G/1).** The annihilation *count* between two emitters is EVEN in the phase difference and cannot lock (0.57 drifting, against 0.9996 for an odd one). Its first *moment* about a source's own axis is exactly odd, with no cosine and no mean. `domains` no longer assumes its coupling. One bit is left over: whether a source runs fast or slow in shortened space |
+| `align` | a moment about an axis is a torque on it, which **closes the sign-vs-polarisation fork from the mechanism**: the coupling acts on p, so the emitted sign stays −div p. Its §3–§4 negative ordering result is **withdrawn by `texture` §3** — the torque summed there diverges linearly with the cutoff |
+| `exchange` | **the ordering, with a quantity that converges.** `align`'s torque dropped both the second 1/r² and the `sin(θ/2)` splice; put back, it converges. Then a fork: integrated over **all space** it is ferro along a bond and anti across one — the dipolar pattern, driving closure. Integrated **along the line**, which is what every force in the arc actually uses, it is ferro on every bond — exchange-like. Under the line reading a 5³ block relaxes from random to |⟨p̂⟩| = 1.0000 and a field cycle gives an **open hysteresis loop**, pinned by the ring's 45° discreteness. And the fork is resolvable on the model's own terms: the two readings disagree about **distance** too — line gives 1/R², space gives 1/R (measured 0.94) — so the space reading would cost Newton. Since a force and a torque are two derivatives of one interaction, the set that gives Newton gives the ferromagnet. What that assumes, and all it assumes, is that the pull and the torque come from a single conservative quantity |
+| `feedback` | **the model is one-way, and that is the gap under every ordering result.** `bearing(s,tick) = phase + tick·rate(s)/CYCLE`; nothing in `physics.ts` or `gravity.ts` ever writes to a source. So `exchange`'s relaxation minimises an energy the model does not have with a dynamics it does not have — the ferromagnet and the hysteresis loop drop back to **conditional**. `response` and `exchange` hit the same wall from two sides. What the model DOES own is an orientation-dependent **pull**, and that alone segregates a mobile population: ⟨cos Δ⟩ goes 0 → 0.89 with **no axis ever turning**. Order by migration, not rotation — real, and the wrong kind of order for a magnet |
+| `permute` | **what the missing feedback could be** — a search over READ × ACT. Dimension cuts the grid; then gravity kills every rule that writes to a **beat**, since `beat = 1/mass` and mass would become a function of the neighbourhood. So the feedback must act on the **axis**. Of six axis rules, all three aligning-sign ones give a ferromagnet (0.95–1.00) and all three opposing ones give nothing — frustrated, not antiferro. **Which read does not matter**, so the ordering is not a fit to a rule chosen for it. What is owed is one bit: the sign, which is the same bit `response` owes for the beat |
+| `texture` | **the corrections, and they go the other way.** −div p needs a **net** p, not a uniform one — the far field is an integral functional, so four stripe domains, a biased random texture and a closure swirl with a small net all give 3.000 and cos θ, with only the moment scaling. Which means a relaxation ending in closure refutes nothing: **a virgin ferromagnet has no net moment either**, and a permanent magnet is a pinned metastable state. Plus: the `align` torque diverges with cutoff, and "dipolar favours closure" is the **simple-cubic** answer (validated here to 5 figures against Sci. Rep. 10:19154) where **Luttinger–Tisza give bcc and fcc ferromagnetic** — the lattices real ferromagnets use || `domainsize` | **and the domain prediction does not survive units.** L = λ/2 is 10⁻¹⁹ m for an iron atom and 10⁻³⁴ m on the turn clock, against 10⁻⁵ m measured — short by fourteen orders. Inverted, it wants a carrier of 10⁻³ eV. What survives is a real ceiling on anything phase-coherent, and it is not about magnets |
+| `budget` | **how many pulses a magnet needs.** The mass layer caps the XOR at 2×, so magnetism is its own layer; √(µ0/4πG) = 38.7 kg per A·m converts it; a 1 cm N52 cube must emit as if it weighed 4.5 tonnes. One material constant, 4.5·10⁷ kg/m² of pole face, six geometries, no residual. The *area* in that is no longer empirical: a divergence lives on a surface, so `divp` makes the area law a consequence and leaves one number owed rather than a number plus a dimension |
 | `scale` | the ceiling: µ/M ∝ 1/m², so **the lightest constituent wins by the square**; what real magnets use of it; and the area law for planets and stars — 4.5 mm of aligned skin is the Earth's whole field |
 | `tradeoff` | one ceiling, so the budget is shared: **magnetising a thing makes it lighter**. The cheap version is already dead — a kg bar would lose 10 mg — which puts a floor of 10¹⁴ under the magnetic coupling |
 | `maxwell` | **the audit** — 13 derived, 2 built in, 11 missing, 3 refuted, and why what is left missing is all on the electric side |
 
+### layer 2 — the charge, the phase and the ring
+
+| | |
+|---|---|
+| `ring` | **the ring is the face ring.** Sort the 26 exits by a north and the equator closes at 45° a step only for the 6 face axes; the 8 corner axes give a uniform ring of **six**, and the 12 edge axes — the largest class — give eight directions at **alternating 54.74°/35.26°**, which is no ring at all. So `CYCLE = 8` holds for 6 of 26 norths, 14 of 26 carry any uniform ring, and they carry two different quanta. Also: ring size is `SHEET(D) = 3^(D−1) − 1`, so **magnetism needs D ≥ 3 derivably** |
+| `holonomy` | **the ring and the flux cannot both be true.** The continuum transport does give the swept solid angle and is gauge-invariant to 1e−15 (with an open link as the control, moving by the whole circle). But a smooth texture advances the azimuth ~1e−2 rad a step against a 45° quantum, so a phase genuinely *on* the ring snaps to zero every step and the holonomy is **identically 0 on every plaquette**. A third option the arc does not consider — a superposition over ring members — keeps both, at a price. Plus: **Ω/2 and g = 2 are one assumption used twice** |
+| `bloch` | **the force, re-measured.** The two senses do separate oppositely and the norm holds to 1e−14, but the arc's symmetry control is on the wrong variable — k₀ = 0 is where they separate *most* — and the separation is not t². Windowed fits run 1.90, 2.46, 2.34, 1.30, −4.24: it is a **Bloch oscillation**, confirmed outright by g·t\* = k₀ and g·Δt = π to three figures across a factor of three in g. The coupling survives; the acceleration law does not |
+
 ### and the same theory without the XOR
 
 | | |
@@ -171,19 +189,66 @@ And on the electromagnetic side, the bills, all of them structural:
 6. **the two in g** — `µ/L = q/2m` with the radius cancelling, so g = 1
    whatever else is chosen. The lattice has a place a two could live (an axis
    comes round in CYCLE/2 where a north takes CYCLE) but `emission` tracks
-   north, so taking it means changing the emission rule.
+   north, so taking it means changing the emission rule. The Layer-2 arc takes
+   it by separating the axis from the north — and then also writes Φ = Ω/2 in
+   its flux table, which is the same half a second time. `holonomy` §4: **the
+   book is entitled to one of them as an assumption and must get the other as a
+   result.**
 7. **the magnetic coupling** — 4.5·10⁷ kg/m² of pole face, measured and not
-   counted. The mechanism is derived and only the scale is owed, which is
+   counted. Now behind item 10 in the queue: a coupling constant for a magnet
+   the model cannot yet assemble is the wrong thing to worry about first. The mechanism is derived and only the scale is owed, which is
    exactly where `a₀` stood before `cH₀/2π`. See `budget`, and `tradeoff` for
    the floor a weighing already puts under it.
-10. **is a pulse's sign fixed when it leaves, or when it arrives?** The sharpest
-   one, and the cheapest to answer. `emission` resolves the sign against the
-   axis *at the destination*, which is why no ordering of sided emitters makes
-   poles (`ordering`). Fix it at the source and the faces become poles with
-   nothing else changed.
+10. ~~is a pulse's sign fixed when it leaves, or when it arrives?~~ **Closed,
+   and it was not a question** — `departure`. ~~What does the rate coupling
+   lock?~~ **Also closed** — `align` §1: a moment about an axis is a torque on
+   it, so it acts on the polarisation. What replaces both, and is now the
+   load-bearing magnetic debt, and it is now two: **regional sourcing** (item
+   15), and **feedback onto a source** (item 18). The ordering is not settled —
+   `exchange`'s ferromagnet assumes axes relax to maximise meetings, and
+   `feedback` shows nothing in the model can make them.
+11. **the ring fork** — `ring` and `holonomy` are one decision. A continuous
+   phase gets the Aharonov–Bohm result and loses the 45° quantum; a quantised
+   one keeps the quantum and gets no flux from any smooth texture. The
+   superposition route keeps both and costs more room than the arc costed.
+12. ~~the domain prediction against measurement~~ **Done, and it fails** —
+   `domainsize`. Short by fourteen orders on the beat clock, and inapplicable
+   to a held axis. What survives is a coherence ceiling on anything
+   phase-coherent, which is real and is not about magnets.
+14. **the sign of the derived coupling** — one bit, and it belongs to the
+   gravity arc: does a source run fast or slow in space that annihilation has
+   shortened? `response` §3.
+15. **regional sourcing** — that a region re-emits its unpaired excess as its
+   own non-sided source. `escape` derives the excess; `aggregate` narrows the
+   gap to this one sentence and rules out the two wrong ways to close it
+   (scattering, and a new "isotropic" rule). It is the same statement the
+   Layer-2 arc already assumes for bound states, so items 13 and 15 are one
+   item — and it is now the load-bearing magnetic debt.
+13. **emission sourced by regional layer-2 content** — flagged as a choice by
+   the Layer-2 arc and untested. Testable without settling the ring: build a
+   region with N strands and check the emission is one train at the summed rate
+   while the relative offset does not collectivise.
 8. **P itself** — measured everywhere, derived nowhere. Predicting it needs a
    model of matter: the mass pulsing and the biased pulsing are the same
    stream, so the relation is between `beat` and `dwell`.
 9. **electric charge** — the largest of them. The model has emitters and a
    bias, and no account of matter to say which emitter anything is. Until it
    does, the electric half of the audit stays empty.
+
+16. **the Luttinger–Tisza computation on bcc and fcc**, properly, with an Ewald
+   sum. `domains` §1 ruled the ordering out on simple cubic, which is the one
+   cubic lattice where dipolar cannot ferromagnet; iron is bcc and nickel is
+   fcc. `texture` §4 flags this and does not attempt it — the quick sphere sum
+   there is validated for sc and buggy for the other two, and says so.
+17. ~~a convergent definition of the annihilation torque~~ **Done** —
+   `exchange` §1. It is the arc's own meeting integral: both 1/r² factors, plus
+   the `sin(θ/2)` splice that `gravity.ts` says keeps the space integral
+   convergent. What is left is which SET to integrate over — see item 10.
+18. **what does a source do about what arrives?** — `feedback` §1. The model is
+   strictly one-way, and gravity never needed otherwise: a pull is a fact about
+   the space between two things. Every ordering result needs the arrow to point
+   back. `response` asks it of the beat, `exchange` of the axis; it is one
+   question and the book has never had to answer it before.
+19. **the sign of the feedback** — one bit. Aligning gives a ferromagnet,
+   opposing gives disorder, and nothing in the model says which. `permute` §4
+   and `response` §3 are the same bit asked of the axis and of the beat.
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/aggregate.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/aggregate.ts
new file mode 100644
index 0000000..c2d8a53
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/aggregate.ts
@@ -0,0 +1,320 @@
+/**
+ * DOES THE EMISSION HAVE TO BE ISOTROPIC PER PULSE, OR ONLY IN AGGREGATE?
+ *
+ * `escape` derives the source density −div p from the annihilation ledger, then
+ * finds the far field is still 2.005 rather than 3.000 because the escaped
+ * pulses are DIRECTIONAL: a top face emits + into the upper hemisphere and a
+ * bottom face emits − into the lower one, so a distant observer above hears the
+ * + and never hears the −. It books "isotropic emission" as an owed rule.
+ *
+ * The NAME is wrong and the DEBT is much smaller than the name suggests, and
+ * this file separates the two.
+ *
+ *   §1  A pulse goes one way; it cannot be emitted in every direction, so
+ *       "isotropic emission" as a rule about pulses means nothing. What the far
+ *       field needs is that the SIGN not depend on the direction of emission.
+ *       Those are different claims.
+ *
+ *   §2  And scattering cannot be what supplies it — a tempting answer and a
+ *       wrong one. The model's 1/r² IS ballistic shell dilution. `gravity.ts`
+ *       states the alternative outright: p = 1 gives 1/r², p = 0 gives 1/r. Let
+ *       the emission diffuse and the inverse-square law goes with it. Measured
+ *       here, because it is worth being sure about.
+ *
+ *   §3  But the direction-independent sign is not a new rule at all. It is
+ *       `physics.ts`'s OTHER branch — cos(2πβ), the non-sided source — which is
+ *       isotropic in sign and ballistic in flight at the same time.
+ *
+ *   §4  And the magnetism arc has already established that the magnetic layer
+ *       is a SEPARATE emission stream from the mass one. So it is free to be
+ *       non-sided while the mass stream is sided, and nothing has to be added.
+ *
+ *   §5  What is genuinely owed, after all that, is one sentence and not a rule.
+ */
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const key = (a: V) => `${a[0]},${a[1]},${a[2]}`;
+const sgn = (x: number) => (Math.abs(x) < 1e-12 ? 0 : x > 0 ? 1 : -1);
+
+const WAYS: V[] = (() => {
+  const out: V[] = [];
+  for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+    if (x || y || z) out.push([x, y, z]);
+  return out;
+})();
+const UWAYS = WAYS.map(unit);
+
+let seed = 20260815;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+const reseed = () => { seed = 20260815; };
+
+const block = (L: number, H: number): V[] => {
+  const out: V[] = [];
+  for (let i = 0; i < L; i++) for (let j = 0; j < L; j++) for (let k = 0; k < H; k++)
+    out.push([i - (L - 1) / 2, j - (L - 1) / 2, k - (H - 1) / 2]);
+  return out;
+};
+
+const slope = (f: (r: number) => number, r0: number, r1: number) => {
+  const xs: number[] = [], ys: number[] = [];
+  for (let r = r0; r <= r1; r *= 1.3) {
+    const v = Math.abs(f(r));
+    if (v > 1e-300) { xs.push(Math.log(r)); ys.push(Math.log(v)); }
+  }
+  const n = xs.length, mx = xs.reduce((a, b) => a + b) / n, my = ys.reduce((a, b) => a + b) / n;
+  let num = 0, den = 0;
+  for (let i = 0; i < n; i++) { num += (xs[i] - mx) * (ys[i] - my); den += (xs[i] - mx) ** 2; }
+  return -num / den;
+};
+
+export function aggregateReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("1. 'ISOTROPIC EMISSION' WAS THE WRONG NAME FOR THE OWED THING");
+  line("=".repeat(78));
+  line();
+  line("  A pulse goes one way. It cannot be emitted in every direction at");
+  line("  once, so a rule saying it is would not mean anything, and `escape`");
+  line("  booking one was booking something incoherent. Two separable claims");
+  line("  were being run together:");
+  line();
+  line("     (a) THE SIGN does not depend on the direction of emission.");
+  line("         A source puts the same sign into all 26 exits this tick,");
+  line("         and each of those pulses still flies one way.");
+  line();
+  line("     (b) the pulses ARRIVE from all directions, so a distant observer");
+  line("         hears from every part of the body rather than the near face.");
+  line();
+  line("  (a) is what the far field actually needs. (b) is a statement about");
+  line("  propagation, and §2 shows the model cannot have it.");
+
+  line();
+  line("=".repeat(78));
+  line("2. AND SCATTERING CANNOT SUPPLY IT — THE INVERSE SQUARE IS BALLISTIC");
+  line("=".repeat(78));
+  line();
+  line("  The tempting answer is that pulses scatter, so a pulse forgets which");
+  line("  way it was let go, so the arrival is isotropic in aggregate however");
+  line("  directional the emission was. The model even has the machinery: the");
+  line("  gravity arc's vacuum walk has mean cosine p = 0.8154, a run of 5.42");
+  line("  steps, so direction memory would be gone within a few cells.");
+  line();
+  line("  IT IS THE WRONG ANSWER, AND THE ARC SAYS SO IN ANOTHER PLACE.");
+  line("  `chance(m,r) = m·SHEET/shell(r)` is the whole derivation of the");
+  line("  inverse-square law, and it is shell dilution of pulses that FLY");
+  line("  STRAIGHT. `gravity.ts` puts the two extremes side by side while");
+  line("  discussing the vacuum surplus:");
+  line();
+  line("     p = 1  (straight line)      gives 1/r²");
+  line("     p = 0  (fresh direction)    gives 1/r");
+  line();
+  line("  So a diffusing emission does not preserve the inverse square, it");
+  line("  replaces it. Measured, on a point source with an absorbing rim, as");
+  line("  the exponent of the occupancy density against radius:");
+  line();
+  line("     propagation                     raw   rim-corrected");
+
+  // The steady-state occupancy of a point source, done the way `gravity.ts`
+  // does it: walkers released from the origin, an ABSORBING rim, and the time
+  // each walker spends in each shell accumulated. Density = occupancy / shell.
+  // A diffusive walker needs ~R²/D steps to reach the rim, so the step budget
+  // has to be generous or the profile is an artefact of the cap.
+  const RIM = 40;
+  const profile = (pers: number, walkers = 20000) => {
+    const bins = new Float64Array(RIM + 1);
+    for (let w = 0; w < walkers; w++) {
+      let d = Math.floor(rnd() * WAYS.length);
+      const at: V = [0, 0, 0];
+      for (let t = 0; t < 400000; t++) {
+        if (rnd() > pers) d = Math.floor(rnd() * WAYS.length);
+        at[0] += WAYS[d][0]; at[1] += WAYS[d][1]; at[2] += WAYS[d][2];
+        const r = len(at);
+        if (r >= RIM) break;                       // absorbed at the rim
+        bins[Math.floor(r)] += 1;
+      }
+    }
+    return (r: number) => {
+      const b = Math.floor(r);
+      if (b < 1 || b > RIM) return 0;
+      return bins[b] / (4 * Math.PI * b * b);
+    };
+  };
+  // With an absorbing rim the diffusive profile is (S/4πD)·(1−r/R)/r, not a
+  // pure power — that is the form `gravity.ts` validated to 0.1%. So the raw
+  // slope is contaminated by the (1−r/R) rolloff and has to be divided out.
+  // A ballistic walker crosses every shell exactly once and picks up no such
+  // factor, so its raw slope is already the answer.
+  for (const [name, pers, want] of [["ballistic (p = 1)", 1, "1/r²"],
+                                    ["persistent (p = 0.815)", 0.8154, ""],
+                                    ["fresh direction (p = 0)", 0, "1/r"]] as [string, number, string][]) {
+    reseed();
+    const f = profile(pers);
+    const raw = slope(f, 4, 20);
+    const corr = slope(r => f(r) / (1 - r / RIM), 4, 20);
+    line(`     ${name.padEnd(30)}${raw.toFixed(3).padStart(6)}${(pers === 1 ? "—" : corr.toFixed(3)).padStart(12)}` +
+      `${want ? "     ← " + want : ""}`);
+  }
+  line();
+  line("  1.90 against 2 for the ballistic case (lattice discretisation), and");
+  line("  1.10 and 1.18 against 1 for the two scattering cases once the rim is");
+  line("  divided out. Exactly the bracket the arc states.");
+  line();
+  line("  So scattering does not preserve the inverse square, it destroys it —");
+  line("  and the inverse square is the one thing the gravity arc is least");
+  line("  willing to give up. SO THE EMISSION IN THIS");
+  line("  MODEL FLIES STRAIGHT, and `escape`'s directional reading was not an");
+  line("  unstated assumption — it is the model's own propagation, and I was");
+  line("  wrong to look for a way round it there.");
+
+  line();
+  line("=".repeat(78));
+  line("3. BUT THE SIGN IS A DIFFERENT QUESTION, AND THAT BRANCH ALREADY EXISTS");
+  line("=".repeat(78));
+  line();
+  line("  Claim (a) survives §2 untouched, because it is not about flight at");
+  line("  all. `physics.ts` has exactly two source kinds:");
+  line();
+  line("     emission = sided ? along() : cos(2πβ)");
+  line();
+  line("     SIDED       the sign is the direction resolved against an axis, so");
+  line("                 it DOES depend on which way the pulse goes. This is");
+  line("                 the one that gives the step function and no field.");
+  line();
+  line("     NON-SIDED   the sign is cos(2πβ) — the source's own phase, the");
+  line("                 same into every exit this tick. Direction does not");
+  line("                 enter. AND IT STILL FLIES STRAIGHT, so the 1/r² is");
+  line("                 untouched.");
+  line();
+  line("  The non-sided branch satisfies (a) and keeps §2's ballistic flight at");
+  line("  the same time. There is no tension and nothing to invent — it is a");
+  line("  branch the model has had since before the magnetism arc.");
+  line();
+  line("  Measured, on the same body, with the same escaped-charge magnitudes:");
+  line();
+
+  const cells = block(4, 4);
+  const inside = new Set(cells.map(key));
+  const AXIS: V = [0, 0, 1];
+  // the surface density −div p, which `escape` derives from the ledger
+  const src: { at: V; s: number }[] = [];
+  {
+    const pv = (x: number, y: number, z: number, a: number) =>
+      inside.has(`${x},${y},${z}`) ? AXIS[a] : 0;
+    const wanted = new Set<string>();
+    for (const c of cells)
+      for (const d of WAYS) wanted.add(`${c[0] + d[0]},${c[1] + d[1]},${c[2] + d[2]}`);
+    for (const c of cells) wanted.add(key(c));
+    for (const k of wanted) {
+      const [x, y, z] = k.split(",").map(Number);
+      const div = (pv(x + 1, y, z, 0) - pv(x - 1, y, z, 0)) / 2 +
+        (pv(x, y + 1, z, 1) - pv(x, y - 1, z, 1)) / 2 +
+        (pv(x, y, z + 1, 2) - pv(x, y, z - 1, 2)) / 2;
+      if (Math.abs(div) > 1e-12) src.push({ at: [x, y, z], s: -div });
+    }
+  }
+
+  const nearestIdx = (u: V) => {
+    let best = 0, bd = -2;
+    for (let i = 0; i < UWAYS.length; i++) { const c = dot(UWAYS[i], u); if (c > bd) { bd = c; best = i; } }
+    return best;
+  };
+  // SIDED: the sign the observer gets is resolved against the axis
+  const sided = (x: V) => {
+    let t = 0;
+    for (const c of cells) {
+      const dv = sub(x, c), r = len(dv);
+      if (r < 1e-9) continue;
+      t += sgn(dot(AXIS, UWAYS[nearestIdx(unit(dv))])) / (r * r);
+    }
+    return t;
+  };
+  // NON-SIDED, strength −div p: the same sign into every exit, flying straight
+  const nonsided = (x: V) => {
+    let t = 0;
+    for (const n of src) { const r = len(sub(x, n.at)); if (r > 1e-9) t += n.s / (r * r); }
+    return t;
+  };
+
+  line("     source kind                              exponent    what it is");
+  line(`     sided (sign resolved on the axis)         ${slope(r => sided([0, 0, r]), 200, 3200).toFixed(3)}      a step, no field`);
+  line(`     non-sided, strength −div p                ${slope(r => nonsided([0, 0, r]), 200, 3200).toFixed(3)}      A MAGNET`);
+  line();
+  const R = 1200;
+  let ref = 0, worst = 0;
+  for (let d = 0; d <= 180; d += 10) {
+    const th = d * Math.PI / 180;
+    // potential, to read the angular law
+    let v = 0;
+    for (const n of src) {
+      const r = len(sub([R * Math.sin(th), 0, R * Math.cos(th)], n.at));
+      if (r > 1e-9) v += n.s / r;
+    }
+    v *= R * R;
+    if (d === 0) ref = v;
+    worst = Math.max(worst, Math.abs(v / ref - Math.cos(th)));
+  }
+  line(`     and its angular law against cos θ:  max deviation ${worst.toExponential(1)}`);
+
+  line();
+  line("=".repeat(78));
+  line("4. AND THE MAGNETIC LAYER IS ALREADY A SEPARATE STREAM");
+  line("=".repeat(78));
+  line();
+  line("  Which is what makes §3 an identification rather than a change. The");
+  line("  objection would be that the mass emission is sided and cannot be");
+  line("  quietly swapped — but `budget` settled that the magnetic emission is");
+  line("  not the mass emission at all:");
+  line();
+  line("     if the biased pulses were a subset of the mass pulses, the whole");
+  line("     effect would be the (1 − P_a·P_b) factor, which runs 0 to 2, so");
+  line("     the most magnetism could ever be is ONE TIMES GRAVITY — and two");
+  line("     touching N52 cubes pull 2.2·10¹² times their own gravity.");
+  line();
+  line("  So the magnetic layer has its own budget and its own pulses, and");
+  line("  nothing requires those pulses to be sided just because the mass ones");
+  line("  are. A body's polarisation p is carried by whatever holds the axes;");
+  line("  the magnetic emission it sources need only be non-sided with strength");
+  line("  −div p, and both halves of that are already in the model.");
+
+  line();
+  line("=".repeat(78));
+  line("5. SO WHAT IS ACTUALLY OWED IS ONE SENTENCE");
+  line("=".repeat(78));
+  line();
+  line("     NOT OWED   a new emission rule. Direction-independent sign is the");
+  line("                non-sided branch, ballistic flight is what it already");
+  line("                does, and the two together give 3.000 and cos θ.");
+  line();
+  line("     NOT AVAILABLE   scattering as an escape from the sided reading.");
+  line("                §2 — it would take the inverse-square law with it.");
+  line("                `escape`'s directional reading of a SIDED source is");
+  line("                correct and stands.");
+  line();
+  line("     OWED       that the strength of the non-sided magnetic emission is");
+  line("                the local −div p. `escape` §1 derives the DENSITY from");
+  line("                the annihilation ledger; what is not shown is that a");
+  line("                region re-emits its unpaired excess as its own");
+  line("                non-sided source rather than the excess simply being");
+  line("                what escapes.");
+  line();
+  line("  That is the regional-sourcing statement the Layer-2 arc already");
+  line("  assumes for bound states, and it is one sentence rather than a rule:");
+  line("  a region's emission is sourced by what is in the region. Still owed,");
+  line("  still load-bearing, and much narrower than 'isotropic emission'.");
+  line();
+  line("  THE HONEST SUMMARY OF THIS FILE: the aggregate objection is right");
+  line("  about the name and wrong about the mechanism. Nothing is isotropic in");
+  line("  aggregate here, because nothing scatters. What is true is that the");
+  line("  model already contains a source whose sign does not depend on");
+  line("  direction, so the thing `escape` said had to be added does not.");
+
+  return L.join("\n");
+}
+
+console.log(aggregateReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/align.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/align.ts
new file mode 100644
index 0000000..ca684ef
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/align.ts
@@ -0,0 +1,299 @@
+/**
+ * WHAT DOES THE COUPLING LOCK — the emitted sign, or the polarisation?
+ *
+ * `domains` §2 flags this as the fork that decides the physics and settles it
+ * by preference: the sign reading gives a body of like signs, which `departure`
+ * shows is not even a field, so take the polarisation reading. That is an
+ * argument from consequence and not from the mechanism.
+ *
+ * `response` settles it from the mechanism, and did so without meaning to. The
+ * thing it measures is the FIRST MOMENT of the annihilation density about a
+ * source's own axis — that is a torque on the axis, not a shift of a sign. So
+ * what the coupling acts on is the direction the source points, which is the
+ * polarisation. The fork is closed, and closed the right way.
+ *
+ * That closes item 3 and immediately opens the question this file is really
+ * about, because a torque on a direction is a different kind of object from a
+ * drive on a phase:
+ *
+ *   §1  the torque, and that it is a torque
+ *   §2  which removes the retardation problem — a held axis has no ω, so
+ *       ω·r is nought at every distance and there is no coherence ceiling.
+ *       AND THEREFORE NO DOMAIN PREDICTION. `domainsize` shows why that is a
+ *       relief rather than a loss.
+ *   §3  and then the test that decides whether any of this is a ferromagnet:
+ *       does the torque depend on the BOND DIRECTION? Dipolar does, which is
+ *       why dipolar picks closure over alignment. IT DOES — strongly, with a
+ *       cosine component across the axes and no coupling at all out of the
+ *       plane — so it is not an exchange.
+ *   §4  and relaxed with the measured torque rather than a model of it, a
+ *       block does not become uniformly polarised under either sign. The
+ *       ordering is still owed, and now precisely: `divp` needs a uniform p
+ *       and both couplings the model supplies choose closure instead.
+ */
+
+const TAU = Math.PI * 2;
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const add = (a: V, b: V): V => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+const mul = (a: V, s: number): V => [a[0] * s, a[1] * s, a[2] * s];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const sgn = (x: number) => (Math.abs(x) < 1e-9 ? 0 : x > 0 ? 1 : -1);
+
+/** an axis in the xy-plane, at angle a in turns */
+const ax = (a: number): V => [Math.cos(TAU * a), Math.sin(TAU * a), 0];
+
+const around = (c: V, R: number): V[] => {
+  const out: V[] = [];
+  const r = Math.ceil(R);
+  for (let x = -r; x <= r; x++) for (let y = -r; y <= r; y++) for (let z = -r; z <= r; z++) {
+    const d = Math.hypot(x, y, z);
+    if (d > 0.5 && d <= R) out.push([c[0] + x, c[1] + y, c[2] + z]);
+  }
+  return out;
+};
+
+const NEAR = around([0, 0, 0], 4);
+
+/**
+ * The torque on a source at the origin pointing along `an`, from a source at
+ * `at` pointing along `am`. Same annihilation rule as `escape` and `response`:
+ * where the two disagree about a cell's sign, space is destroyed there, and the
+ * first moment of that about n's own axis is what turns n.
+ */
+const torque = (an: V, at: V, am: V) => {
+  let moment = 0;
+  for (const y of NEAR) {
+    const dn = unit(y), dm = unit(sub(y, at));
+    const sn = sgn(dot(an, dn)), sm = sgn(dot(am, dm));
+    if (sn === 0 || sm === 0 || sn === sm) continue;
+    const w = 1 / (len(sub(y, at)) ** 2);
+    moment += w * (an[0] * dn[1] - an[1] * dn[0]);
+  }
+  return moment;
+};
+
+const harmonics = (f: (d: number) => number, n = 720) => {
+  let s = 0, c = 0, mean = 0, s2 = 0;
+  for (let i = 0; i < n; i++) {
+    const d = i / n, v = f(d);
+    mean += v / n;
+    s += 2 * v * Math.sin(TAU * d) / n;
+    c += 2 * v * Math.cos(TAU * d) / n;
+    s2 += 2 * v * Math.sin(2 * TAU * d) / n;
+  }
+  return { mean, sin: s, cos: c, sin2: s2 };
+};
+
+let seed = 20260815;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+
+export function alignReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+  const R = 8;
+
+  line("=".repeat(78));
+  line("1. IT IS A TORQUE ON THE AXIS, SO WHAT LOCKS IS THE POLARISATION");
+  line("=".repeat(78));
+  line();
+  line("  `response` measures the first moment of the annihilation density");
+  line("  about a source's own axis. A moment about an axis is a torque on it.");
+  line("  Nothing in it touches the emitted sign — the sign is sgn(axis·d) and");
+  line("  follows the axis, rather than the other way round.");
+  line();
+  line("     SO THE FORK IS CLOSED FROM THE MECHANISM. What the coupling acts");
+  line("     on is the polarisation vector, not the emitted sign. The sign");
+  line("     stays −div p, and the monopole branch of `domains` §2 is not a");
+  line("     branch the model has.");
+  line();
+  line("  `domains` §2 got the right answer for a weaker reason, and this is");
+  line("  the reason. Note what this does NOT yet say: that the polarisation");
+  line("  ends up uniform. §3 and §4 are about that, and the answer there is no.");
+
+  line();
+  line("=".repeat(78));
+  line("2. AND A DIRECTION HAS NO ω, SO THE RETARDATION PROBLEM GOES");
+  line("=".repeat(78));
+  line();
+  line("  This is the part that matters, and it cuts both ways.");
+  line();
+  line("  `domains` §4 derives a coherence ceiling from the lag: the coupling is");
+  line("  sin(2π(βₘ − βₙ) − ω·r), the lag grows with distance, and order");
+  line("  collapses at ω·L ≈ π. That argument needs a β that is RUNNING. A");
+  line("  source whose axis is HELD has no β — `physics.ts` distinguishes the");
+  line("  two outright, `sided` with an axis and no `turning` — so ω = 0, the");
+  line("  lag term is nought at every distance, and there is no ceiling.");
+  line();
+  line("     held axis      a static torque between two directions, no lag");
+  line("     turning axis   the same torque with Δβ → Δβ − ω·r, and a ceiling");
+  line("                    at L ≈ π/ω");
+  line();
+  line("  `domainsize` shows what the ceiling is worth if it applies: 10⁻¹⁹ m");
+  line("  for an iron atom against 10⁻⁵ m measured, and 10⁻³⁴ m on the turn");
+  line("  clock. So a magnet made of TURNING sources cannot order across even");
+  line("  one atomic spacing, and is not a magnet.");
+  line();
+  line("     WHICH IS THE ANSWER: a magnet is made of HELD sources. The domain");
+  line("     prediction is not a prediction of this model, because the ceiling");
+  line("     it comes from applies to a kind of source a magnet is not made of.");
+  line();
+  line("  That is a loss and it is the right kind of loss — the alternative was");
+  line("  a prediction wrong by fourteen orders of magnitude. What survives is");
+  line("  a genuine constraint on the other kind of source: anything in this");
+  line("  model whose emission is phase-coherent cannot stay coherent past half");
+  line("  its own wavelength.");
+
+  line();
+  line("=".repeat(78));
+  line("3. SO DOES IT ALIGN — AND DOES IT DEPEND ON THE BOND DIRECTION?");
+  line("=".repeat(78));
+  line();
+  line("  This is the test that decides whether the model has a ferromagnet in");
+  line("  it at all, and it is one question. Dipolar coupling has the bond");
+  line("  direction in it — the 3(m·r̂)(m·r̂) term — and that is exactly why");
+  line("  `domains` §1 finds it picks closure over alignment. A coupling with");
+  line("  NO bond direction in it is an exchange, and exchange aligns.");
+  line();
+  line("  So: hold n along x̂, put m at distance 8 in various directions, and");
+  line("  sweep m's axis.");
+  line();
+  line("     bond direction     sin component    cos    2nd harmonic   zero at");
+  const dirs: [string, V][] = [
+    ["+x  (along n)", [1, 0, 0]],
+    ["+y  (across n)", [0, 1, 0]],
+    ["+z  (out of plane)", [0, 0, 1]],
+    ["+x+y (diagonal)", [1, 1, 0]],
+  ];
+  const sins: number[] = [];
+  for (const [name, d] of dirs) {
+    const at = mul(unit(d), R);
+    const h = harmonics(a => torque(ax(0), at, ax(a)));
+    sins.push(h.sin);
+    // where the torque vanishes with a restoring slope
+    let zero = "—";
+    const N = 2000;
+    for (let i = 0; i < N; i++) {
+      const a0 = i / N, a1 = (i + 1) / N;
+      const t0 = torque(ax(0), at, ax(a0)), t1 = torque(ax(0), at, ax(a1));
+      if (t0 === 0 && t1 === 0) continue;
+      if (t0 <= 0 && t1 > 0) { zero = (a0 * 360).toFixed(0) + "°"; break; }
+    }
+    line(`     ${name.padEnd(20)}${h.sin.toExponential(3).padStart(11)}` +
+      `${h.cos.toExponential(1).padStart(11)}${h.sin2.toExponential(1).padStart(15)}    ${zero}`);
+  }
+  const spread = (Math.max(...sins.map(Math.abs)) - Math.min(...sins.map(Math.abs)))
+    / Math.max(...sins.map(Math.abs));
+  line();
+  line(`     spread in |sin| across bond directions   ${(spread * 100).toFixed(1)}%`);
+  line();
+  line("  IT DOES DEPEND ON THE BOND DIRECTION, AND STRONGLY. Read the row");
+  line("  for +y: the sine component is nought and the whole torque is a");
+  line("  COSINE, which means it does not vanish when the two axes agree —");
+  line("  aligned is not even an equilibrium for a transverse bond. Read the");
+  line("  row for +z: the torque vanishes altogether, so two sources stacked");
+  line("  perpendicular to the plane their axes turn in do not talk at all.");
+  line("  And the diagonal carries both components at once.");
+  line();
+  line("  So this is not an exchange. It has the same kind of angular structure");
+  line("  dipolar has — the structure that makes `domains` §1 pick closure over");
+  line("  alignment — and the guess that it would be direction-free is wrong.");
+  line();
+  line("  Which means §4 cannot be done with a model coupling. It has to be");
+  line("  done with this one.");
+
+  line();
+  line("=".repeat(78));
+  line("4. RELAXED ON A BLOCK, WITH THE MEASURED TORQUE AND NOT A MODEL OF IT");
+  line("=".repeat(78));
+  line();
+  line("  Axes confined to the xy-plane, a 3³ block, every pair coupled by the");
+  line("  torque as measured — tabulated over both axis angles for every bond");
+  line("  offset in the block, so the bond direction is carried exactly.");
+  line();
+
+  const S = 3, H = (S - 1) / 2, NB = 36;
+  const sites: V[] = [];
+  for (let i = 0; i < S; i++) for (let j = 0; j < S; j++) for (let k = 0; k < S; k++)
+    sites.push([i - H, j - H, k - H]);
+
+  // T[offsetKey][bn][bm] — the torque on n at the origin from m at the offset
+  const table = new Map<string, Float64Array>();
+  const okey = (d: V) => `${d[0]},${d[1]},${d[2]}`;
+  for (const a of sites) for (const b of sites) {
+    const d = sub(b, a);
+    if (!d[0] && !d[1] && !d[2]) continue;
+    const k = okey(d);
+    if (table.has(k)) continue;
+    const t = new Float64Array(NB * NB);
+    for (let p = 0; p < NB; p++) for (let q = 0; q < NB; q++)
+      t[p * NB + q] = torque(ax(p / NB), d, ax(q / NB));
+    table.set(k, t);
+  }
+  line(`     distinct bond offsets tabulated   ${table.size}`);
+  line(`     axis-angle grid                   ${NB} × ${NB}`);
+  line();
+
+  const relax = (K: number, steps = 4000) => {
+    const a = sites.map(() => Math.floor(rnd() * NB));
+    for (let t = 0; t < steps; t++) {
+      const na = a.slice();
+      for (let i = 0; i < sites.length; i++) {
+        let s = 0;
+        for (let j = 0; j < sites.length; j++) {
+          if (i === j) continue;
+          const tb = table.get(okey(sub(sites[j], sites[i])))!;
+          s += tb[a[i] * NB + a[j]];
+        }
+        // one step of the axis, in whole grid cells, in the direction of the torque
+        const push = K * s;
+        if (Math.abs(push) > 1e-9) na[i] = (a[i] + (push > 0 ? 1 : -1) + NB) % NB;
+      }
+      for (let i = 0; i < a.length; i++) a[i] = na[i];
+    }
+    let c = 0, sn = 0;
+    for (const x of a) { c += Math.cos(TAU * x / NB); sn += Math.sin(TAU * x / NB); }
+    return { order: Math.hypot(c, sn) / a.length, a };
+  };
+
+  line("        K        net polarisation |⟨p̂⟩|      state");
+  seed = 20260815; const up = relax(+1);
+  seed = 20260815; const dn = relax(-1);
+  for (const [nm, r] of [["+1", up], ["−1", dn]] as [string, { order: number }][])
+    line(`     ${nm.padEnd(17)}${r.order.toFixed(4)}` +
+      `                 ${r.order > 0.9 ? "uniform — a ferromagnet" : r.order > 0.4 ? "partly ordered" : "no net polarisation"}`);
+  line();
+  line("  Neither sign gives a uniform state. The coupling has too much angular");
+  line("  structure in it: a bond across the axes pushes even when they agree,");
+  line("  and a bond out of the plane does not push at all, so the block cannot");
+  line("  settle on one direction the way a pure sin(Δ) coupling does.");
+  line();
+  line("     WHICH PUTS THE ORDERING BACK WHERE `domains` §1 LEFT IT. Dipolar");
+  line("     fails because it favours closure; the annihilation torque fails");
+  line("     for the same reason and by the same mechanism, and it is the same");
+  line("     reason real ferromagnetism needs exchange rather than either.");
+  line();
+  line("  So the honest ledger for the ordering is worse than `domains` reads");
+  line("  it, and better specified:");
+  line();
+  line("     DERIVED       that a coupling exists, that it is odd in the phase");
+  line("                   difference, that it acts on the polarisation and not");
+  line("                   on the sign, and that it carries the 1/r² the");
+  line("                   emission already had. `response`, and §1 here.");
+  line();
+  line("     MEASURED, AND NEGATIVE   that this coupling does not produce a");
+  line("                   uniformly polarised body, because its angular");
+  line("                   structure favours closure exactly as dipolar does.");
+  line();
+  line("     STILL OWED    a coupling that aligns. Nothing in the model supplies");
+  line("                   one, and the two candidates it does supply both");
+  line("                   choose closure. `divp` needs a uniform p and the");
+  line("                   model does not yet produce one.");
+
+  return L.join("\n");
+}
+
+console.log(alignReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/bloch.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/bloch.ts
new file mode 100644
index 0000000..14b2eff
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/bloch.ts
@@ -0,0 +1,280 @@
+/**
+ * THE FORCE, RE-MEASURED — and what a linearly ramping θ actually does.
+ *
+ * The Layer-2 arc's most concrete positive result is a force: run the Dirac
+ * walk with an azimuthal advance that ramps, θ(t) = g·t, which is a vector
+ * potential growing in time and therefore a constant field, and run the same
+ * strand with the grain and against it. They go opposite ways, the separation
+ * grows as t², "which is what a force does rather than what a drift does".
+ *
+ * Everything structural in that reproduces, and §1 says so: the two senses do
+ * separate, they separate oppositely, the norm is conserved to 1e−14, and the
+ * two real sectors are j = 0 and j = CYCLE/2. Two things need correcting.
+ *
+ * FIRST, the symmetry control is attached to the wrong variable. The arc says
+ * a strand with no MOMENTUM cannot show its charge; measured, k₀ = 0 is where
+ * the two senses separate most, symmetrically, which is exactly what two
+ * opposite charges released from rest in a field do. What cannot show a charge
+ * is no FIELD, and the arc's own g = 0 row already says so. The sentence is
+ * right and the variable in it is wrong.
+ *
+ * SECOND, the separation is not t², and is not a stable power at all. The
+ * turnaround the arc reads as "the with-the-grain strand has been turned all
+ * the way round" is the band wrapping. A ramping θ walks the momentum through
+ * the Brillouin zone at a rate g, which is a Bloch oscillation — a charge in a
+ * constant field on a lattice does not accelerate forever. That is the correct
+ * behaviour and not a defect; the defect is reading the first quarter of an
+ * oscillation as a power law and quoting the exponent.
+ *
+ * §3 is the distinguishing test, and it is decisive: every feature of the
+ * trajectory lands at a fixed value of g·t.
+ */
+
+const CYCLE = 8;
+
+/** a two-component complex amplitude per site: [reR, imR, reL, imL] */
+type Field = Float64Array;
+
+const make = (N: number): Field => new Float64Array(4 * N);
+
+/**
+ * One tick of the walk the quantum arc derives: a coin at angle m, then a
+ * shift of the two components in opposite directions, with an azimuthal
+ * advance θ applied as a phase on the hop — which is what a helix does and is
+ * where minimal coupling comes from.
+ */
+const step = (psi: Field, N: number, m: number, theta: number, sense: 1 | -1) => {
+  const c = Math.cos(m), s = Math.sin(m);
+  const out = make(N);
+  const cp = Math.cos(theta * sense), sp = Math.sin(theta * sense);
+  for (let x = 0; x < N; x++) {
+    const i = 4 * x;
+    // coin: [[c, i s], [i s, c]] — the Dirac coin, unitary by construction
+    const rR = c * psi[i] - s * psi[i + 3], iR = c * psi[i + 1] + s * psi[i + 2];
+    const rL = c * psi[i + 2] - s * psi[i + 1], iL = c * psi[i + 3] + s * psi[i];
+    // hop, with the azimuthal phase on it
+    const R = (x + 1) % N, Lx = (x - 1 + N) % N;
+    out[4 * R] += rR * cp - iR * sp;
+    out[4 * R + 1] += rR * sp + iR * cp;
+    out[4 * Lx + 2] += rL * cp + iL * sp;
+    out[4 * Lx + 3] += -rL * sp + iL * cp;
+  }
+  psi.set(out);
+};
+
+const norm = (psi: Field, N: number) => {
+  let t = 0;
+  for (let x = 0; x < N; x++) {
+    const i = 4 * x;
+    t += psi[i] ** 2 + psi[i + 1] ** 2 + psi[i + 2] ** 2 + psi[i + 3] ** 2;
+  }
+  return t;
+};
+
+const mean = (psi: Field, N: number) => {
+  let t = 0, w = 0;
+  for (let x = 0; x < N; x++) {
+    const i = 4 * x;
+    const p = psi[i] ** 2 + psi[i + 1] ** 2 + psi[i + 2] ** 2 + psi[i + 3] ** 2;
+    // positions run −N/2 … N/2 so a packet near the origin is not wrapped
+    t += p * (x - N / 2); w += p;
+  }
+  return t / w;
+};
+
+/** a gaussian packet at k₀, centred, on both components */
+const packet = (N: number, k0: number, width = 12): Field => {
+  const psi = make(N);
+  for (let x = 0; x < N; x++) {
+    const d = x - N / 2, a = Math.exp(-(d * d) / (2 * width * width));
+    const ph = k0 * d;
+    psi[4 * x] = a * Math.cos(ph); psi[4 * x + 1] = a * Math.sin(ph);
+    psi[4 * x + 2] = a * Math.cos(ph); psi[4 * x + 3] = a * Math.sin(ph);
+  }
+  let n = Math.sqrt(norm(psi, N));
+  for (let i = 0; i < psi.length; i++) psi[i] /= n;
+  return psi;
+};
+
+/** run to T ticks under a ramp θ(t) = g·t, and report ⟨x⟩ over time */
+const run = (N: number, T: number, g: number, m: number, k0: number, sense: 1 | -1) => {
+  const psi = packet(N, k0);
+  const trace: number[] = [];
+  for (let t = 0; t < T; t++) { step(psi, N, m, g * t, sense); trace.push(mean(psi, N)); }
+  return { trace, norm: norm(psi, N) };
+};
+
+export function forceReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+  const N = 2048, T = 400, m = 0.3, k0 = 0.6;
+
+  line("=".repeat(78));
+  line("1. THE STRUCTURE REPRODUCES — AND THE CONTROL IS ON THE WRONG VARIABLE");
+  line("=".repeat(78));
+  line();
+  line("     g          ⟨x⟩ with grain   ⟨x⟩ against    separation   norm error");
+  for (const g of [0, 0.001, 0.002, 0.004, 0.008]) {
+    const a = run(N, T, g, m, k0, 1), b = run(N, T, g, m, k0, -1);
+    const xa = a.trace[T - 1], xb = b.trace[T - 1];
+    line(`  ${g.toFixed(3).padStart(7)}${xa.toFixed(2).padStart(17)}${xb.toFixed(2).padStart(15)}` +
+      `${Math.abs(xa - xb).toFixed(2).padStart(13)}   ${Math.abs(a.norm - 1).toExponential(1)}`);
+  }
+  line();
+  line("  Opposite senses, norm conserved exactly, and the sizes are the arc's.");
+  line();
+  line("  And g = 0 gives nothing, which is the control that matters: with no");
+  line("  field the two senses are the same object and no measurement of");
+  line("  position separates them. A charge in no field is not observably a");
+  line("  charge — which is the arc's sentence and is correct.");
+  line();
+  line("  THE ARC ATTACHES THAT SENTENCE TO THE WRONG VARIABLE. It reports the");
+  line("  control as k₀ = 0 rather than g = 0 — 'a strand with no momentum is");
+  line("  mapped to itself by the conjugation that swaps the two senses' — and");
+  line("  measured on the walk that is not what happens:");
+  line();
+  line("     k₀        ⟨x⟩ with grain   ⟨x⟩ against   separation at g = 0.004");
+  for (const k of [0, 0.2, 0.6, 1.2]) {
+    const a = run(N, T, 0.004, m, k, 1), b = run(N, T, 0.004, m, k, -1);
+    line(`  ${k.toFixed(2).padStart(7)}${a.trace[T - 1].toFixed(2).padStart(17)}` +
+      `${b.trace[T - 1].toFixed(2).padStart(14)}${Math.abs(a.trace[T - 1] - b.trace[T - 1]).toFixed(2).padStart(20)}`);
+  }
+  line();
+  line("  k₀ = 0 is where the two senses separate MOST, not least, and they do");
+  line("  it symmetrically: ±316.83 about a stationary start. That is exactly");
+  line("  what two opposite charges released from rest in a field do, and it is");
+  line("  a better demonstration of the result than the one the arc reports.");
+  line();
+  line("  The physics is on the arc's side and the variable is not. A charge at");
+  line("  rest is perfectly observable the moment a field is switched on; what");
+  line("  is unobservable is a charge with no field, and that is the g = 0 row");
+  line("  the table already has. The 'needs something to be asymmetric about'");
+  line("  paragraph should be about g and not about k₀.");
+  line();
+  line("  (What k₀ does control is how soon the strand reaches the band edge,");
+  line("  which is §3 and is a different effect entirely.)");
+  line();
+  line("=".repeat(78));
+  line("2. BUT THE EXPONENT IS NOT 2 AND IS NOT AN EXPONENT");
+  line("=".repeat(78));
+  line();
+  line("  Fit log|separation| against log t in windows, rather than reading the");
+  line("  endpoint. A t² law gives 2 in every window.");
+  line();
+  const g = 0.004;
+  const a = run(N, 1600, g, m, k0, 1), b = run(N, 1600, g, m, k0, -1);
+  const sep = a.trace.map((v, i) => Math.abs(v - b.trace[i]));
+  line("     window (ticks)      fitted power");
+  for (const [t0, t1] of [[20, 60], [60, 150], [150, 350], [350, 700], [700, 1500]]) {
+    const xs: number[] = [], ys: number[] = [];
+    for (let t = t0; t < t1; t += Math.max(1, Math.floor((t1 - t0) / 40)))
+      if (sep[t] > 1e-9) { xs.push(Math.log(t)); ys.push(Math.log(sep[t])); }
+    const n = xs.length, mx = xs.reduce((p, q) => p + q) / n, my = ys.reduce((p, q) => p + q) / n;
+    let num = 0, den = 0;
+    for (let i = 0; i < n; i++) { num += (xs[i] - mx) * (ys[i] - my); den += (xs[i] - mx) ** 2; }
+    line(`     ${(t0 + "–" + t1).padEnd(19)}${(num / den).toFixed(2).padStart(8)}`);
+  }
+  line();
+  line("  It runs and then flattens. That is not a power law being measured");
+  line("  badly, it is not a power law: a ramping θ enters the dispersion as");
+  line("  k → k − θ, so a constant field walks the momentum through the band at");
+  line("  a rate g and brings it back round. The turnaround the arc reads as");
+  line("  'the with-the-grain strand has been turned all the way round' is");
+  line("  exactly right as a description and is the band wrapping, not the");
+  line("  force winning.");
+  line();
+  line("  WHICH IS BLOCH OSCILLATION, and it is the correct behaviour for a");
+  line("  charge in a constant field on a lattice — a real result in its own");
+  line("  right, and one the arc could have claimed instead. The force is real.");
+  line("  The t² is the small-t limit of the oscillation, which every");
+  line("  oscillation has.");
+
+  line();
+  line("=".repeat(78));
+  line("3. AND THE DISTINGUISHING TEST IS CHEAP, AND IT PASSES");
+  line("=".repeat(78));
+  line();
+  line("  If it is a Bloch oscillation then the clock is θ = g·t and nothing");
+  line("  else, so every feature of the trajectory has to land at a fixed value");
+  line("  of g·t. Two of them are predicted outright:");
+  line();
+  line("     the strand turns round when the momentum reaches the band centre,");
+  line("     which is θ = k₀, so g·t* = k₀");
+  line();
+  line("     and it turns again every time the momentum crosses another zero of");
+  line("     the group velocity, which are π apart, so g·Δt = π");
+  line();
+  line("       g        t*      g·t*   (k₀ = 0.6)      Δt      g·Δt      π");
+  for (const gg of [0.003, 0.004, 0.006, 0.008]) {
+    const r = run(N, Math.ceil(9 / gg), gg, m, k0, 1);
+    const turns: number[] = [];
+    const v = r.trace.map((x, i) => (i === 0 ? 0 : x - r.trace[i - 1]));
+    for (let t = 30; t < v.length - 1; t++)
+      if (v[t] * v[t + 1] < 0 && (turns.length === 0 || t - turns[turns.length - 1] > 20))
+        turns.push(t);
+    const t0 = turns[0] ?? NaN;
+    const d = turns.length > 1 ? turns[1] - turns[0] : NaN;
+    line(`  ${gg.toFixed(3).padStart(7)}${String(t0).padStart(9)}${(gg * t0).toFixed(3).padStart(10)}` +
+      `${String(d).padStart(20)}${(gg * d).toFixed(3).padStart(10)}   ${Math.PI.toFixed(3)}`);
+  }
+  line();
+  line("  Both hold across a factor of nearly three in g. The trajectory is a");
+  line("  function of g·t, which is what a Bloch oscillation is and is not what");
+  line("  an accelerated charge is.");
+  line();
+  line("  So what the arc measured is the charge coupling to the field with the");
+  line("  right sign — which IS the result, and survives — and not an");
+  line("  acceleration law. The t² is the small-θ limit of the oscillation,");
+  line("  which every oscillation has, so the arc's reading is right for the");
+  line("  first quarter and wrong about what it is the first quarter of.");
+  line();
+  line("  The correction matters beyond tidiness: a coupling read off a Bloch");
+  line("  oscillation inherits the error, and the coupling is the one number");
+  line("  the arc still owes.");
+  line();
+  return L.join("\n");
+}
+
+/** the dispersion, and which sectors are real — both reproduce, so both stay */
+export function dispersionReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("4. THE DISPERSION AND THE TWO REAL SECTORS, WHICH BOTH HOLD");
+  line("=".repeat(78));
+  line();
+  line("     cos Ω = cos m · cos(k − θ),  θ = 2πj/CYCLE");
+  line();
+  line("     j     θ/2π     phase e^{iθ}      group velocity at k = 0");
+  const m = 0.3;
+  for (let j = 0; j < CYCLE; j++) {
+    const th = 2 * Math.PI * j / CYCLE;
+    const vg = (k: number) => {
+      const h = 1e-6;
+      const O = (kk: number) => Math.acos(Math.max(-1, Math.min(1, Math.cos(m) * Math.cos(kk - th))));
+      return (O(k + h) - O(k - h)) / (2 * h);
+    };
+    const ph = Math.cos(th);
+    const real = Math.abs(Math.sin(th)) < 1e-12;
+    line(`  ${String(j).padStart(6)}${(j / CYCLE).toFixed(3).padStart(9)}` +
+      `${(real ? ph.toFixed(0) : "complex").padStart(14)}${vg(0).toFixed(6).padStart(24)}` +
+      (real ? "   ← real" : ""));
+  }
+  line();
+  line("  Six of the eight carry a group velocity at k = 0; the two that do not");
+  line("  are j = 0 and j = CYCLE/2, whose phases are +1 and −1. So the lattice");
+  line("  says which sectors could have been done without complex numbers, and");
+  line("  it is two out of eight. That part of the arc stands as written.");
+  line();
+  line("  One caveat carried from `ring`: CYCLE = 8 is the FACE ring. On a");
+  line("  corner axis the ring has six members, so there are two real sectors");
+  line("  out of six rather than two out of eight, and on an edge axis the");
+  line("  ring is not uniform and 2πj/CYCLE is not what θ is.");
+
+  return L.join("\n");
+}
+
+console.log(forceReport());
+console.log();
+console.log(dispersionReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/departure.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/departure.ts
new file mode 100644
index 0000000..3f05216
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/departure.ts
@@ -0,0 +1,232 @@
+/**
+ * IS A PULSE'S SIGN FIXED WHEN IT LEAVES, OR WHEN IT ARRIVES?
+ *
+ * That is the question `ordering` closes on, and it is called the cheapest open
+ * question in the arc: the arrival reading gives a monopole, so the departure
+ * reading is where the pole model is supposed to be rescued.
+ *
+ * It is not a question. For a straight ray the direction a pulse was emitted
+ * INTO is the direction of the observer, so `sgn(n·d̂)` computed at the source
+ * and computed at the destination are the same number — not nearly the same,
+ * the same, because it is the same d̂ read twice. Measured below over random
+ * observers the difference is exactly zero.
+ *
+ * The two can only come apart where the ray bends, or where the local north
+ * varies along the path. Neither happens in the far field of a uniformly
+ * ordered lump, which is where the 1/r² was measured.
+ *
+ * What DOES separate is a third convention the arc already has and did not put
+ * here: a sign fixed per EMITTER, the same into every direction, set by where
+ * the emitter is in its own cycle. That is `physics.ts`'s non-sided branch —
+ * `cos(2πβ)` — and it is the one that gives 1/r³.
+ *
+ * §3 then asks what the sided tally actually is, since calling it a monopole
+ * was too kind: it is not a field at all.
+ */
+
+const DIMS = 3;
+const DEG = Math.pow(3, DIMS) - 1;
+
+type V = [number, number, number];
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+
+/** the 26 ways out of a cell */
+const WAYS: V[] = (() => {
+  const out: V[] = [];
+  for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+    if (x || y || z) out.push([x, y, z]);
+  return out;
+})();
+
+/** which of the 26 a continuous direction is nearest to */
+const nearestWay = (d: V): V => {
+  let best = WAYS[0], bestDot = -2;
+  for (const w of WAYS) { const c = dot(unit(w), d); if (c > bestDot) { bestDot = c; best = w; } }
+  return best;
+};
+
+const sgn = (x: number) => (Math.abs(x) < 1e-12 ? 0 : x > 0 ? 1 : -1);
+
+/** a solid cube of emitters, every one pointed the same way */
+const cube = (L: number): V[] => {
+  const out: V[] = [];
+  const h = (L - 1) / 2;
+  for (let i = 0; i < L; i++) for (let j = 0; j < L; j++) for (let k = 0; k < L; k++)
+    out.push([i - h, j - h, k - h]);
+  return out;
+};
+
+const NORTH: V = [0, 0, 1];
+
+/**
+ * The three conventions. Each returns the sign one emitter contributes to one
+ * observer; the field is the 1/r² sum of them, which is how every other file
+ * here reads a far field.
+ */
+const conventions = {
+  /** sign resolved against the axis AT THE DESTINATION — `along()` in physics.ts */
+  arrival: (p: V, x: V, s: number) => sgn(dot(NORTH, unit(sub(x, p)))),
+  /** sign resolved at the SOURCE, from the direction the pulse was let go into */
+  departure: (p: V, x: V, s: number) => sgn(dot(NORTH, unit(sub(x, p)))),
+  /** the same, but the emission direction quantised to one of the 26 first */
+  quantised: (p: V, x: V, s: number) => sgn(dot(NORTH, nearestWay(unit(sub(x, p))))),
+  /** sign fixed per emitter by its own phase, the same into every direction */
+  phase: (p: V, x: V, s: number) => s,
+};
+type Conv = keyof typeof conventions;
+
+/** Σ sign / r² over the body */
+const field = (body: V[], signs: number[], x: V, c: Conv) => {
+  const f = conventions[c];
+  let total = 0;
+  for (let i = 0; i < body.length; i++) {
+    const r = len(sub(x, body[i]));
+    if (r < 1e-9) continue;
+    total += f(body[i], x, signs[i]) / (r * r);
+  }
+  return total;
+};
+
+/** slope of log|F| against log r, on the axis */
+const exponent = (body: V[], signs: number[], c: Conv, r0 = 200, r1 = 3200) => {
+  const xs: number[] = [], ys: number[] = [];
+  for (let r = r0; r <= r1; r *= 1.3) {
+    const v = Math.abs(field(body, signs, [0, 0, r], c));
+    if (v > 0) { xs.push(Math.log(r)); ys.push(Math.log(v)); }
+  }
+  const n = xs.length, mx = xs.reduce((a, b) => a + b) / n, my = ys.reduce((a, b) => a + b) / n;
+  let num = 0, den = 0;
+  for (let i = 0; i < n; i++) { num += (xs[i] - mx) * (ys[i] - my); den += (xs[i] - mx) ** 2; }
+  return -num / den;
+};
+
+// seeded, so the numbers come back the same
+let seed = 20260815;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+
+export function departureReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  const body = cube(4);
+  // alternating phases, so `phase` has both signs in it and is not trivially net
+  const signs = body.map((_, i) => (i % 2 ? 1 : -1));
+  const balanced = signs.reduce((a, b) => a + b, 0);
+
+  line("=".repeat(78));
+  line("1. DEPARTURE AND ARRIVAL ARE THE SAME FUNCTION");
+  line("=".repeat(78));
+  line();
+  line("  200 observers at random directions and random distances, both");
+  line("  conventions evaluated on the same body.");
+  line();
+
+  let worst = 0, worstQ = 0;
+  for (let t = 0; t < 200; t++) {
+    const th = Math.acos(2 * rnd() - 1), ph = 2 * Math.PI * rnd();
+    const r = 50 + 3000 * rnd();
+    const x: V = [r * Math.sin(th) * Math.cos(ph), r * Math.sin(th) * Math.sin(ph), r * Math.cos(th)];
+    const a = field(body, signs, x, "arrival");
+    const d = field(body, signs, x, "departure");
+    const q = field(body, signs, x, "quantised");
+    worst = Math.max(worst, Math.abs(a - d));
+    worstQ = Math.max(worstQ, Math.abs(a - q) / (Math.abs(a) || 1));
+  }
+
+  line(`     max |arrival − departure|                       ${worst.toExponential(3)}`);
+  line(`     max |arrival − quantised| / |arrival|           ${worstQ.toExponential(3)}`);
+  line();
+  line("  The first is zero and cannot be anything else. A pulse that reaches");
+  line("  the observer was emitted into the direction of the observer, so the");
+  line("  d̂ the source resolves its sign against IS the d̂ the destination");
+  line("  resolves it against. One number, computed in two places.");
+  line();
+  line("  The second is the only real content in the distinction: rounding the");
+  line("  emission direction onto one of the 26 first. That changes the sign");
+  line("  only for observers within half a lattice angle of the equator, and");
+  line("  it does not move the exponent.");
+  line();
+  line("     convention                     exponent");
+  for (const c of ["arrival", "departure", "quantised", "phase"] as Conv[])
+    line(`     ${c.padEnd(28)} ${exponent(body, signs, c).toFixed(3)}`);
+  line();
+  line(`  (the phase body has net sign ${balanced}, so its 1/r³ is not a`);
+  line("  cancellation of a net — there is no net to cancel)");
+  line();
+  line("  So the arc's cheapest open question is not open and is not a");
+  line("  question. Both branches give the same 2.000 because they are one");
+  line("  branch, and the quantised reading gives it too. What");
+  line("  gives 3.000 is the arc's SECOND emitter, not its fourth: a sign the");
+  line("  emitter fixes for itself before it knows who is listening.");
+  line();
+  line("  The distinction the arc wanted does exist, but not here. Departure");
+  line("  and arrival come apart exactly where the ray bends, or where north");
+  line("  turns along the path — a magnetic texture, which is what the Layer-2");
+  line("  arc's holonomy is about. In the far field of a uniformly ordered");
+  line("  lump there is neither.");
+
+  line();
+  line("=".repeat(78));
+  line("2. AND 'MONOPOLE' WAS TOO KIND — IT IS NOT A FIELD AT ALL");
+  line("=".repeat(78));
+  line();
+  line("  Read the sided tally as a vector field, B = Σ sgn(n·r̂)·r̂/r², and");
+  line("  take its flux through spheres. If it were a monopole the flux would");
+  line("  be the enclosed charge, the same at every radius.");
+  line();
+  line("     radius        flux");
+
+  const flux = (R: number) => {
+    // Lebedev is overkill; a product grid converges fine for a smooth-in-φ field
+    let total = 0;
+    const NT = 400, NP = 200;
+    for (let i = 0; i < NT; i++) {
+      const th = Math.PI * (i + 0.5) / NT, w = Math.sin(th) * (Math.PI / NT) * (2 * Math.PI / NP);
+      for (let j = 0; j < NP; j++) {
+        const ph = 2 * Math.PI * (j + 0.5) / NP;
+        const rhat: V = [Math.sin(th) * Math.cos(ph), Math.sin(th) * Math.sin(ph), Math.cos(th)];
+        const x: V = [R * rhat[0], R * rhat[1], R * rhat[2]];
+        let br = 0;
+        for (const p of body) {
+          const d = sub(x, p), r = len(d);
+          br += sgn(dot(NORTH, unit(d))) * dot(unit(d), rhat) / (r * r);
+        }
+        total += br * R * R * w;
+      }
+    }
+    return total;
+  };
+
+  for (const R of [200, 400, 800, 1600])
+    line(`     ${String(R).padStart(6)}   ${flux(R).toExponential(3)}`);
+
+  line();
+  line("  Nought at every radius. There is no monopole; ∇·B = 0 holds");
+  line("  observationally. So what is the 1/r²?");
+  line();
+  line("     θ        r²·F(r=1000)");
+  for (const deg of [0, 30, 60, 89, 90, 91, 120, 180]) {
+    const th = deg * Math.PI / 180, R = 1000;
+    const x: V = [R * Math.sin(th), 0, R * Math.cos(th)];
+    line(`     ${String(deg).padStart(3)}°    ${(field(body, signs, x, "arrival") * R * R).toExponential(3)}`);
+  }
+  line();
+  line("  Constant magnitude, flat from the pole to one degree off the equator,");
+  line("  a step discontinuity at 90°, and the mirror of itself below. That is");
+  line("  sgn(cos θ)/r², and it is impossible for a real field: zero enclosed");
+  line("  charge forbids a 1/r² term in any multipole expansion, so the");
+  line("  exterior is not source-free. The step at the equator is a source");
+  line("  sheet running to infinity.");
+  line();
+  line("  Σ sgn(n·d̂)/r² IS NOT A FIELD, IT IS A TALLY OF RECEIVED PULSES.");
+  line("  Σ s_e/r², with the sign fixed per emitter, IS a field — and that is");
+  line("  the real reason the phase route works, rather than anything about");
+  line("  where the arithmetic happens to be done.");
+
+  return L.join("\n");
+}
+
+console.log(departureReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/divp.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/divp.ts
new file mode 100644
index 0000000..4d61679
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/divp.ts
@@ -0,0 +1,331 @@
+/**
+ * WHERE THE POLES COME FROM, ON A SOURCE THE MODEL COULD ACTUALLY PRODUCE.
+ *
+ * `poles` measured the pole model and got every magnetostatic result out of it
+ * — 3cos²θ − 1, 1/R⁴, all five orientations — on a body whose bias was PUT ON
+ * IT BY HAND: + at one end, − at the other, because that is what a bar magnet
+ * is. `ordering` then asked which arrangement of ordinary emitters produces
+ * that, found that none of them do, and closed on a question about where the
+ * sign gets resolved. `departure` shows that question has no content.
+ *
+ * This file asks the question the other way round. Do not ask where the sign
+ * is resolved; ask what the PRIMITIVE is. Give each node a polarisation vector
+ * p — a thing an ordering can plausibly hold, since it is just "which way this
+ * bit of the body is pointed" — and let the emitted sign be
+ *
+ *     s = −div p
+ *
+ * which is nought wherever p is uniform and appears only where the body ends.
+ * Nobody assigns a pole to a face; the faces are where the divergence is.
+ *
+ * Two constructions are compared, on the same block, at the same strength:
+ *
+ *   BY HALF   s = +1 in the upper half, −1 in the lower. Net zero, and the
+ *             far field comes out right — this is `poles`' body.
+ *   BY −div p  s from the divergence. Net zero identically, by telescoping.
+ *
+ * They agree on everything a magnet is normally asked for. The test that
+ * separates them is the oldest one there is: CUT THE MAGNET IN HALF. A real
+ * one gives two magnets. By-half gives two monopoles, because the assignment
+ * was to a region of the original body and the halves inherit it. −div p
+ * regenerates, because a divergence is a fact about the body that is there.
+ */
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+
+type Node = { at: V; s: number };
+
+const key = (x: number, y: number, z: number) => `${x},${y},${z}`;
+
+/** a solid block, L×L×H, on lattice sites centred at the origin */
+const block = (L: number, H: number): V[] => {
+  const out: V[] = [];
+  for (let i = 0; i < L; i++) for (let j = 0; j < L; j++) for (let k = 0; k < H; k++)
+    out.push([i - (L - 1) / 2, j - (L - 1) / 2, k - (H - 1) / 2]);
+  return out;
+};
+
+/**
+ * s = −div p, by central differences, over the body and the shell around it —
+ * a cell one step outside the body still sees p on one side and nothing on the
+ * other, which is where half the surface charge lands.
+ */
+const byDivergence = (cells: V[], axis: V): Node[] => {
+  const inBody = new Set(cells.map(c => key(c[0], c[1], c[2])));
+  const p = (x: number, y: number, z: number, a: number) =>
+    inBody.has(key(x, y, z)) ? axis[a] : 0;
+
+  const wanted = new Set<string>();
+  for (const c of cells)
+    for (let dx = -1; dx <= 1; dx++) for (let dy = -1; dy <= 1; dy++) for (let dz = -1; dz <= 1; dz++)
+      wanted.add(key(c[0] + dx, c[1] + dy, c[2] + dz));
+
+  const out: Node[] = [];
+  for (const k of wanted) {
+    const [x, y, z] = k.split(",").map(Number);
+    const div =
+      (p(x + 1, y, z, 0) - p(x - 1, y, z, 0)) / 2 +
+      (p(x, y + 1, z, 1) - p(x, y - 1, z, 1)) / 2 +
+      (p(x, y, z + 1, 2) - p(x, y, z - 1, 2)) / 2;
+    if (Math.abs(div) > 1e-12) out.push({ at: [x, y, z], s: -div });
+  }
+  return out;
+};
+
+/** s = +1 on the far side of the body along the axis, −1 on the near side */
+const byHalf = (cells: V[], axis: V): Node[] =>
+  cells.map(c => {
+    const h = c[0] * axis[0] + c[1] * axis[1] + c[2] * axis[2];
+    return { at: c, s: Math.abs(h) < 1e-12 ? 0 : h > 0 ? 1 : -1 };
+  }).filter(n => n.s !== 0);
+
+/** move and re-orient a body */
+const place = (b: Node[], to: V, flip: V | null = null): Node[] =>
+  b.map(n => {
+    let a: V = [...n.at] as V;
+    if (flip) a = [a[0] * flip[0], a[1] * flip[1], a[2] * flip[2]];
+    return { at: [a[0] + to[0], a[1] + to[1], a[2] + to[2]] as V, s: n.s };
+  });
+
+/** rotate a body so its z axis becomes x — for the crossed orientation */
+const zToX = (b: Node[]): Node[] => b.map(n => ({ at: [n.at[2], n.at[1], n.at[0]] as V, s: n.s }));
+
+const potential = (b: Node[], x: V) => {
+  let t = 0;
+  for (const n of b) { const r = len(sub(x, n.at)); if (r > 1e-9) t += n.s / r; }
+  return t;
+};
+
+/** the tally the rest of the arc reads: Σ s/r² */
+const tally = (b: Node[], x: V) => {
+  let t = 0;
+  for (const n of b) { const r = len(sub(x, n.at)); if (r > 1e-9) t += n.s / (r * r); }
+  return t;
+};
+
+const slope = (f: (r: number) => number, r0: number, r1: number) => {
+  const xs: number[] = [], ys: number[] = [];
+  for (let r = r0; r <= r1; r *= 1.25) {
+    const v = Math.abs(f(r));
+    if (v > 1e-300) { xs.push(Math.log(r)); ys.push(Math.log(v)); }
+  }
+  const n = xs.length, mx = xs.reduce((a, b) => a + b) / n, my = ys.reduce((a, b) => a + b) / n;
+  let num = 0, den = 0;
+  for (let i = 0; i < n; i++) { num += (xs[i] - mx) * (ys[i] - my); den += (xs[i] - mx) ** 2; }
+  return -num / den;
+};
+
+/** pole-model interaction energy, and the force along the separation */
+const energy = (a: Node[], b: Node[]) => {
+  let u = 0;
+  for (const p of a) for (const q of b) { const r = len(sub(p.at, q.at)); if (r > 1e-9) u += p.s * q.s / r; }
+  return u;
+};
+const force = (mk: (R: number) => [Node[], Node[]], R: number, h = 0.5) => {
+  const [a1, b1] = mk(R + h), [a0, b0] = mk(R - h);
+  return -(energy(a1, b1) - energy(a0, b0)) / (2 * h);
+};
+
+/** s = −div p for an arbitrary per-node polarisation field */
+const byField = (cells: V[], f: (c: V, i: number) => V): Node[] => {
+  const at = new Map<string, V>();
+  cells.forEach((c, i) => at.set(key(c[0], c[1], c[2]), f(c, i)));
+  const p = (x: number, y: number, z: number, a: number) => (at.get(key(x, y, z)) ?? [0, 0, 0])[a];
+  const wanted = new Set<string>();
+  for (const c of cells)
+    for (let dx = -1; dx <= 1; dx++) for (let dy = -1; dy <= 1; dy++) for (let dz = -1; dz <= 1; dz++)
+      wanted.add(key(c[0] + dx, c[1] + dy, c[2] + dz));
+  const out: Node[] = [];
+  for (const k of wanted) {
+    const [x, y, z] = k.split(",").map(Number);
+    const div =
+      (p(x + 1, y, z, 0) - p(x - 1, y, z, 0)) / 2 +
+      (p(x, y + 1, z, 1) - p(x, y - 1, z, 1)) / 2 +
+      (p(x, y, z + 1, 2) - p(x, y, z - 1, 2)) / 2;
+    if (Math.abs(div) > 1e-12) out.push({ at: [x, y, z], s: -div });
+  }
+  return out;
+};
+
+let seed = 20260815;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+const reseed = () => { seed = 20260815; };
+
+const AXIS: V = [0, 0, 1];
+
+export function divpReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  const cells = block(4, 4);
+  const bodies: [string, Node[]][] = [
+    ["by half", byHalf(cells, AXIS)],
+    ["−div p", byDivergence(cells, AXIS)],
+  ];
+
+  line("=".repeat(78));
+  line("1. BOTH CONSTRUCTIONS ARE MAGNETS IN THE FAR FIELD");
+  line("=".repeat(78));
+  line();
+  line("     construction   nodes    net sign    Σs/r² exp   |Φ(θ)/Φ(0) − cosθ| max");
+  for (const [name, b] of bodies) {
+    const net = b.reduce((t, n) => t + n.s, 0);
+    const e = slope(r => tally(b, [0, 0, r]), 200, 3200);
+    // the potential of a dipole is ∝ cos θ / r²; check the angle at fixed r
+    const R = 800;
+    let ref = 0, worst = 0;
+    for (let d = 0; d <= 180; d += 5) {
+      const th = d * Math.PI / 180;
+      const v = potential(b, [R * Math.sin(th), 0, R * Math.cos(th)]) * R * R;
+      if (d === 0) ref = v;
+      worst = Math.max(worst, Math.abs(v / ref - Math.cos(th)));
+    }
+    line(`     ${name.padEnd(14)}${String(b.length).padStart(5)}${net.toFixed(6).padStart(12)}` +
+      `${e.toFixed(3).padStart(12)}   ${worst.toExponential(1)}`);
+  }
+  line();
+  line("  Both net to nothing, both fall as 1/r³, both are cos θ to four or");
+  line("  five figures at every angle. On the far field there is nothing to");
+  line("  choose between them.");
+
+  line();
+  line("=".repeat(78));
+  line("2. AND BOTH GIVE ALL FIVE ORIENTATIONS AND 1/R⁴");
+  line("=".repeat(78));
+  line();
+  line("     construction   N–S facing    N–N facing    side ∥      side anti    crossed");
+  for (const [name, b] of bodies) {
+    const R = 40;
+    const ns = force(r => [b, place(b, [0, 0, r])], R);
+    const nn = force(r => [b, place(b, [0, 0, r], [1, 1, -1])], R);
+    const sp = force(r => [b, place(b, [r, 0, 0])], R);
+    const sa = force(r => [b, place(b, [r, 0, 0], [1, 1, -1])], R);
+    const cr = force(r => [b, place(zToX(b), [0, 0, r])], R);
+    line(`     ${name.padEnd(14)}${ns.toExponential(3).padStart(12)}${nn.toExponential(3).padStart(14)}` +
+      `${sp.toExponential(2).padStart(12)}${sa.toExponential(2).padStart(13)}${cr.toExponential(1).padStart(12)}`);
+  }
+  line();
+  line("     construction   force exponent (N–S)   (N–N)");
+  for (const [name, b] of bodies) {
+    const e1 = slope(R => force(r => [b, place(b, [0, 0, r])], R), 40, 200);
+    const e2 = slope(R => force(r => [b, place(b, [0, 0, r], [1, 1, -1])], R), 40, 200);
+    line(`     ${name.padEnd(14)}${e1.toFixed(3).padStart(18)}${e2.toFixed(3).padStart(11)}`);
+  }
+  line();
+  line("  Negative is attraction. N–S pulls, N–N pushes, side by side aligned");
+  line("  pushes and anti-aligned pulls, one across the other is nought to");
+  line("  machine precision, and the force between two of them is 1/R⁴ — which");
+  line("  is magnetostatics, twice over.");
+
+  line();
+  line("=".repeat(78));
+  line("3. THE TEST THAT SEPARATES THEM: CUT IT IN HALF");
+  line("=".repeat(78));
+  line();
+  line("  Take the upper half of the block and ask what it is. By-half keeps");
+  line("  the signs it was given; −div p is recomputed on the half that now");
+  line("  exists, which is what a divergence does when a body changes shape.");
+  line();
+  const upper = cells.filter(c => c[2] > 0);
+  const cut: [string, Node[]][] = [
+    ["by half", byHalf(cells, AXIS).filter(n => n.at[2] > 0)],
+    ["−div p", byDivergence(upper, AXIS)],
+  ];
+  line("     construction   net sign    exponent    what it is");
+  for (const [name, b] of cut) {
+    const net = b.reduce((t, n) => t + n.s, 0);
+    const e = slope(r => tally(b, [0, 0, r]), 200, 3200);
+    line(`     ${name.padEnd(14)}${net.toFixed(4).padStart(10)}${e.toFixed(3).padStart(12)}    ` +
+      (Math.abs(net) < 1e-9 ? "a magnet" : "A MONOPOLE"));
+  }
+  line();
+  line("  By-half fails outright. Every node in the upper half was assigned +,");
+  line("  so the half is a lump of one sign with a 1/r² tally and a net of 32");
+  line("  — the thing the whole arc has been trying not to produce.");
+  line();
+  line("  −div p regenerates. The new bottom face has a divergence it did not");
+  line("  have when there was more body below it, so a south pole appears where");
+  line("  the cut was, the net is nought again, and the exponent is 3. Two");
+  line("  magnets out of one, which is the entire content of 'there are no");
+  line("  magnetic monopoles' stated as an experiment.");
+
+  line();
+  line("=".repeat(78));
+  line("4. AND THE ARC'S FINE-TUNING OBJECTION DOES NOT REACH IT");
+  line("=".repeat(78));
+  line();
+  line("  The Layer-2 arc rules the ± charge route out as fine-tuned — one");
+  line("  emitter in 784 flipped drags the exponent to 2.79, and a real magnet");
+  line("  is 10²³ atoms with thermal disorder in it, so the imbalance goes as");
+  line("  √N and the dipole is never visible. It then takes closed loops");
+  line("  instead, on the grounds that a loop has no monopole moment by");
+  line("  topology rather than by cancellation.");
+  line();
+  line("  That objection is correct against ASSIGNED charges and does not");
+  line("  reach a divergence, because you cannot flip a charge — there are no");
+  line("  charges to flip. You can only disturb p, and Σ(−div p) telescopes to");
+  line("  nought for ANY p whatever, which is topology too.");
+  line();
+  line("     disturbance to p                    net sign     exponent");
+  const shown: [string, (c: V, i: number) => V][] = [
+    ["none — uniform ẑ", () => [0, 0, 1]],
+    ["one node reversed", (c, i) => (i === 7 ? [0, 0, -1] : [0, 0, 1])],
+    ["eight nodes reversed", (c, i) => (i % 8 === 0 ? [0, 0, -1] : [0, 0, 1])],
+    ["every node ±10% wobble", () => [0.1 * (2 * rnd() - 1), 0.1 * (2 * rnd() - 1), 1]],
+    ["every node ±50% wobble", () => [0.5 * (2 * rnd() - 1), 0.5 * (2 * rnd() - 1), 1]],
+    ["p entirely random", () => {
+      const v: V = [2 * rnd() - 1, 2 * rnd() - 1, 2 * rnd() - 1];
+      const l = len(v) || 1; return [v[0] / l, v[1] / l, v[2] / l];
+    }],
+  ];
+  for (const [name, f] of shown) {
+    reseed();
+    const b = byField(cells, f);
+    const net = b.reduce((t, n) => t + n.s, 0);
+    const e = slope(r => tally(b, [0, 0, r]), 200, 3200);
+    line(`     ${name.padEnd(32)}${net.toExponential(1).padStart(11)}${e.toFixed(3).padStart(13)}`);
+  }
+  line();
+  line("  The net is nought to machine precision in every row including the");
+  line("  fully random one, where there is no magnet left at all — the exponent");
+  line("  wanders because the remaining moment is small and noisy, not because");
+  line("  a monopole has appeared. Nothing here is held in place and nothing");
+  line("  needs to be.");
+  line();
+  line("  Which does not refute the loop route; the two agree outside the body");
+  line("  and experiment separates them inside, where it picks the current");
+  line("  loop. What it refutes is the ARGUMENT — the fine-tuning objection");
+  line("  was aimed at assigned charges and a divergence is not one.");
+
+  line();
+  line("=".repeat(78));
+  line("5. WHICH RECONCILES WITH WHAT THE ARC ALREADY MEASURED");
+  line("=".repeat(78));
+  line();
+  line("  `ordering` §1 reports the signed emission as 'nought in the middle of");
+  line("  a cylinder and largest at its ends' and reads it as encouragement.");
+  line();
+  line("     THAT IS −div p. It was the right quantity already.");
+  line();
+  line("  What went wrong afterwards is one line and not a mechanism: the sign");
+  line("  was then resolved against the axis AT THE DESTINATION, which throws");
+  line("  the polarisation away and replaces it with sgn(n·d̂) — and `departure`");
+  line("  shows that is not a field at all. The arc had the quantity, and");
+  line("  destroyed it in the step that turned it into a sign.");
+  line();
+  line("  So the primitive is the polarisation and the sign is its divergence.");
+  line("  Nothing is assigned to a face, nothing is held in place, and the");
+  line("  faces are poles because that is where p stops.");
+  line();
+  line("  One caveat kept honest: the energy used here is the pole model's");
+  line("  Σ s_a s_b / r, not the annihilation excess `poles` measures. The two");
+  line("  are not numerically comparable — the excess is even in z where a");
+  line("  signed field sum is odd — so the orientations and exponents transfer");
+  line("  and the absolute sizes do not.");
+
+  return L.join("\n");
+}
+
+console.log(divpReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/domains.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/domains.ts
new file mode 100644
index 0000000..8ff4d43
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/domains.ts
@@ -0,0 +1,316 @@
+/**
+ * WHAT ORDERS THE EMITTERS — and how big the ordered region is allowed to get.
+ *
+ * `divp` says what a magnet has to be: a region with a uniform polarisation in
+ * it, whose emitted sign is −div p. It does not say what holds the
+ * polarisation uniform. This file asks that, and the answer turns out to
+ * predict something the arc did not set out to get.
+ *
+ *   §1  The coupling the model already has — dipolar — does not order. It
+ *       selects a state with NO net polarisation, which is the standard result
+ *       and the reason real ferromagnetism needs exchange.
+ *
+ *   §2  A coupling that does order: arriving emission changes how fast an
+ *       emitter comes round. Locks hard, from random phases, with the 1/r²
+ *       reach the emission already has.
+ *
+ *   §3  And it is not assumed. It follows from two things already in the
+ *       model — emission is cos(2πβ), and a receiver's rate responds to what
+ *       arrives — with one harmonic expansion and product-to-sum.
+ *
+ *   §4  Which then forces a maximum size, because the signal arrives LATE.
+ *       Coherent regions cannot be bigger than about half a wavelength of the
+ *       emitter's own beat. That is a domain, and nothing was put in to make
+ *       one.
+ *
+ * Everything is seeded.
+ */
+
+const TAU = Math.PI * 2;
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+
+const cube = (L: number): V[] => {
+  const out: V[] = [];
+  const h = (L - 1) / 2;
+  for (let i = 0; i < L; i++) for (let j = 0; j < L; j++) for (let k = 0; k < L; k++)
+    out.push([i - h, j - h, k - h]);
+  return out;
+};
+
+let seed = 20260815;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+const reseed = () => { seed = 20260815; };
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** the textbook dipolar sum, Σ_{i<j} [mᵢ·mⱼ − 3(mᵢ·r̂)(mⱼ·r̂)]/r³, per moment */
+const dipolar = (at: V[], m: V[]) => {
+  let u = 0;
+  for (let i = 0; i < at.length; i++)
+    for (let j = i + 1; j < at.length; j++) {
+      const d = sub(at[j], at[i]), r = len(d);
+      const rh: V = [d[0] / r, d[1] / r, d[2] / r];
+      u += (dot(m[i], m[j]) - 3 * dot(m[i], rh) * dot(m[j], rh)) / (r * r * r);
+    }
+  return u / at.length;
+};
+
+export function orderingReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+  const at = cube(6);
+
+  const states: [string, (p: V) => V][] = [
+    ["uniform ẑ", () => [0, 0, 1]],
+    ["columnar (± by x)", p => [0, 0, ((p[0] + 2.5) % 2 < 1 ? 1 : -1)]],
+    ["layered (± by z)", p => [0, 0, ((p[2] + 2.5) % 2 < 1 ? 1 : -1)]],
+    ["in-plane closure", p => {
+      const r = Math.hypot(p[0], p[1]) || 1;
+      return [-p[1] / r, p[0] / r, 0];
+    }],
+    ["in-plane uniform", () => [1, 0, 0]],
+  ];
+
+  line("=".repeat(78));
+  line("1. THE COUPLING THE MODEL ALREADY HAS DOES NOT ORDER");
+  line("=".repeat(78));
+  line();
+  line("  A 6×6×6 block of moments, five arrangements, the dipolar energy per");
+  line("  moment. Lower wins.");
+  line();
+  line("     arrangement            E/N        net polarisation |⟨m⟩|");
+  for (const [name, f] of states) {
+    const m = at.map(f);
+    const s: V = [0, 0, 0];
+    for (const v of m) { s[0] += v[0]; s[1] += v[1]; s[2] += v[2]; }
+    line(`     ${name.padEnd(22)}${dipolar(at, m).toFixed(3).padStart(7)}` +
+      `${(len(s) / m.length).toFixed(3).padStart(22)}`);
+  }
+  line();
+  line("  The uniform state is exactly nought — the dipolar lattice sum on a");
+  line("  cubic lattice vanishes by symmetry — and every state that beats it");
+  line("  has no net polarisation at all. Dipolar coupling favours closure,");
+  line("  which is the standard result and is why real ferromagnetism needs");
+  line("  exchange rather than dipole–dipole.");
+  line();
+  line("  So the ordering cannot come from the pole energy. It has to come from");
+  line("  the emission itself.");
+
+  return L.join("\n");
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Emitters as phases. `lag` in ticks per unit distance is ω/c with c = 1 cell a
+ * tick — set it to zero for the instantaneous version.
+ */
+const kuramoto = (at: V[], K: number, spread: number, steps: number, dt: number, lag = 0) => {
+  const N = at.length;
+  const b = Array.from({ length: N }, () => rnd());              // random phases
+  const w = Array.from({ length: N }, () => 1 + spread * (2 * rnd() - 1));
+  const r2 = Array.from({ length: N }, (_, i) =>
+    Array.from({ length: N }, (_, j) => (i === j ? 0 : 1 / (len(sub(at[i], at[j])) ** 2))));
+  const d = Array.from({ length: N }, (_, i) =>
+    Array.from({ length: N }, (_, j) => len(sub(at[i], at[j]))));
+
+  for (let t = 0; t < steps; t++) {
+    const db = new Array(N).fill(0);
+    for (let i = 0; i < N; i++) {
+      let drive = 0;
+      for (let j = 0; j < N; j++) {
+        if (i === j) continue;
+        drive += r2[i][j] * Math.sin(TAU * (b[j] - b[i]) - lag * d[i][j]);
+      }
+      db[i] = w[i] + (K / 2) * drive;
+    }
+    for (let i = 0; i < N; i++) b[i] = (b[i] + dt * db[i]) % 1;
+  }
+
+  let c = 0, s = 0;
+  for (const x of b) { c += Math.cos(TAU * x); s += Math.sin(TAU * x); }
+  return Math.hypot(c, s) / N;
+};
+
+export function couplingReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+  const at = cube(4);
+
+  line("=".repeat(78));
+  line("2. A COUPLING THAT DOES ORDER: ARRIVING EMISSION CHANGES THE RATE");
+  line("=".repeat(78));
+  line();
+  line("  64 emitters on a 4³ block, phases random to start, natural rates");
+  line("  spread by 10%, full 1/r² reach, no lag. Order is |⟨e^{2πiβ}⟩|.");
+  line();
+  line("        K      order    ");
+  for (const K of [-2, -0.5, 0, 0.5, 2]) {
+    reseed();
+    const o = kuramoto(at, K, 0.1, 4000, 0.01);
+    line(`     ${K.toFixed(2).padStart(5)}     ${o.toFixed(4)}   ` +
+      (o > 0.9 ? "locked" : o > 0.3 ? "partial" : "incoherent"));
+  }
+  line();
+  line("  It locks, and it locks hard. Negative K gives incoherence, which is");
+  line("  the check that the lock is the coupling and not the initialisation.");
+  line();
+  line("  ONE CRITICAL CAVEAT, and it decides the physics rather than");
+  line("  decorating it. WHAT the rate coupling locks is not settled by this");
+  line("  measurement:");
+  line();
+  line("     if it locks the SIGN            every emitter ends the same sign,");
+  line("                                     net bias 1.0000, and the body is a");
+  line("                                     monopole — `departure` §2");
+  line("     if it locks the POLARISATION    the locked state is a uniform p,");
+  line("                                     the sign is still −div p, and the");
+  line("                                     body is the magnet of `divp`");
+  line();
+  line("  Take the second reading. It is not a preference: a sign is what the");
+  line("  emitter sends, and `departure` shows a body of like signs is not a");
+  line("  field at all, so the first reading is not available on its own terms.");
+
+  return L.join("\n");
+}
+
+export function derivationReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("3. AND THE COUPLING IS DERIVED, NOT PUT IN");
+  line("=".repeat(78));
+  line();
+  line("  Two things the model already has:");
+  line();
+  line("    (a) the emitted sign is cos(2πβ) — `physics.ts`'s own source line —");
+  line("        arriving at a receiver weighted 1/r², since that is what a");
+  line("        pulse spread over a shell does;");
+  line("    (b) a receiver's rotation responds to what arrives, and responds");
+  line("        differently at different points of its own cycle.");
+  line();
+  line("  Expand that sensitivity in harmonics of the receiver's phase. The");
+  line("  constant term only shifts the frequency and cannot lock anything to");
+  line("  anything; the first term that can is Z(β) = −sin(2πβ). So the drive");
+  line("  on n from m is");
+  line();
+  line("     −K·sin(2πβₙ)·cos(2πβₘ)/r²");
+  line();
+  line("  and product-to-sum splits it into");
+  line();
+  line("     −(K/2r²)·[ sin(2π(βₙ+βₘ)) + sin(2π(βₙ−βₘ)) ]");
+  line();
+  line("  The first term runs at twice the beat and averages away for |K| ≪ ω.");
+  line("  What survives is");
+  line();
+  line("     (K/2r²)·sin(2π(βₘ − βₙ))");
+  line();
+  line("  which is exactly §2's coupling, with the 1/r² the emission already");
+  line("  carried. Checked numerically: the sum term against its average.");
+  line();
+
+  // the averaging claim, measured rather than asserted
+  const w = 1.0, K = 0.05, steps = 200000, dt = 0.001;
+  let bn = 0.11, bm = 0.63, full = 0, kept = 0;
+  for (let t = 0; t < steps; t++) {
+    full += -(K / 2) * (Math.sin(TAU * (bn + bm)) + Math.sin(TAU * (bn - bm)));
+    kept += (K / 2) * Math.sin(TAU * (bm - bn));
+    bn += dt * w * 1.0; bm += dt * w * 1.07;
+  }
+  line(`     ⟨full drive⟩ over ${steps} ticks     ${(full / steps).toExponential(3)}`);
+  line(`     ⟨surviving term⟩                    ${(kept / steps).toExponential(3)}`);
+  line(`     difference                          ${Math.abs(full / steps - kept / steps).toExponential(3)}`);
+  line();
+  line("  The two averages agree, so the fast term really is the one that goes.");
+
+  return L.join("\n");
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+export function coherenceReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("4. WHICH FORCES A MAXIMUM SIZE, BECAUSE THE SIGNAL ARRIVES LATE");
+  line("=".repeat(78));
+  line();
+  line("  Nothing in §2 or §3 said WHEN the emission arrives. It arrives late:");
+  line("  a pulse goes a cell a tick, so a neighbour r cells away is heard as");
+  line("  it was r ticks ago, and the coupling is really");
+  line();
+  line("     sin(2π(βₘ − βₙ) − ω·r)");
+  line();
+  line("  The lag grows with distance while the phase difference does not, so");
+  line("  shells far enough out couple with the WRONG SIGN and pull the other");
+  line("  way. Order should therefore survive up to a size and then collapse.");
+  line();
+  line("  A 4³ block, K = 2, against the lag per lattice step:");
+  line();
+  line("     ω·spacing     order");
+  for (const w of [0, 0.02, 0.05, 0.1, 0.2, 0.4, 0.8, 1.6]) {
+    reseed();
+    const o = kuramoto(cube(4), 2, 0.1, 4000, 0.01, w);
+    line(`     ${w.toFixed(2).padStart(9)}     ${o.toFixed(4)}`);
+  }
+  line();
+  line("  (the last two rows are both incoherence; which of them is the");
+  line("  smaller is noise, not a trend)");
+  line();
+  line("  Now the same sweep against BODY SIZE, looking for where it goes. If");
+  line("  the mechanism is the lag, the threshold should scale as 1/L rather");
+  line("  than sitting at a fixed ω.");
+  line();
+  line("       L      ω* (order falls below ½)     ω*·L");
+  const thresholds: number[] = [];
+  for (const size of [4, 6, 8]) {
+    const at = cube(size);
+    let lo = 0, hi = 4;
+    for (let it = 0; it < 12; it++) {
+      const mid = (lo + hi) / 2;
+      reseed();
+      const o = kuramoto(at, 2, 0.1, 2500, 0.01, mid);
+      if (o > 0.5) lo = mid; else hi = mid;
+    }
+    const w = (lo + hi) / 2;
+    thresholds.push(w * size);
+    line(`     ${String(size).padStart(3)}${w.toFixed(4).padStart(24)}${(w * size).toFixed(3).padStart(14)}`);
+  }
+  const mean = thresholds.reduce((a, b) => a + b) / thresholds.length;
+  line();
+  line(`     mean ω*·L = ${mean.toFixed(3)},   π = ${Math.PI.toFixed(3)}`);
+  line();
+  line("  ω*·L is the same number to about a tenth across a factor of two in");
+  line("  L, where ω* alone moves by nearly two, so the threshold is a");
+  line("  statement about ω·L and not about ω. And that number is near π.");
+  line();
+  line("  So a coherent region has a maximum size of about π/ω lattice steps —");
+  line("  HALF THE EMITTER'S OWN WAVELENGTH — and a body larger than that");
+  line("  breaks into regions rather than ordering as one.");
+  line();
+  line("     THAT IS A MAGNETIC DOMAIN, and its size is set by the emitter's");
+  line("     beat and by nothing else. No anisotropy, no wall energy, no");
+  line("     surface term: only the light-travel time of the model's own");
+  line("     signal against the model's own period.");
+  line();
+  line("  Which makes it a prediction rather than a fit. The gravity arc has");
+  line("  period = 1/mass, so ω is fixed the moment a carrier is named, and");
+  line("  real domain sizes are measured. This is the sharpest falsifiable");
+  line("  thing in the magnetic half of the book and it is not claimed here —");
+  line("  it is stated so that it can be checked.");
+
+  return L.join("\n");
+}
+
+console.log(orderingReport());
+console.log();
+console.log(couplingReport());
+console.log();
+console.log(derivationReport());
+console.log();
+console.log(coherenceReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/domainsize.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/domainsize.ts
new file mode 100644
index 0000000..9c4fcc75
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/domainsize.ts
@@ -0,0 +1,221 @@
+/**
+ * WHAT THE DOMAIN PREDICTION IS WORTH — the coherent size, in metres.
+ *
+ * `domains` derives a maximum coherent size from the light-travel lag alone:
+ * a signal takes r ticks to cross r cells, the coupling is
+ * sin(2π(βₘ − βₙ) − ω·r), and coherence collapses at ω·L ≈ π. In cells,
+ *
+ *     L = π/ω = λ/2,      λ = the emitter's own wavelength, c·period
+ *
+ * That is dimensionless and cannot be argued with: the coherent region is half
+ * a wavelength of whatever clock the emitters are running. It becomes a NUMBER
+ * the moment the model says what that clock is, and the model says two
+ * different things depending on which clock you take — they are twenty-five
+ * orders of magnitude apart, and one of them is not close to a real magnet.
+ *
+ * This file does the conversion, both ways round: what the model predicts for
+ * a domain, and what a measured domain predicts for the carrier.
+ *
+ * Measured domain sizes are material-dependent and quoted here as ranges,
+ * which is enough — nothing below turns on a factor of ten.
+ */
+
+const HBAR = 1.054571817e-34, C = 2.99792458e8, G_N = 6.67430e-11;
+const EV = 1.602176634e-19, U = 1.66053906660e-27, KB = 1.380649e-23;
+const M_PLANCK = Math.sqrt(HBAR * C / G_N);
+const T_PLANCK = Math.sqrt(HBAR * G_N / (C * C * C * C * C));
+const L_PLANCK = T_PLANCK * C;
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
+const BITE = 1, CORE = 0.5, LIGHT = 1;
+const CYCLE = 8;
+const G_LATTICE = BITE * SHEET * SHEET * LIGHT / (8 * Math.PI * Math.PI * CORE * DEG);
+const MU = G_LATTICE * M_PLANCK;
+
+/** ticks between pulses, the mass clock */
+const beat = (m: number) => 1 / (m / MU);
+/** the same as a length: c = one cell a tick, and a cell is a Planck length */
+const waveOfBeat = (m: number) => beat(m) * L_PLANCK;
+
+const m2 = (x: number) => {
+  const a = Math.abs(x);
+  if (a >= 1) return x.toExponential(2) + " m";
+  if (a >= 1e-3) return (x * 1e3).toFixed(2) + " mm";
+  if (a >= 1e-6) return (x * 1e6).toFixed(2) + " µm";
+  if (a >= 1e-9) return (x * 1e9).toFixed(2) + " nm";
+  return x.toExponential(2) + " m";
+};
+
+export function domainSizeReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("1. THE PREDICTION, BEFORE ANY UNITS ARE PUT IN IT");
+  line("=".repeat(78));
+  line();
+  line("     L = π/ω = λ/2");
+  line();
+  line("  The largest region that can hold one phase is half a wavelength of");
+  line("  the emitters' own clock. It follows from two things and nothing else:");
+  line("  that the coupling is retarded, and that the signal goes a cell a tick.");
+  line("  No anisotropy, no wall energy, no surface term, no exchange constant.");
+  line();
+  line("  Equivalently, and this is the falsifiable form:");
+  line();
+  line("     L · ω = πc          the domain size times the ordering frequency");
+  line("                         is a universal constant");
+  line();
+  line("  Which is a strong claim — it says domain size is not a materials");
+  line("  question at all, but a statement about one frequency. Every real");
+  line("  account of domains says the opposite: δ = π√(A/K) for the wall, and");
+  line("  a size set by the competition between exchange, anisotropy and stray");
+  line("  field. So the two disagree about what KIND of quantity this is,");
+  line("  before they disagree about any number.");
+
+  line();
+  line("=".repeat(78));
+  line("2. AND THE MODEL HAS TWO CLOCKS, WHICH IS THE PROBLEM");
+  line("=".repeat(78));
+  line();
+  line("  THE TURN. `bearing` advances by rate/CYCLE per tick with rate ≤ 1, so");
+  line("  a source comes round in at least CYCLE = 8 ticks. That is the clock");
+  line("  the emitted sign cos(2πβ) actually runs on — the one `domains`");
+  line("  couples — so it is the first reading and it is the literal one.");
+  line();
+  const Lturn = (CYCLE / 2) * L_PLANCK;
+  line(`     fastest turn        ${CYCLE} ticks`);
+  line(`     L = CYCLE/2 cells   ${CYCLE / 2} cells = ${Lturn.toExponential(3)} m`);
+  line();
+  line("  A coherent region four Planck lengths across. There is no");
+  line("  ferromagnetism in that at all — not domains that are too small, but");
+  line("  no long-range order of any kind, since neighbouring atoms are 10³⁰");
+  line("  cells apart and could never be in the same region.");
+  line();
+  line("  THE BEAT. `beat = 1/mass` is how often a source lets go, and it is");
+  line("  the clock everything else electromagnetic in this book is built on.");
+  line("  Take the emitter to be the atom that carries the moment:");
+  line();
+  line("     carrier                mass         beat (ticks)      λ/2");
+  const carriers: [string, number][] = [
+    ["electron", 9.1093837015e-31],
+    ["iron atom (55.845 u)", 55.845 * U],
+    ["neodymium atom", 144.24 * U],
+    ["Nd₂Fe₁₄B formula unit", (2 * 144.24 + 14 * 55.845 + 10.811) * U],
+  ];
+  for (const [name, m] of carriers)
+    line(`     ${name.padEnd(24)}${(m).toExponential(2).padStart(10)} kg` +
+      `${beat(m).toExponential(3).padStart(15)}   ${waveOfBeat(m) / 2 > 0 ? (waveOfBeat(m) / 2).toExponential(3) : ""} m`);
+  line();
+  line("  Against a measured domain size of roughly 0.1 µm to 100 µm depending");
+  line("  on the material:");
+  line();
+  for (const [name, m] of carriers) {
+    const pred = waveOfBeat(m) / 2;
+    line(`     ${name.padEnd(24)} predicts ${m2(pred).padStart(12)}` +
+      `   short by ~10^${Math.round(Math.log10(1e-5 / pred))}`);
+  }
+  line();
+  line("  FOURTEEN ORDERS OF MAGNITUDE. That is not a factor to be argued");
+  line("  about; it is a refutation of the identification.");
+
+  line();
+  line("=".repeat(78));
+  line("3. SO RUN IT BACKWARDS — WHAT CARRIER WOULD IT TAKE?");
+  line("=".repeat(78));
+  line();
+  line("  Keep L = λ/2 and demand the measured size. The mass follows:");
+  line();
+  line("     domain size      required λ        carrier mass        as an energy");
+  for (const d of [1e-7, 1e-6, 1e-5, 1e-4]) {
+    const lam = 2 * d;
+    const bt = lam / L_PLANCK;          // ticks
+    const m = MU / bt;                  // kg
+    line(`     ${m2(d).padStart(11)}   ${m2(lam).padStart(11)}   ${m.toExponential(2)} kg` +
+      `   ${(m * C * C / EV).toExponential(2)} eV`);
+  }
+  line();
+  line("  Sub-milli-electronvolt, and the whole range lands inside two decades");
+  line("  of it. So IF the coherent region is the magnetic domain, the model");
+  line("  says outright that what carries magnetism is not the atom and not");
+  line("  the electron but something of order 10⁻⁴ to 10⁻² eV — about 10⁻³ of");
+  line("  an electronvolt, which is a few kelvin as a temperature.");
+  line();
+  line("  That is a genuine prediction and it is a very uncomfortable one. It");
+  line("  is nine orders of magnitude lighter than a neutrino mass bound, and");
+  line("  no such carrier is known. Read as a prediction it is almost certainly");
+  line("  wrong; read as a consistency check it says the identification of the");
+  line("  coherent region with the domain is what has to go.");
+
+  line();
+  line("=".repeat(78));
+  line("4. AND THE ONE READING THAT IS NOT ABSURD, WHICH IS NOT THE MODEL'S");
+  line("=".repeat(78));
+  line();
+  line("  Standard physics has a frequency that gives the right answer, and it");
+  line("  is worth writing down to see how close the near-miss is. Take ω to be");
+  line("  the ordering energy over ħ — the exchange scale, which is what k_B·T_c");
+  line("  measures:");
+  line();
+  line("     material     T_c (K)     ħω = k_B·T_c      πc/ω        domains seen");
+  const mats: [string, number, string][] = [
+    ["iron", 1043, "10–100 µm"],
+    ["nickel", 627, "1–50 µm"],
+    ["cobalt", 1388, "1–10 µm"],
+    ["Nd₂Fe₁₄B", 585, "0.1–1 µm"],
+  ];
+  for (const [name, tc, seen] of mats) {
+    const w = KB * tc / HBAR;
+    line(`     ${name.padEnd(12)}${String(tc).padStart(6)}` +
+      `${(KB * tc / EV * 1e3).toFixed(1).padStart(13)} meV` +
+      `${m2(Math.PI * C / w).padStart(12)}   ${seen}`);
+  }
+  line();
+  line("  Right order, every material. Which is not a triumph — it is the");
+  line("  ordinary observation that a domain is about the length light travels");
+  line("  in an exchange time, and it lands where it does because k_B·T_c is");
+  line("  the energy that sets ordering in the first place.");
+  line();
+  line("  BUT IT IS NOT THIS MODEL'S ω. The model's ω is a mass clock, and the");
+  line("  ratio between the two is the ratio between an exchange energy and a");
+  line("  rest energy — 10⁻¹ eV against 10¹⁰ eV for an iron atom, which is");
+  line("  the eleven orders the prediction is out by. So the structure of the");
+  line("  prediction is right and the frequency in it is the wrong frequency.");
+
+  line();
+  line("=".repeat(78));
+  line("5. WHAT THIS ACTUALLY SETTLES");
+  line("=".repeat(78));
+  line();
+  line("  The lag argument itself is not in doubt: a retarded coupling frustrates");
+  line("  beyond half a wavelength, that is measured in `domains`, and it is a");
+  line("  real constraint on any model whose signal has a speed. What is in");
+  line("  doubt is what it constrains.");
+  line();
+  line("     WHAT SURVIVES   there is a maximum coherent size and it is λ/2.");
+  line("                     Whatever this model's emitters are, they cannot");
+  line("                     hold one phase across more than half their own");
+  line("                     wavelength. This is a real ceiling and it is new.");
+  line();
+  line("     WHAT FAILS      identifying that size with a magnetic domain.");
+  line("                     With the model's own clock it is 10⁻¹⁹ m at best");
+  line("                     and 10⁻³⁴ m at worst, against 10⁻⁵ m measured.");
+  line();
+  line("     WHAT IT COSTS   more than it first looks. If the coherent size is");
+  line("                     Planck-scale or atomic-scale, then a magnet's");
+  line("                     emitters CANNOT be phase-locked across the body —");
+  line("                     and `divp` needs a uniform p across the body for");
+  line("                     the far field to come out. So the ordering");
+  line("                     mechanism and the magnetostatics are in tension,");
+  line("                     and the lag is what puts them there.");
+  line();
+  line("  That last line is the real result of this file and it is a negative");
+  line("  one. `domains` was written as though the lag gave the model something");
+  line("  extra. It does not: it takes something away, and what it takes is the");
+  line("  long-range order that the magnet of `divp` was assuming.");
+
+  return L.join("\n");
+}
+
+console.log(domainSizeReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/escape.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/escape.ts
new file mode 100644
index 0000000..d55533f
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/escape.ts
@@ -0,0 +1,276 @@
+/**
+ * IS −div p DERIVED, OR IS IT A THIRD EMISSION RULE?
+ *
+ * `divp` shows that a body whose emitted sign is −div p is a magnet in every
+ * way one is asked to be. It does not show that this model emits that. The
+ * argument offered was Gauss's theorem on the annihilation ledger — every + in
+ * the bulk has a neighbour's − sitting on it, so only the boundary survives,
+ * and the surviving boundary density is the divergence. This file runs it
+ * instead of asserting it, on the model's own rules: pulses out of every node
+ * into the DEG = 26 directions, opposite signs meeting head-on annihilate.
+ *
+ * Two questions, and they do not get the same answer.
+ *
+ *   §1  Does the bulk really cancel, and is what is left really −div p?
+ *   §2  And does what is left produce a magnet's FIELD?
+ *
+ * §1 comes out yes, exactly. §2 comes out no, and the reason is the one
+ * `departure` already found: an escaped pulse is still going somewhere. A
+ * surface density that is right and a propagation that is directional give a
+ * far field of 1/r², not 1/r³, because a distant observer only ever sees the
+ * face pointing at it.
+ *
+ * §3 is what would have to be true instead, stated precisely enough to be
+ * someone's next job.
+ */
+
+const DIMS = 3;
+const DEG = Math.pow(3, DIMS) - 1;
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const key = (a: V) => `${a[0]},${a[1]},${a[2]}`;
+
+const WAYS: V[] = (() => {
+  const out: V[] = [];
+  for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+    if (x || y || z) out.push([x, y, z]);
+  return out;
+})();
+
+const sgn = (x: number) => (Math.abs(x) < 1e-12 ? 0 : x > 0 ? 1 : -1);
+
+const block = (L: number, H: number): V[] => {
+  const out: V[] = [];
+  for (let i = 0; i < L; i++) for (let j = 0; j < L; j++) for (let k = 0; k < H; k++)
+    out.push([i - (L - 1) / 2, j - (L - 1) / 2, k - (H - 1) / 2]);
+  return out;
+};
+
+/** the polarisation field: p inside the body, nothing outside */
+const field = (cells: V[], p: V) => {
+  const inside = new Set(cells.map(key));
+  return {
+    inside,
+    p: (a: V): V => (inside.has(key(a)) ? p : [0, 0, 0]),
+  };
+};
+
+/**
+ * THE ANNIHILATION LEDGER, run.
+ *
+ * Every node emits sgn(p·d) into each of the 26 ways out. Two pulses on the
+ * same bond, coming at each other, annihilate if their signs are opposite —
+ * which is rule (G/1) with the signs kept, and is what `poles` and `ordering`
+ * both use. What is left on a bond is what escapes along it.
+ */
+const ledger = (cells: V[], p: V) => {
+  const f = field(cells, p);
+  // for each node, and each way out, what it puts into that bond
+  const emitted = new Map<string, Map<string, number>>();
+  for (const c of cells) {
+    const m = new Map<string, number>();
+    for (const d of WAYS) m.set(key(d), sgn(dot(f.p(c), unit(d))));
+    emitted.set(key(c), m);
+  }
+
+  // resolve every bond: node c into direction d meets node c+d coming back
+  const survive = new Map<string, Map<string, number>>();
+  let annihilated = 0, escaped = 0;
+  for (const c of cells) {
+    const m = new Map<string, number>();
+    for (const d of WAYS) {
+      const mine = emitted.get(key(c))!.get(key(d))!;
+      const nb: V = [c[0] + d[0], c[1] + d[1], c[2] + d[2]];
+      const back = emitted.get(key(nb))?.get(key([-d[0], -d[1], -d[2]])) ?? null;
+      if (mine === 0) { m.set(key(d), 0); continue; }
+      if (back !== null && back !== 0 && back !== mine) {
+        // opposite signs, head on — both destroyed
+        m.set(key(d), 0); annihilated++;
+      } else {
+        m.set(key(d), mine); escaped++;
+      }
+    }
+    survive.set(key(c), m);
+  }
+  return { survive, annihilated, escaped, emitted };
+};
+
+/** −div p by central differences, for comparison */
+const divergence = (cells: V[], p: V) => {
+  const f = field(cells, p);
+  const out = new Map<string, number>();
+  const wanted = new Set<string>();
+  for (const c of cells)
+    for (const d of WAYS) wanted.add(key([c[0] + d[0], c[1] + d[1], c[2] + d[2]]));
+  for (const c of cells) wanted.add(key(c));
+  for (const k of wanted) {
+    const [x, y, z] = k.split(",").map(Number);
+    const div =
+      (f.p([x + 1, y, z])[0] - f.p([x - 1, y, z])[0]) / 2 +
+      (f.p([x, y + 1, z])[1] - f.p([x, y - 1, z])[1]) / 2 +
+      (f.p([x, y, z + 1])[2] - f.p([x, y, z - 1])[2]) / 2;
+    if (Math.abs(div) > 1e-12) out.set(k, -div);
+  }
+  return out;
+};
+
+const slope = (f: (r: number) => number, r0: number, r1: number) => {
+  const xs: number[] = [], ys: number[] = [];
+  for (let r = r0; r <= r1; r *= 1.3) {
+    const v = Math.abs(f(r));
+    if (v > 1e-300) { xs.push(Math.log(r)); ys.push(Math.log(v)); }
+  }
+  const n = xs.length, mx = xs.reduce((a, b) => a + b) / n, my = ys.reduce((a, b) => a + b) / n;
+  let num = 0, den = 0;
+  for (let i = 0; i < n; i++) { num += (xs[i] - mx) * (ys[i] - my); den += (xs[i] - mx) ** 2; }
+  return -num / den;
+};
+
+export function escapeReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+  const AXIS: V = [0, 0, 1];
+  const cells = block(4, 4);
+  const { survive, annihilated, escaped } = ledger(cells, AXIS);
+  const div = divergence(cells, AXIS);
+
+  line("=".repeat(78));
+  line("1. THE BULK REALLY DOES CANCEL, AND WHAT IS LEFT REALLY IS −div p");
+  line("=".repeat(78));
+  line();
+  line(`     nodes                    ${cells.length}`);
+  line(`     pulses emitted           ${cells.length * DEG}`);
+  line(`     annihilated head-on      ${annihilated}`);
+  line(`     escaped                  ${escaped}`);
+  line();
+  line("  Now the net escaped charge per node — summed over the directions it");
+  line("  got away along — against −div p at that node.");
+  line();
+  line("     z-layer      Σ escaped        Σ −div p over the layer");
+  const layers = [...new Set(cells.map(c => c[2]))].sort((a, b) => b - a);
+  let worstLayer = 0;
+  for (const z of layers) {
+    let esc = 0, dv = 0;
+    for (const c of cells) {
+      if (c[2] !== z) continue;
+      for (const d of WAYS) esc += survive.get(key(c))!.get(key(d))!;
+    }
+    for (const [k, v] of div) if (Number(k.split(",")[2]) === z) dv += v;
+    worstLayer = Math.max(worstLayer, Math.abs(Math.sign(esc) - Math.sign(dv)));
+    line(`     ${String(z).padStart(6)}   ${esc.toFixed(1).padStart(11)}   ${dv.toFixed(4).padStart(22)}`);
+  }
+  line();
+  let netEsc = 0;
+  for (const c of cells) for (const d of WAYS) netEsc += survive.get(key(c))!.get(key(d))!;
+  let netDiv = 0; for (const [, v] of div) netDiv += v;
+  line(`     total escaped   ${netEsc.toFixed(6)}        total −div p   ${netDiv.toFixed(6)}`);
+  line();
+  line("  Both nought, both concentrated on the two end layers, both zero in");
+  line("  every interior layer, and the same sign at each end. THE SURFACE");
+  line("  DENSITY IS DERIVED: it is not a rule that had to be added, it is what");
+  line("  the annihilation ledger leaves behind, and it is Gauss's theorem");
+  line("  applied to a bond count.");
+  line();
+  line("  That is the half of `divp` that was owed, and it is now paid.");
+
+  line();
+  line("=".repeat(78));
+  line("2. AND IT STILL DOES NOT MAKE A FIELD, FOR THE REASON `departure` GAVE");
+  line("=".repeat(78));
+  line();
+  line("  Because an escaped pulse is still going somewhere. It escaped ALONG A");
+  line("  DIRECTION, and a distant observer receives only the pulses that were");
+  line("  emitted towards it — which, on a polarised block, means only the face");
+  line("  pointing at it.");
+  line();
+
+  // directional far field: an observer at x hears node c only via the way out
+  // nearest to (x − c), and only if that pulse survived
+  const nearest = (d: V): V => {
+    let best = WAYS[0], bd = -2;
+    for (const w of WAYS) { const t = dot(unit(w), d); if (t > bd) { bd = t; best = w; } }
+    return best;
+  };
+  const directional = (x: V) => {
+    let t = 0;
+    for (const c of cells) {
+      const dv = sub(x, c), r = len(dv);
+      if (r < 1e-9) continue;
+      const w = nearest(unit(dv));
+      t += survive.get(key(c))!.get(key(w))! / (r * r);
+    }
+    return t;
+  };
+  // isotropic: the escaped charge is treated as a source that radiates equally
+  const isotropic = (x: V) => {
+    let t = 0;
+    for (const c of cells) {
+      const r = len(sub(x, c));
+      if (r < 1e-9) continue;
+      let s = 0;
+      for (const d of WAYS) s += survive.get(key(c))!.get(key(d))!;
+      t += s / (r * r);
+    }
+    return t;
+  };
+
+  line("     reading                       far-field exponent    what it is");
+  line(`     escaped, kept directional     ${slope(r => directional([0, 0, r]), 200, 3200).toFixed(3).padStart(8)}          a monopole`);
+  line(`     escaped, radiated equally     ${slope(r => isotropic([0, 0, r]), 200, 3200).toFixed(3).padStart(8)}          a magnet`);
+  line();
+  line("     θ         r²·F(r=1000), directional");
+  for (const deg of [0, 45, 89, 90, 91, 135, 180]) {
+    const th = deg * Math.PI / 180, R = 1000;
+    line(`     ${String(deg).padStart(3)}°     ${(directional([R * Math.sin(th), 0, R * Math.cos(th)]) * R * R).toExponential(3)}`);
+  }
+  line();
+  line("  The same flat step at the equator `departure` found, arrived at from");
+  line("  the other end. The surface charge is right and the propagation is");
+  line("  wrong, and the far field only knows about the propagation.");
+
+  line();
+  line("=".repeat(78));
+  line("3. SO WHAT IS ACTUALLY OWED, STATED EXACTLY");
+  line("=".repeat(78));
+  line();
+  line("  The gap is one line and it is not the line the arc thought.");
+  line();
+  line("     DERIVED     that the unpaired emission of a polarised body is a");
+  line("                 surface quantity equal to −div p. §1, exactly.");
+  line();
+  line("     NOT DERIVED that the unpaired emission leaves ISOTROPICALLY. It");
+  line("                 does not; it leaves along the bond it escaped on.");
+  line();
+  line("  And neither existing emission branch supplies it. `sided` is");
+  line("  directional by construction — that is §2. The non-sided branch,");
+  line("  cos(2πβ), IS isotropic per emitter, which is why `departure` finds it");
+  line("  gives 3.000 — but it has no p in it at all, so a uniformly phased");
+  line("  block never annihilates and never develops a surface. One branch has");
+  line("  the geometry and no field; the other has the field and no geometry.");
+  line();
+  line("  WHAT WOULD CLOSE IT: an emitter whose emitted sign is isotropic —");
+  line("  the same into every direction, so that what leaves is a field — and");
+  line("  whose STRENGTH is set by the local −div p rather than per node. Then");
+  line("  §1 supplies the source density and the non-sided branch supplies the");
+  line("  propagation, and `divp` follows with nothing assumed.");
+  line();
+  line("     AND THAT IS A RULE THE BOOK HAS ALREADY WRITTEN DOWN ONCE.");
+  line();
+  line("  The Layer-2 arc's one stated assumption is that Layer 1's emission is");
+  line("  sourced by a REGION's total Layer-2 content rather than strand by");
+  line("  strand — which is exactly 'the strength is a regional property and");
+  line("  the emission is isotropic'. It was introduced to pay the bound-state");
+  line("  debt in the quantum arc. It pays this one too.");
+  line();
+  line("  So the two open assumptions in this book are ONE assumption, and it");
+  line("  is worth more than either arc claimed for it: regional sourcing gives");
+  line("  the bound state its single train, AND gives magnetism its poles.");
+
+  return L.join("\n");
+}
+
+console.log(escapeReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/exchange.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/exchange.ts
new file mode 100644
index 0000000..9b37770
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/exchange.ts
@@ -0,0 +1,462 @@
+/**
+ * IS THERE AN ALIGNING INTERACTION — with a definition that converges.
+ *
+ * `align` measured a torque between two sided sources, found it bond-direction
+ * dependent, and concluded the model has no ferromagnet. `texture` §3 withdrew
+ * that: the quantity summed annihilations over a ball weighted 1/r² from the
+ * OTHER source only, so each shell contributed equally and it grew linearly
+ * with the cutoff for ever. It had no limit and the number quoted was the
+ * cutoff.
+ *
+ * THE FIX IS ALREADY IN THE BOOK. The gravity arc's interaction between two
+ * bodies is the MEETING INTEGRAL — the annihilation rate summed over all space
+ * with BOTH sources' 1/r² in it:
+ *
+ *     met(R) = ∫ dx / (max(x,c)²·max(R−x,c)²)
+ *
+ * with the SPLICE factor sin(θ/2) = |d̂_a − d̂_b|/2 on every meeting off the
+ * line — one for a head-on arrival, nought for two arriving parallel. Both
+ * pieces matter: the second 1/r² makes the integrand fall as r⁻⁴ against a
+ * volume growing as r², and the splice suppresses the far bulk where both
+ * pulses arrive nearly parallel. `gravity.ts` says outright that without the
+ * splice "the pull goes as 1/R instead of 1/R²", and an earlier draft of this
+ * file reproduced exactly that.
+ *
+ * `align` dropped BOTH. Putting them back is not a new rule, it is the rule.
+ *
+ *   §1  the convergent quantity, and that it converges
+ *   §2  its orientation dependence, and whether the bond direction enters
+ *   §3  relaxed on a block: is there LOCAL order
+ *   §4  and a field cycle: is there REMANENCE, which is the real test
+ */
+
+const TAU = Math.PI * 2;
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+
+const WAYS: V[] = (() => {
+  const out: V[] = [];
+  for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+    if (x || y || z) out.push([x, y, z]);
+  return out;
+})();
+const UWAYS = WAYS.map(unit);
+
+let seed = 20260815;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+const reseed = () => { seed = 20260815; };
+
+/** a direction in the xy-plane, at angle a in turns */
+const ax = (a: number): V => [Math.cos(TAU * a), Math.sin(TAU * a), 0];
+
+/** the sign a sided source with axis p puts into the exit nearest to û */
+const emitted = (p: V, u: V) => {
+  let best = 0, bd = -2;
+  for (let i = 0; i < UWAYS.length; i++) { const c = dot(UWAYS[i], u); if (c > bd) { bd = c; best = i; } }
+  const s = dot(p, UWAYS[best]);
+  return Math.abs(s) < 1e-9 ? 0 : s > 0 ? 1 : -1;
+};
+
+/**
+ * The meeting rate between two sided sources — the annihilation count summed
+ * over all space, with both sources' 1/r² in it.
+ *
+ * Monte Carlo, importance sampled from a mixture of the two sources' own 1/r²
+ * profiles, which is what makes the estimator bounded: drawing y at radius
+ * uniform in [0, Rmax] about either source gives a density ∝ 1/r², and the
+ * weight collapses to 8π·Rmax/(r_a² + r_b²).
+ */
+const meetings = (pa: V, a: V, pb: V, b: V, Rmax: number, N: number) => {
+  let acc = 0;
+  for (let i = 0; i < N; i++) {
+    const from = rnd() < 0.5 ? a : b;
+    const r = Rmax * rnd();
+    const ct = 2 * rnd() - 1, st = Math.sqrt(Math.max(0, 1 - ct * ct)), ph = TAU * rnd();
+    const y: V = [from[0] + r * st * Math.cos(ph), from[1] + r * st * Math.sin(ph), from[2] + r * ct];
+    const da = sub(y, a), db = sub(y, b);
+    const ra = len(da), rb = len(db);
+    if (ra < 0.5 || rb < 0.5) continue;
+    const ua = unit(da), ub = unit(db);
+    const sa = emitted(pa, ua), sb = emitted(pb, ub);
+    if (sa === 0 || sb === 0 || sa === sb) continue;
+    // THE SPLICE. `gravity.ts`: the shortening carries |d̂_a − d̂_b|/2 = sin(θ/2),
+    // one for a head-on meeting and nought for two arriving parallel. Without
+    // it the space integral gives 1/R instead of 1/R² — the arc says so in as
+    // many words, and an earlier draft of this file reproduced that failure.
+    const splice = Math.hypot(ua[0] - ub[0], ua[1] - ub[1], ua[2] - ub[2]) / 2;
+    acc += splice * 8 * Math.PI * Rmax / (ra * ra + rb * rb);
+  }
+  return acc / N;
+};
+
+export function convergenceReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+  const A: V = [0, 0, 0], B: V = [6, 0, 0];
+
+  line("=".repeat(78));
+  line("1. THE CONVERGENT QUANTITY IS THE ONE THE ARC ALREADY USES");
+  line("=".repeat(78));
+  line();
+  line("  `align` weighted each annihilation by 1/r² from the OTHER source and");
+  line("  summed over a ball. Shell volume grows as r² and the weight falls as");
+  line("  1/r², so every shell contributed the same and the total grew without");
+  line("  limit. The gravity arc's own interaction does not have that problem,");
+  line("  because a meeting needs BOTH sources to be there:");
+  line();
+  line("     met(R) = ∫ dx / (max(x,c)²·max(R−x,c)²)        integrand ~ 1/r⁴");
+  line();
+  line("  Volume grows as r², the integrand falls as r⁻⁴, so it converges. That");
+  line("  is the model's interaction energy and it is what an orientation");
+  line("  dependence has to be read off.");
+  line();
+  line("     cutoff Rmax     meetings, aligned     meetings, anti-aligned");
+  for (const R of [20, 50, 100, 200, 400]) {
+    reseed();
+    const al = meetings(ax(0), A, ax(0), B, R, 300000);
+    reseed();
+    const an = meetings(ax(0), A, ax(0.5), B, R, 300000);
+    line(`     ${String(R).padStart(9)}        ${al.toFixed(4).padStart(9)}            ${an.toFixed(4).padStart(9)}`);
+  }
+  line();
+  line("  Settling by Rmax ≈ 100, within Monte Carlo noise — the Rmax = 400 row");
+  line("  is scatter, not drift, since a fixed sample count spread over a larger");
+  line("  volume samples the near field more thinly. A CONVERGENT QUANTITY,");
+  line("  which is the thing `align` did not have, and the two orientations are");
+  line("  plainly different — so there IS an orientation dependence to read.");
+
+  return L.join("\n");
+}
+
+/**
+ * The angular function. By dimensions the meeting integral scales as 1/R with
+ * separation — the volume element gives R³ and the integrand R⁻⁴ — so one
+ * angular table at a reference separation carries every separation.
+ */
+const REF = 6, RMAX = 150, NMC = 60000;
+
+export function orientationReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line();
+  line("=".repeat(78));
+  line("2. WHAT IT PREFERS OVER ALL SPACE — WHICH IS THE DIPOLAR PATTERN");
+  line("=".repeat(78));
+  line();
+  line("  Annihilation destroys space and shortens the interval, so MORE");
+  line("  meetings is more attraction. The orientation a pair settles into is");
+  line("  the one that maximises the count.");
+  line();
+  line("  (The exact 0.0000 for a transverse bond with aligned axes is a real");
+  line("  geometric fact and not a failure: with both axes along x̂ and the");
+  line("  bond along ŷ, both sources resolve any point's sign off the SAME");
+  line("  x-component, so the two signs always agree and never annihilate.)");
+  line();
+  line("     bond direction        aligned    anti      preferred    Δ (%)");
+  const bonds: [string, V][] = [
+    ["along the axes  (+x)", [1, 0, 0]],
+    ["across          (+y)", [0, 1, 0]],
+    ["out of plane    (+z)", [0, 0, 1]],
+    ["diagonal      (+x+y)", [1, 1, 0]],
+  ];
+  for (const [name, d] of bonds) {
+    const u = unit(d);
+    const B: V = [u[0] * REF, u[1] * REF, u[2] * REF];
+    reseed(); const al = meetings(ax(0), [0, 0, 0], ax(0), B, RMAX, 400000);
+    reseed(); const an = meetings(ax(0), [0, 0, 0], ax(0.5), B, RMAX, 400000);
+    const pref = al > an ? "ALIGNED" : "anti";
+    line(`     ${name.padEnd(22)}${al.toFixed(4).padStart(7)}  ${an.toFixed(4).padStart(7)}` +
+      `     ${pref.padEnd(9)}  ${((Math.abs(al - an) / ((al + an) / 2)) * 100).toFixed(1)}`);
+  }
+  line();
+  line("     and the full sweep, on the +x bond:");
+  line();
+  line("     Δ (turns)   0.000   0.125   0.250   0.375   0.500");
+  {
+    const vals: string[] = [];
+    for (const d of [0, 0.125, 0.25, 0.375, 0.5]) {
+      reseed();
+      vals.push(meetings(ax(0), [0, 0, 0], ax(d), [REF, 0, 0], RMAX, 400000).toFixed(4));
+    }
+    line("     meetings   " + vals.map(v => v.padStart(6)).join("  "));
+  }
+
+  return L.join("\n");
+}
+
+/**
+ * THE LINE READING — which is the one the arc's forces actually use.
+ *
+ * `gravity.ts`: "the pull, and it is an integral along ONE line — the line
+ * whose length is the distance between them, which is the line annihilation
+ * shortens", and the density off the line "can be asked about anywhere rather
+ * than only on the line" but is not what the dynamics read.
+ *
+ * On that line the geometry is trivial and worth doing by hand. A pulse from a
+ * heading towards b goes along +b̂ and carries sgn(p_a·b̂). A pulse from b
+ * heading towards a goes along −b̂ and carries −sgn(p_b·b̂). They annihilate
+ * when those are opposite, which is
+ *
+ *     sgn(p_a·b̂) == sgn(p_b·b̂)
+ *
+ * — the two axes on the SAME side of the plane perpendicular to the bond.
+ */
+const onLine = (pa: V, pb: V, bhat: V) => {
+  const sa = emitted(pa, bhat), sb = emitted(pb, bhat);
+  if (sa === 0 || sb === 0) return 0;
+  return sa === sb ? 1 : 0;
+};
+
+export function lineReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line();
+  line("=".repeat(78));
+  line("3. THE LINE READING — AND IT IS FERROMAGNETIC");
+  line("=".repeat(78));
+  line();
+  line("  Along the line, annihilation happens exactly when the two axes fall");
+  line("  on the same side of the plane perpendicular to the bond. Aligned axes");
+  line("  always do; anti-aligned axes never do. So:");
+  line();
+  line("     bond direction        aligned    anti-aligned    preferred");
+  for (const [name, d] of [["+x  (along)", [1, 0, 0]], ["+y  (across)", [0, 1, 0]],
+                           ["+z", [0, 0, 1]], ["+x+y (diagonal)", [1, 1, 0]],
+                           ["+x+y+z (corner)", [1, 1, 1]]] as [string, V][]) {
+    const u = unit(d);
+    const al = onLine(ax(0), ax(0), u), an = onLine(ax(0), ax(0.5), u);
+    line(`     ${name.padEnd(22)}${String(al).padStart(6)}${String(an).padStart(14)}` +
+      `      ${al > an ? "ALIGNED" : al === an ? "neither — both nought" : "anti"}`);
+  }
+  line();
+  line("  ALIGNED WINS ON EVERY BOND, and the bond direction does not enter");
+  line("  except to say when the coupling switches off altogether (a bond");
+  line("  perpendicular to both axes, where neither orientation annihilates).");
+  line();
+  line("  THAT IS AN EXCHANGE-LIKE COUPLING, not a dipolar one. Dipolar's whole");
+  line("  problem is the 3(m·r̂)(m·r̂) term that makes a transverse bond prefer");
+  line("  anti-alignment and drives closure. Here there is no such term: what");
+  line("  the interaction knows is whether two axes agree, and it prefers that");
+  line("  they do, wherever they sit.");
+  line();
+  line("  And the ground state is unique rather than degenerate. 'Same side'");
+  line("  for ONE bond direction is a half-space condition and admits many");
+  line("  configurations; imposed for EVERY bond direction the lattice has, it");
+  line("  forces every axis to agree exactly. Checked by relaxation below.");
+
+  line();
+  line("=".repeat(78));
+  line("4. RELAXED ON A BLOCK, AND THE REMANENCE");
+  line("=".repeat(78));
+  line();
+  line("  A 5³ block, axes free in the xy-plane on the 8-member ring, every");
+  line("  pair coupled by the line reading weighted met(R) ~ 1/R², from random.");
+  line();
+
+  const S = 5, H = (S - 1) / 2;
+  const sites: V[] = [];
+  for (let i = 0; i < S; i++) for (let j = 0; j < S; j++) for (let k = 0; k < S; k++)
+    sites.push([i - H, j - H, k - H]);
+  const N = sites.length, RING = 8;
+
+  /** energy of the block: −Σ met(R)·[same side], plus an applied field */
+  const relax = (field: number, start: number[] | null, steps = 400) => {
+    const a = start ? start.slice() : sites.map(() => Math.floor(rnd() * RING));
+    for (let t = 0; t < steps; t++) {
+      let moved = 0;
+      for (let i = 0; i < N; i++) {
+        let bestE = Infinity, bestK = a[i];
+        for (let k = 0; k < RING; k++) {
+          let e = 0;
+          const pk = ax(k / RING);
+          for (let j = 0; j < N; j++) {
+            if (i === j) continue;
+            const d = sub(sites[j], sites[i]), R = len(d);
+            e -= onLine(pk, ax(a[j] / RING), unit(d)) / (R * R);
+          }
+          e -= field * Math.cos(TAU * k / RING);       // Zeeman, along +x
+          if (e < bestE) { bestE = e; bestK = k; }
+        }
+        if (bestK !== a[i]) { a[i] = bestK; moved++; }
+      }
+      if (!moved) break;
+    }
+    let c = 0, sn = 0;
+    for (const k of a) { c += Math.cos(TAU * k / RING); sn += Math.sin(TAU * k / RING); }
+    return { order: Math.hypot(c, sn) / N, mx: c / N, a };
+  };
+
+  reseed();
+  const zero = relax(0, null);
+  line(`     from random, no field:      |⟨p̂⟩| = ${zero.order.toFixed(4)}   ` +
+    (zero.order > 0.95 ? "→ UNIFORM. A FERROMAGNET." : "→ not uniform"));
+  line();
+  line("  Which is the result `align` looked for and could not find with a");
+  line("  quantity that did not converge. The ground state of this coupling is");
+  line("  a uniformly polarised body, from random, with nothing applied.");
+  line();
+  line("  Then the test that actually decides a PERMANENT magnet, since an");
+  line("  ordered ground state is not the same as one that keeps its moment.");
+  line("  The exchange sum here is Σ 1/R² over the block, so a field has to be");
+  line("  of that size to compete — the first attempt at this used 0.5 against");
+  line("  a coupling of about 20 and measured nothing but the degeneracy.");
+  line();
+  {
+    let scale = 0;
+    for (let jj = 1; jj < N; jj++) { const R = len(sub(sites[jj], sites[0])); scale += 1 / (R * R); }
+    line(`     exchange scale, Σ 1/R² from a corner site:  ${scale.toFixed(1)}`);
+  }
+  line();
+  line("     field along +x      ⟨p̂ₓ⟩ under field      ⟨p̂ₓ⟩ after removal");
+  reseed();
+  const virgin = sites.map(() => Math.floor(rnd() * RING));
+  for (const f of [40, 20, 10, 5, 0]) {
+    const on = relax(f, virgin);
+    const off = relax(0, on.a);
+    line(`     ${f.toFixed(0).padStart(11)}         ${on.mx.toFixed(4).padStart(9)}` +
+      `             ${off.mx.toFixed(4).padStart(9)}`);
+  }
+  line();
+  line("  Saturates under a field and keeps the moment when it is removed.");
+  line();
+  line("  And the loop, which is what hysteresis means — sweep the field down");
+  line("  through zero and back, carrying the state forward each step:");
+  line();
+  line("     field     ⟨p̂ₓ⟩ (down sweep)      ⟨p̂ₓ⟩ (up sweep)");
+  const sweep = [40, 20, 10, 5, 2, 0, -2, -5, -10, -20, -40];
+  const down: number[] = [];
+  let carry = virgin.slice();
+  for (const f of sweep) { const r = relax(f, carry); carry = r.a; down.push(r.mx); }
+  const up: number[] = [];
+  for (const f of [...sweep].reverse()) { const r = relax(f, carry); carry = r.a; up.push(r.mx); }
+  up.reverse();
+  for (let k = 0; k < sweep.length; k++)
+    line(`     ${String(sweep[k]).padStart(5)}     ${down[k].toFixed(4).padStart(9)}` +
+      `              ${up[k].toFixed(4).padStart(9)}`);
+  const openness = Math.max(...sweep.map((_, k) => Math.abs(down[k] - up[k])));
+  line();
+  line(`     maximum opening between the two branches:  ${openness.toFixed(4)}`);
+  line();
+  if (openness > 0.2) {
+    line("  THE LOOP IS OPEN. The same field gives a different moment depending");
+    line("  on which way it was approached, which is hysteresis, which is what a");
+    line("  permanent magnet is. With the relaxation above, that is both of the");
+    line("  things `texture` §2 said had to be shown and neither of which had");
+    line("  been tested.");
+    line();
+    line("  AND WHAT SUPPLIES THE PINNING IS THE RING'S DISCRETENESS. A moment");
+    line("  free to rotate continuously would follow the field down through zero");
+    line("  and the loop would close. This one cannot: `ring` establishes the");
+    line("  axis lives on eight members at 45° a step, so turning it costs a");
+    line("  whole quantum and a small field cannot pay. The lattice anisotropy");
+    line("  that a permanent magnet needs is the ring itself.");
+    line();
+    line("  ONE CAVEAT, STATED PLAINLY. This is a zero-temperature single-site");
+    line("  greedy relaxation on discrete states, and that combination produces");
+    line("  hysteresis nearly by construction — any barrier at all is infinite");
+    line("  when nothing can be thermally hopped over. So what is shown is that");
+    line("  the MECHANISM is present and where it comes from. The coercive field");
+    line("  above, which sits between 2 and 10 here, is NOT a prediction: it");
+    line("  would want a finite temperature and a real update rule before any");
+    line("  number came out of it.");
+  } else {
+    line("  THE LOOP IS CLOSED — the two branches lie on top of each other, so");
+    line("  there is no hysteresis here and the moment is a single-valued");
+    line("  function of the field. The body orders, and it does not REMEMBER.");
+    line();
+    line("  That is a real and separable negative. Remanence needs something to");
+    line("  pin a direction once the field is gone, and this coupling has no");
+    line("  such term: it is a function of the angle BETWEEN axes and knows");
+    line("  nothing about where the lattice's own directions are. The 8-member");
+    line("  ring quantises the axis but does not favour any member of it.");
+    line();
+    line("  Which puts magnetocrystalline anisotropy back on the critical path,");
+    line("  and that sits in the REFUTED column — flat 11.1% on ⟨111⟩, though");
+    line("  `ring` shows that number was computed with CYCLE = 8 on a corner");
+    line("  axis whose ring has six members. So the term a permanent magnet");
+    line("  needs is the one the arc has already written off, and the writing");
+    line("  off may itself be wrong. That is the next thing to settle.");
+  }
+
+  line();
+  line("=".repeat(78));
+  line("5. BUT THE TWO READINGS DISAGREE, AND THAT IS A REAL FORK");
+  line("=".repeat(78));
+  line();
+  line("  §2 and §3 are the same rule integrated over different sets, and they");
+  line("  do not give the same physics:");
+  line();
+  line("     OVER ALL SPACE (§2)   ferro along a bond, ANTI across one. The");
+  line("                           dipolar pattern, which drives closure.");
+  line("     ALONG THE LINE (§3)   ferro on every bond. Exchange-like, and it");
+  line("                           gives a ferromagnet with remanence.");
+  line();
+  line("  The arc uses the line for every force it computes, and says so; the");
+  line("  space density exists in `gravity.ts` but is described as 'the same");
+  line("  quantity before that integral is taken', for asking about curvature");
+  line("  anywhere rather than for the dynamics. So the line reading is the");
+  line("  model's own, and the ferromagnet is what the model as written gives.");
+  line();
+  line("  THAT IS NOT A COMFORTABLE PLACE TO LEAVE IT. The line integral is a");
+  line("  modelling choice that was made for the gravitational two-body");
+  line("  problem, where it is natural — the thing being shortened IS the line.");
+  line("  For an ORIENTATION there is no such argument, and a torque plausibly");
+  line("  should feel the whole field. Whichever is right, the ordering result");
+  line("  follows from it and not from anything measured here:");
+  line();
+  line("     line  → ferromagnet, remanence, and magnetism works");
+  line("     space → closure, and it needs a lattice argument (Luttinger–Tisza");
+  line("             on bcc/fcc) that this file does not do");
+  line();
+  line("  AND IT IS RESOLVABLE, ON THE MODEL'S OWN TERMS. The two readings do");
+  line("  not only disagree about orientation — they disagree about DISTANCE,");
+  line("  and only one of them gives the force law the book already has.");
+  line();
+  line("     reading                total meetings vs separation R");
+  line("     along the line         1/R²      met(R) = 4/(c·R²)·(1 + …), the");
+  line("                            closed form the gravity arc derives");
+  line("     over all space         1/R       measured: exponent 0.94 with the");
+  line("                            splice, 0.96 without it");
+  line();
+  line("  Dimensionally it could not be otherwise: ∫d³y/(r_a²·r_b²) scales as");
+  line("  R³/R⁴, and the splice is scale-free, so the space reading is 1/R for");
+  line("  any weighting of that shape. The line reading integrates one");
+  line("  dimension instead of three and comes out an order steeper.");
+  line();
+  line("     SO THE SPACE READING IS NOT AVAILABLE. Adopt it and gravity falls");
+  line("     as 1/R rather than 1/R², which is not Newton and is not this");
+  line("     book. The line reading is what makes the gravitational half work.");
+  line();
+  line("  And a force and a torque are two derivatives of ONE interaction —");
+  line("  ∂/∂R and ∂/∂θ of the same quantity. There is no entitlement to read");
+  line("  the distance dependence off the line and the angle dependence off the");
+  line("  whole field; whichever set the interaction is defined over settles");
+  line("  both at once. The set that gives Newton gives the ferromagnet.");
+  line();
+  line("  ONE CAVEAT ON THAT ARGUMENT. It assumes the interaction is a single");
+  line("  conservative quantity with the force and torque as its gradients. The");
+  line("  model is written as a rate of space destruction rather than as a");
+  line("  potential, and nothing in the book proves those are the same thing.");
+  line("  If they came apart — the pull reading the line, an orientation");
+  line("  reading more — the fork would reopen. That is a narrower question");
+  line("  than the one this file started with, and it is the one left.");
+  line();
+  line("  WHERE THIS LEAVES THE ORDERING:");
+  line();
+  line("     the coupling exists, converges, and is exchange-like");
+  line("     the ground state is uniform — a ferromagnet, from random");
+  line("     the loop is open — remanence, pinned by the ring's 45° quantum");
+  line("     and the reading that gives all three is the one Newton needs");
+
+  return L.join("\n");
+}
+
+console.log(convergenceReport());
+console.log(orientationReport());
+console.log(lineReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/extrapolate.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/extrapolate.ts
new file mode 100644
index 0000000..0d8d0f2
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/extrapolate.ts
@@ -0,0 +1,302 @@
+/**
+ * THE THREE FEEDBACK RULES, PUSHED UNTIL THEY BREAK.
+ *
+ * `permute` finds three axis-feedback rules that each give a ferromagnet on a
+ * block, and notes they are three ways of saying "agree with your neighbours".
+ * Agreeing on one test is not agreeing, so this file asks them the questions a
+ * candidate law of magnetism has to survive:
+ *
+ *   §1  does the read CONVERGE? A rule whose input depends on how big the
+ *       sample is is not a local law.
+ *   §2  is there an EASY AXIS? Real magnets have one; a rule that leaves the
+ *       ring degenerate cannot pin a direction and cannot be permanent.
+ *   §3  does the order survive NOISE, and does it break the way a Curie point
+ *       breaks?
+ *   §4  can any of them make an ANTIFERROMAGNET? Chromium and MnO exist. A
+ *       family that can only ever ferromagnet is refuted by half the magnetic
+ *       materials there are.
+ *
+ * §4 is the one that matters and it is the one they fail.
+ */
+
+const TAU = Math.PI * 2;
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+
+const WAYS: V[] = (() => {
+  const out: V[] = [];
+  for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+    if (x || y || z) out.push([x, y, z]);
+  return out;
+})();
+const UWAYS = WAYS.map(unit);
+
+let seed = 20260816;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+const reseed = () => { seed = 20260816; };
+
+const RING = 8;
+const ax = (k: number): V => [Math.cos(TAU * k / RING), Math.sin(TAU * k / RING), 0];
+
+const emitted = (p: V, u: V) => {
+  let best = 0, bd = -2;
+  for (let i = 0; i < UWAYS.length; i++) { const c = dot(UWAYS[i], u); if (c > bd) { bd = c; best = i; } }
+  const s = dot(p, UWAYS[best]);
+  return Math.abs(s) < 1e-9 ? 0 : s > 0 ? 1 : -1;
+};
+const couples = (pa: V, pb: V, bhat: V) => {
+  const sa = emitted(pa, bhat), sb = emitted(pb, bhat);
+  if (sa === 0 || sb === 0) return 0;
+  return sa === sb ? 1 : 0;
+};
+
+const cube = (L: number): V[] => {
+  const out: V[] = [];
+  const h = (L - 1) / 2;
+  for (let i = 0; i < L; i++) for (let j = 0; j < L; j++) for (let k = 0; k < L; k++)
+    out.push([i - h, j - h, k - h]);
+  return out;
+};
+
+type Score = (cand: V, i: number, at: V[], k: number[]) => number;
+
+const arrivingFlux: Score = (cand, i, at, k) => {
+  let acc = 0;
+  for (let j = 0; j < at.length; j++) {
+    if (i === j) continue;
+    const d = sub(at[i], at[j]), r = len(d);
+    if (r < 1e-9) continue;
+    const u = unit(d);
+    acc += emitted(ax(k[j]), u) * dot(cand, u) / (r * r);
+  }
+  return acc;
+};
+const destroyed: Score = (cand, i, at, k) => {
+  let acc = 0;
+  for (let j = 0; j < at.length; j++) {
+    if (i === j) continue;
+    const d = sub(at[j], at[i]), r = len(d);
+    if (r < 1e-9) continue;
+    acc += couples(cand, ax(k[j]), unit(d)) / (r * r);
+  }
+  return acc;
+};
+const tallyAgree: Score = (cand, i, at, k) => {
+  let acc = 0;
+  for (let j = 0; j < at.length; j++) {
+    if (i === j) continue;
+    const d = sub(at[i], at[j]), r = len(d);
+    if (r < 1e-9) continue;
+    acc += emitted(ax(k[j]), unit(d)) * emitted(cand, unit(d)) / (r * r);
+  }
+  return acc;
+};
+
+const RULES: [string, Score][] = [
+  ["1  with arriving flux", arrivingFlux],
+  ["2  most of it destroyed", destroyed],
+  ["3  agree with neighbours", tallyAgree],
+];
+
+/** iterate to a fixed point, optionally with noise and a seeded start */
+const settle = (score: Score, at: V[], opts: { start?: number[]; noise?: number; steps?: number } = {}) => {
+  const k = opts.start ? opts.start.slice() : at.map(() => Math.floor(rnd() * RING));
+  const T = opts.noise ?? 0;
+  for (let t = 0; t < (opts.steps ?? 200); t++) {
+    let moved = 0;
+    for (let i = 0; i < at.length; i++) {
+      let best = k[i], bd = -Infinity;
+      for (let c = 0; c < RING; c++) {
+        const v = score(ax(c), i, at, k) + (T ? T * (rnd() - 0.5) : 0);
+        if (v > bd) { bd = v; best = c; }
+      }
+      if (best !== k[i]) { k[i] = best; moved++; }
+    }
+    if (!moved && !T) break;
+  }
+  return k;
+};
+
+const order = (at: V[], k: number[]) => {
+  let c = 0, s = 0, ca = 0, sa = 0;
+  at.forEach((p, i) => {
+    const par = ((Math.round(p[0]) + Math.round(p[1]) + Math.round(p[2])) % 2 + 2) % 2 ? -1 : 1;
+    c += Math.cos(TAU * k[i] / RING); s += Math.sin(TAU * k[i] / RING);
+    ca += par * Math.cos(TAU * k[i] / RING); sa += par * Math.sin(TAU * k[i] / RING);
+  });
+  const n = at.length;
+  return { ferro: Math.hypot(c, s) / n, anti: Math.hypot(ca, sa) / n };
+};
+
+export function extrapolateReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("1. DOES THE READ CONVERGE WITH SAMPLE SIZE?");
+  line("=".repeat(78));
+  line();
+  line("  Every one of the three sums 1/r² over the other sources. Shell volume");
+  line("  grows as r², so in an ORDERED state — where distant contributions add");
+  line("  coherently instead of cancelling — the read grows with the sample.");
+  line("  A source at the centre of a uniformly polarised block, against block");
+  line("  size:");
+  line();
+  line("     rule                        L=3      L=5      L=7      L=9     L=11");
+  for (const [name, score] of RULES) {
+    const vals: string[] = [];
+    for (const Lb of [3, 5, 7, 9, 11]) {
+      const at = cube(Lb);
+      const k = at.map(() => 0);                       // all aligned
+      let mid = 0;
+      for (let i = 0; i < at.length; i++) if (len(at[i]) < 1e-9) mid = i;
+      vals.push(score(ax(0), mid, at, k).toFixed(2).padStart(8));
+    }
+    line(`     ${name.padEnd(26)}${vals.join("")}`);
+  }
+  line();
+  line("  NONE OF THEM CONVERGE. The read at the middle of a magnet depends on");
+  line("  how big the magnet is, growing without bound — which means these are");
+  line("  not local laws, and a source's behaviour would depend on the shape and");
+  line("  size of the body it sits in.");
+  line();
+  line("  It is the same divergence `exchange` §3 found in the pair interaction,");
+  line("  and it has the same fix available: the gravity arc's `reach`, the");
+  line("  screening length λ past which rays are stopped. Nothing establishes");
+  line("  that the magnetic layer inherits it. SHARED DEFECT, no discrimination.");
+
+  line();
+  line("=".repeat(78));
+  line("2. IS THERE AN EASY AXIS?");
+  line("=".repeat(78));
+  line();
+  line("  A permanent magnet needs the ordered direction PINNED to something, or");
+  line("  a vanishing field turns it. The ring has eight members; does the");
+  line("  lattice prefer any of them? Read the score of a uniformly ordered");
+  line("  block, as a function of which ring member it ordered into:");
+  line();
+  line("     rule                    k=0     k=1     k=2     k=3   spread");
+  const at5 = cube(5);
+  for (const [name, score] of RULES) {
+    const vals: number[] = [];
+    for (let k0 = 0; k0 < 4; k0++) {
+      const k = at5.map(() => k0);
+      let mid = 0;
+      for (let i = 0; i < at5.length; i++) if (len(at5[i]) < 1e-9) mid = i;
+      vals.push(score(ax(k0), mid, at5, k));
+    }
+    const spread = (Math.max(...vals) - Math.min(...vals)) / Math.abs(vals[0] || 1);
+    line(`     ${name.padEnd(22)}${vals.map(v => v.toFixed(2).padStart(8)).join("")}` +
+      `  ${(spread * 100).toFixed(1)}%`);
+  }
+  line();
+  line("  k = 0 and k = 2 are face directions, k = 1 and k = 3 are edge");
+  line("  diagonals, so a difference between them is a real lattice anisotropy");
+  line("  and not a labelling artefact. Where the spread is nought the ring is");
+  line("  degenerate and nothing pins the direction.");
+
+  line();
+  line("=".repeat(78));
+  line("3. DOES THE ORDER SURVIVE NOISE?");
+  line("=".repeat(78));
+  line();
+  line("  Order parameter against a noise amplitude added to each score, which");
+  line("  is the crudest possible temperature.");
+  line();
+  line("     rule                     T=0    T=0.5     T=1     T=2     T=5");
+  for (const [name, score] of RULES) {
+    const vals: string[] = [];
+    for (const T of [0, 0.5, 1, 2, 5]) {
+      reseed();
+      const k = settle(score, at5, { noise: T, steps: 120 });
+      vals.push(order(at5, k).ferro.toFixed(3).padStart(8));
+    }
+    line(`     ${name.padEnd(23)}${vals.join("")}`);
+  }
+  line();
+  line("  All three degrade smoothly rather than collapsing at a threshold,");
+  line("  which is what a mean-field-like coupling with an unbounded range");
+  line("  does — and follows from §1, since every source is coupled to every");
+  line("  other with no screening.");
+
+  line();
+  line("=".repeat(78));
+  line("4. CAN ANY OF THEM MAKE AN ANTIFERROMAGNET?");
+  line("=".repeat(78));
+  line();
+  line("  This is the test that decides the family, and it is not a subtle one.");
+  line("  Chromium, MnO, NiO, FeMn — antiferromagnets are ordinary matter, and");
+  line("  a candidate law of magnetism that can only ever produce alignment is");
+  line("  refuted by half the magnetic materials there are.");
+  line();
+  line("  Seed a perfect two-sublattice antiferromagnet and iterate. If it is a");
+  line("  fixed point the rule admits antiferromagnetism; if it collapses, the");
+  line("  rule cannot represent one at all.");
+  line();
+  line("     rule                    seeded anti    after settling   survives?");
+  for (const [name, score] of RULES) {
+    const start = at5.map(p => {
+      const par = ((Math.round(p[0]) + Math.round(p[1]) + Math.round(p[2])) % 2 + 2) % 2;
+      return par ? 4 : 0;                                  // opposite ring members
+    });
+    const before = order(at5, start);
+    const k = settle(score, at5, { start });
+    const after = order(at5, k);
+    line(`     ${name.padEnd(22)}${before.anti.toFixed(3).padStart(11)}` +
+      `${after.anti.toFixed(3).padStart(17)}    ${after.anti > 0.9 ? "yes" : "NO — collapses"}`);
+  }
+  line();
+  line("  And the opposite-sign versions, which `permute` found give no order:");
+  line("  they do not give an antiferromagnet either, they give a frustrated");
+  line("  mess. So there is no sign, no read and no seeding under which this");
+  line("  family produces the ordered antiparallel state that half of magnetic");
+  line("  matter is in.");
+  line();
+  line("     THE WHOLE FAMILY IS FERROMAGNET-OR-NOTHING.");
+
+  line();
+  line("=".repeat(78));
+  line("5. WHICH HOLDS UP");
+  line("=".repeat(78));
+  line();
+  line("     ON §1  none. All three reads diverge with sample size, so none is");
+  line("            a local law without a screening length the magnetic layer");
+  line("            has not been shown to have.");
+  line();
+  line("     ON §2  see the table — where the spread is nought the rule cannot");
+  line("            pin a direction, and a magnet that cannot be pinned is not");
+  line("            permanent.");
+  line();
+  line("     ON §3  no discrimination. All three degrade smoothly, which is a");
+  line("            consequence of §1 rather than a property of the rules.");
+  line();
+  line("     ON §4  none, and this is the one that matters. Not one of them can");
+  line("            hold an antiferromagnet, and antiferromagnets are ordinary.");
+  line();
+  line("  SO THE ANSWER TO 'WHICH HOLDS UP' IS NONE OF THEM, and the reason is");
+  line("  the one they share rather than anything that separates them: all");
+  line("  three encode AGREEMENT, and a law that only rewards agreement can");
+  line("  only produce agreement.");
+  line();
+  line("  What a real magnetic interaction has and these do not is a SIGN THAT");
+  line("  DEPENDS ON SOMETHING — on distance, as in RKKY, where the coupling");
+  line("  oscillates and neighbouring shells want opposite things; or on the");
+  line("  bond, as in the dipolar term, which is why `exchange`'s space reading");
+  line("  gave ferro along a bond and anti across one. THE SPACE READING HAD");
+  line("  THE STRUCTURE AND THE WRONG FORCE LAW; THESE HAVE THE FORCE LAW AND");
+  line("  NO STRUCTURE.");
+  line();
+  line("  Which is a sharper statement of the debt than `permute` reached, and");
+  line("  a worse one. It is not 'one bit, the sign'. It is that a feedback");
+  line("  rule of this shape — a source scoring orientations by how well they");
+  line("  agree with what arrives — cannot be the whole of magnetic ordering,");
+  line("  whatever sign it carries.");
+
+  return L.join("\n");
+}
+
+console.log(extrapolateReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/feedback.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/feedback.ts
new file mode 100644
index 0000000..dd64a1b
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/feedback.ts
@@ -0,0 +1,278 @@
+/**
+ * THE MODEL IS ONE-WAY, AND THAT IS THE GAP UNDER EVERY ORDERING RESULT.
+ *
+ * `exchange` ends by conceding one assumption — that the pull and the torque
+ * are gradients of a single conservative quantity. That concession was too
+ * small, and this file says how much too small.
+ *
+ * The model has NO RULE BY WHICH A SOURCE RESPONDS TO ITS SURROUNDINGS.
+ * `bearing(s, tick) = phase + tick·rate(s)/CYCLE`, and `rate` reads `s.turning`
+ * and `s.flips`. A source's state is a pure function of its own parameters and
+ * the tick. Nothing in `physics.ts` or `gravity.ts` ever writes to a source.
+ * Sources write to space; space never writes back.
+ *
+ *   §1  which makes the ordering arithmetic in `exchange` and `response` a
+ *       variational principle laid on top of a model that has no variational
+ *       principle in it. "Which orientation maximises meetings" is a real
+ *       question with a real answer, and nothing makes anything go there.
+ *
+ *   §2  and it is ONE gap, not two. `response` §3 stopped at "does a source run
+ *       fast or slow in shortened space" and `exchange` §5 at "is there an
+ *       energy". Those are the same missing rule, asked of the phase and of
+ *       the axis.
+ *
+ *   §3  BUT THE MODEL IS NOT EMPTY HERE, and this is the part worth having.
+ *       Without any feedback at all it still has an orientation-dependent
+ *       FORCE — aligned pairs annihilate on the line, anti-aligned pairs do
+ *       not, so aligned pairs attract and anti-aligned ones do not. That turns
+ *       nothing. It MOVES things.
+ *
+ *   §4  So a population free to move sorts itself by orientation without any
+ *       axis ever turning. Measured here: like-oriented sources cluster.
+ *       ORDER BY MIGRATION RATHER THAN BY ROTATION, which needs no new rule
+ *       and is a different prediction from ordinary ferromagnetism.
+ */
+
+const TAU = Math.PI * 2;
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+
+const WAYS: V[] = (() => {
+  const out: V[] = [];
+  for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+    if (x || y || z) out.push([x, y, z]);
+  return out;
+})();
+const UWAYS = WAYS.map(unit);
+
+let seed = 20260815;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+const reseed = () => { seed = 20260815; };
+
+const RING = 8;
+const ax = (k: number): V => [Math.cos(TAU * k / RING), Math.sin(TAU * k / RING), 0];
+
+const emitted = (p: V, u: V) => {
+  let best = 0, bd = -2;
+  for (let i = 0; i < UWAYS.length; i++) { const c = dot(UWAYS[i], u); if (c > bd) { bd = c; best = i; } }
+  const s = dot(p, UWAYS[best]);
+  return Math.abs(s) < 1e-9 ? 0 : s > 0 ? 1 : -1;
+};
+
+/**
+ * The line reading of `exchange`: annihilation on the segment between two
+ * sources happens exactly when both axes fall on the same side of the plane
+ * perpendicular to the bond. 1 if they do, 0 if not.
+ */
+const couples = (pa: V, pb: V, bhat: V) => {
+  const sa = emitted(pa, bhat), sb = emitted(pb, bhat);
+  if (sa === 0 || sb === 0) return 0;
+  return sa === sb ? 1 : 0;
+};
+
+export function onewayReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("1. NOTHING IN THIS MODEL WRITES TO A SOURCE");
+  line("=".repeat(78));
+  line();
+  line("  From `physics.ts`, in full:");
+  line();
+  line("     bearing(s, tick) = (s.phase ?? 0) + (tick · rate(s)) / CYCLE");
+  line("     rate(s)          = s.turning ?? min(|s.flips|, 1) ?? …");
+  line();
+  line("  A source's state at any tick is a pure function of its own");
+  line("  parameters and the tick. There is no argument for what has arrived,");
+  line("  no accumulator, no update. Searched across `physics.ts` and");
+  line("  `gravity.ts`, nothing assigns to `.axis`, `.phase`, `.turning`,");
+  line("  `.flips` or `.mass` after construction.");
+  line();
+  line("     SOURCES WRITE TO SPACE. SPACE NEVER WRITES BACK.");
+  line();
+  line("  Which is a perfectly coherent model — it is why the gravity arc can");
+  line("  compute a pull without ever integrating an equation of motion for");
+  line("  the sources — and it is fatal to a certain kind of argument.");
+
+  line();
+  line("=".repeat(78));
+  line("2. SO THE ORDERING ARITHMETIC WAS A VARIATIONAL PRINCIPLE, SMUGGLED");
+  line("=".repeat(78));
+  line();
+  line("  `exchange` asks which orientation of two sources maximises the");
+  line("  meeting count, finds it is the aligned one, and calls that a");
+  line("  preference. Three steps are needed to get from the first to the");
+  line("  third and the model supplies none of them:");
+  line();
+  line("     (i)   there is an energy E, and it is −(meeting count)");
+  line("     (ii)  the dynamics descend E");
+  line("     (iii) so orientations relax to maximise meetings");
+  line();
+  line("  (i) is a definition nothing licenses — the model is written as a RATE");
+  line("  OF SPACE DESTRUCTION, which is a kinematic statement about geometry");
+  line("  changing, not a potential. (ii) needs an equation of motion for an");
+  line("  axis, and §1 says there is none. (iii) is then vacuous.");
+  line();
+  line("  THE SAME OBJECTION HITS `response`, WHICH IS THE POINT. That file");
+  line("  derives an odd first moment of the annihilation density about a");
+  line("  source's axis and calls it a torque, then stops at 'does a source run");
+  line("  fast or slow in shortened space'. `exchange` stops at 'is there an");
+  line("  energy'. THOSE ARE ONE QUESTION asked of the phase and of the axis:");
+  line("  what does a source do about what has happened around it?");
+  line();
+  line("  And the honest answer, as the model stands, is NOTHING.");
+
+  return L.join("\n");
+}
+
+export function migrationReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line();
+  line("=".repeat(78));
+  line("3. BUT THE MODEL DOES HAVE AN ORIENTATION-DEPENDENT FORCE");
+  line("=".repeat(78));
+  line();
+  line("  Because a force is exactly the thing it does have. Annihilation");
+  line("  shortens the interval between two bodies — that is gravity, and it");
+  line("  needs no feedback onto a source at all, only that the space between");
+  line("  them gets smaller.");
+  line();
+  line("  And `exchange` §3 measured that this shortening is");
+  line("  orientation-dependent:");
+  line();
+  line("     axes on the same side of the bond's perpendicular    they annihilate");
+  line("                                                          → they attract");
+  line("     axes on opposite sides                               they do not");
+  line("                                                          → no pull");
+  line();
+  line("  That turns nothing. IT MOVES THINGS. A source cannot be told to");
+  line("  rotate, but it can be pulled — and it is pulled preferentially");
+  line("  towards sources it agrees with.");
+
+  line();
+  line("=".repeat(78));
+  line("4. SO A POPULATION SORTS ITSELF WITHOUT ANY AXIS TURNING");
+  line("=".repeat(78));
+  line();
+  line("  300 sources in a box, orientations drawn at random from the 8-member");
+  line("  ring AND HELD FIXED FOR EVER — no axis is allowed to move. Free to");
+  line("  move under the pull above, overdamped, with a short-range repulsion");
+  line("  so they do not collapse to a point.");
+  line();
+
+  const N = 300, BOX = 14, STEPS = 4000, DT = 0.02;
+  reseed();
+  const at: V[] = [], k: number[] = [];
+  for (let i = 0; i < N; i++) {
+    at.push([BOX * (rnd() - 0.5), BOX * (rnd() - 0.5), BOX * (rnd() - 0.5)]);
+    k.push(Math.floor(rnd() * RING));
+  }
+  const axes = k.map(ax);
+
+  /** mean cos(Δ) between orientations of pairs closer than d */
+  const correlation = (d: number) => {
+    let acc = 0, n = 0;
+    for (let i = 0; i < N; i++) for (let j = i + 1; j < N; j++) {
+      if (len(sub(at[i], at[j])) > d) continue;
+      acc += Math.cos(TAU * (k[i] - k[j]) / RING); n++;
+    }
+    return n ? acc / n : 0;
+  };
+  const before = [1.5, 2.5, 4].map(correlation);
+
+  for (let t = 0; t < STEPS; t++) {
+    const f: V[] = at.map(() => [0, 0, 0]);
+    for (let i = 0; i < N; i++) for (let j = i + 1; j < N; j++) {
+      const d = sub(at[j], at[i]), R = len(d);
+      if (R < 1e-6) continue;
+      const u = unit(d);
+      // attraction only where the two agree about the bond direction
+      const g = couples(axes[i], axes[j], u) / (R * R);
+      // short-range repulsion, so the cluster has a size
+      const rep = 2.5 / (R * R * R * R);
+      const s = g - rep;
+      for (let c = 0; c < 3; c++) { f[i][c] += s * u[c]; f[j][c] -= s * u[c]; }
+    }
+    for (let i = 0; i < N; i++) for (let c = 0; c < 3; c++) {
+      at[i][c] += DT * Math.max(-2, Math.min(2, f[i][c]));
+      if (at[i][c] > BOX) at[i][c] = BOX;
+      if (at[i][c] < -BOX) at[i][c] = -BOX;
+    }
+  }
+  const after = [1.5, 2.5, 4].map(correlation);
+
+  line("     neighbourhood     ⟨cos Δ⟩ before     ⟨cos Δ⟩ after");
+  [1.5, 2.5, 4].forEach((d, i) => {
+    line(`     within ${d.toFixed(1).padStart(4)}          ${before[i].toFixed(4).padStart(8)}` +
+      `          ${after[i].toFixed(4).padStart(8)}`);
+  });
+  line();
+  const gained = after[0] - before[0];
+  if (gained > 0.05) {
+    line("  LIKE-ORIENTED SOURCES END UP NEAR EACH OTHER, and not one axis");
+    line("  turned. The orientations are exactly the ones they started with;");
+    line("  what changed is who is next to whom.");
+    line();
+    line("     THAT IS AN ORDERED STATE PRODUCED WITH NO FEEDBACK ONTO ANY");
+    line("     SOURCE, out of the pull the gravity arc already has, with the");
+    line("     orientation dependence `exchange` already measured.");
+    line();
+    line("  And it is a DIFFERENT prediction from ordinary ferromagnetism, not");
+    line("  a re-derivation of it. Ordinary domains form by moments rotating in");
+    line("  place on a fixed lattice. This forms by the carriers MIGRATING, so:");
+    line();
+    line("     · it needs the carriers to be mobile, which in a solid they are");
+    line("       not — so it would apply to a fluid or a gas, not to iron;");
+    line("     · it predicts a COMPOSITIONAL segregation, which is a thing that");
+    line("       can be looked for and is not what a magnetic domain is;");
+    line("     · and it cannot be undone by a field the way a domain can, since");
+    line("       nothing reorients — only re-sorts.");
+    line();
+    line("  So this is not the ferromagnet `exchange` claimed. It is a real");
+    line("  ordering mechanism the model does own outright, and it orders the");
+    line("  wrong thing for a magnet.");
+  } else {
+    line("  No segregation: the orientation correlation is unchanged, so the");
+    line("  orientation-dependent pull does not sort the population on this");
+    line("  geometry. The model then has no ordering mechanism at all without");
+    line("  feedback, and §1 is the whole story.");
+  }
+
+  line();
+  line("=".repeat(78));
+  line("5. WHAT THIS DOES TO THE LEDGER");
+  line("=".repeat(78));
+  line();
+  line("     WITHDRAWN   `exchange` §4's ferromagnet and hysteresis loop as");
+  line("                 statements about THIS model. The relaxation there");
+  line("                 minimises an energy the model does not have, using a");
+  line("                 dynamics it does not have. What those runs show is");
+  line("                 that IF axes relaxed to maximise meetings, the state");
+  line("                 would be uniform and would show hysteresis — which is");
+  line("                 a conditional worth keeping and is not a derivation.");
+  line();
+  line("     STANDS      the interaction itself. It converges, it is");
+  line("                 exchange-like under the line reading, and the line");
+  line("                 reading is the one that gives Newton. Every one of");
+  line("                 those is a fact about the meeting count and none of");
+  line("                 them needs a dynamics.");
+  line();
+  line("     AND THE REAL DEBT IS NAMED. Not 'is there an energy' but: WHAT");
+  line("     DOES A SOURCE DO ABOUT WHAT ARRIVES? The book has never needed an");
+  line("     answer, because gravity does not — a pull is a fact about the");
+  line("     space between two things. Every ordering result does need one,");
+  line("     and this is the first place the model has been asked a question");
+  line("     that requires the arrow to point the other way.");
+
+  return L.join("\n");
+}
+
+console.log(onewayReport());
+console.log(migrationReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/holonomy.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/holonomy.ts
new file mode 100644
index 0000000..d013dbb
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/holonomy.ts
@@ -0,0 +1,313 @@
+/**
+ * THE PHASE AROUND A LOOP — and whether a QUANTISED ring can have one.
+ *
+ * The Layer-2 arc's central positive result is that the complex structure is
+ * forced by closed loops: carry a strand around a plaquette in a texture whose
+ * north turns, and the azimuthal advances do not cancel. What is left is the
+ * solid angle the axis swept, it is gauge-invariant under any site-by-site
+ * redefinition of where azimuth zero sits, and that is Aharonov–Bohm as a
+ * lattice-counting fact.
+ *
+ * The continuum half of that is true and §1 reproduces it. §2 is the check the
+ * arc did not run, and it is the one that matters, because the SAME arc says
+ * the phase lives on an eight-member ring with a quantum of 45°:
+ *
+ *     a smooth texture advances the azimuth by ~1e−2 radians per step
+ *     the ring's smallest move is 45° = 7.85e−1 radians
+ *
+ * If the phase is genuinely ON the ring, every step rounds to no move at all
+ * and the holonomy is identically zero on every loop. The quantised ring and
+ * the continuous solid-angle flux cannot both be true, and the arc asserts
+ * both — the ring in its opening section and the flux four sections later.
+ *
+ * §3 is the third option, which does not appear in the arc and is the only one
+ * that keeps both: let the strand be a superposition over ring members, so the
+ * advance is an expectation rather than a snap.
+ */
+
+const CYCLE = 8;
+const SPIN = 2 * Math.PI / CYCLE;
+
+type V = [number, number, number];
+const add = (a: V, b: V): V => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+const mul = (a: V, s: number): V => [a[0] * s, a[1] * s, a[2] * s];
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross = (a: V, b: V): V =>
+  [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+
+/**
+ * A Layer-1 texture: a north that turns as you move. The amplitude is what
+ * makes it a texture rather than a uniform field; nothing here depends on the
+ * particular one beyond its being smooth.
+ */
+const TWIST = 0.35;
+const north = (x: number, y: number): V =>
+  unit([TWIST * Math.sin(0.5 * x), TWIST * Math.sin(0.5 * y), 1]);
+
+/** the minimal rotation taking a to b, applied to v — parallel transport */
+const transport = (a: V, b: V, v: V): V => {
+  const axis = cross(a, b), s = len(axis);
+  if (s < 1e-14) return v;
+  const k = mul(axis, 1 / s), c = dot(a, b), th = Math.atan2(s, c);
+  // Rodrigues
+  return add(add(mul(v, Math.cos(th)), mul(cross(k, v), Math.sin(th))),
+    mul(k, dot(k, v) * (1 - Math.cos(th))));
+};
+
+/** the signed angle a frame picks up going round a closed list of norths */
+const holonomy = (loop: V[]) => {
+  const n0 = loop[0];
+  const seed: V = Math.abs(n0[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+  const v0 = unit(cross(n0, seed));
+  let v = v0, n = n0;
+  for (let i = 1; i <= loop.length; i++) {
+    const m = loop[i % loop.length];
+    v = transport(n, m, v);
+    n = m;
+  }
+  return Math.atan2(dot(cross(v0, v), n0), dot(v0, v));
+};
+
+/** solid angle of the spherical polygon the loop traces, by fan triangulation */
+const solidAngle = (loop: V[]) => {
+  let total = 0;
+  for (let i = 1; i + 1 < loop.length; i++) {
+    const a = loop[0], b = loop[i], c = loop[i + 1];
+    const num = Math.abs(dot(a, cross(b, c)));
+    const den = 1 + dot(a, b) + dot(b, c) + dot(c, a);
+    let e = 2 * Math.atan2(num, den);
+    if (dot(a, cross(b, c)) < 0) e = -e;
+    total += e;
+  }
+  return total;
+};
+
+/** the corners of an n×n plaquette at (x,y), in order */
+const plaquette = (x: number, y: number, n: number): V[] => {
+  const pts: V[] = [];
+  for (let i = 0; i < n; i++) pts.push(north(x + i, y));
+  for (let i = 0; i < n; i++) pts.push(north(x + n, y + i));
+  for (let i = 0; i < n; i++) pts.push(north(x + n - i, y + n));
+  for (let i = 0; i < n; i++) pts.push(north(x, y + n - i));
+  return pts;
+};
+
+let seed = 20260815;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+
+export function holonomyReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("1. THE CONTINUUM HALF IS RIGHT: THE HOLONOMY IS THE SWEPT SOLID ANGLE");
+  line("=".repeat(78));
+  line();
+  line("     plaquette          transported     solid angle     difference");
+  const loops: [string, V[]][] = [
+    ["(0,0) 1×1", plaquette(0, 0, 1)],
+    ["(1.5,0.7) 1×1", plaquette(1.5, 0.7, 1)],
+    ["(0,0) 2×2", plaquette(0, 0, 2)],
+    ["(3,3) 1×1", plaquette(3, 3, 1)],
+  ];
+  for (const [name, lp] of loops) {
+    const h = holonomy(lp), s = solidAngle(lp);
+    line(`     ${name.padEnd(18)}${h.toExponential(3).padStart(12)}` +
+      `${s.toExponential(3).padStart(16)}${Math.abs(Math.abs(h) - Math.abs(s)).toExponential(1).padStart(15)}`);
+  }
+  line();
+  line("  Parallel transport of a frame vector round the loop picks up the");
+  line("  solid angle the north swept, which is the arc's claim and is a");
+  line("  textbook fact about a sphere. Nothing on the lattice is needed for");
+  line("  it — only that the axis turns.");
+  line();
+  line("  Note it gives Ω and not Ω/2. See §4.");
+  line();
+  line("  And it is gauge-invariant. Redefine where azimuth zero sits at every");
+  line("  site independently, by a random amount, and the loop is untouched:");
+  line();
+
+  // A gauge here is a choice of where azimuth zero sits at each site. Build
+  // the holonomy the way a lattice gauge theory does — sum the link advances,
+  // each measured between the two sites' OWN reference directions — and do it
+  // under random per-site choices. The φ(x) enter every link twice with
+  // opposite signs, so a closed loop cannot see them; an open path can.
+  const gaugedLoop = (lp: V[], phi: number[]) => {
+    const frame = (n: V, p: number): V => {
+      const s: V = Math.abs(n[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+      const e1 = unit(cross(n, s)), e2 = cross(n, e1);
+      return unit(add(mul(e1, Math.cos(p)), mul(e2, Math.sin(p))));
+    };
+    let total = 0;
+    for (let i = 0; i < lp.length; i++) {
+      const a = lp[i], b = lp[(i + 1) % lp.length];
+      const va = transport(a, b, frame(a, phi[i]));
+      const vb = frame(b, phi[(i + 1) % lp.length]);
+      total += Math.atan2(dot(cross(va, vb), b), dot(va, vb));
+    }
+    // each link is measured mod a turn, so the loop is too — wrap into (−π, π]
+    const wrapped = total - 2 * Math.PI * Math.round(total / (2 * Math.PI));
+    return wrapped;
+  };
+
+  let worst = 0, openSpread = 0;
+  for (const [, lp] of loops) {
+    const base = gaugedLoop(lp, new Array(lp.length).fill(0));
+    const opens: number[] = [];
+    for (let t = 0; t < 50; t++) {
+      const phi = lp.map(() => 2 * Math.PI * rnd());
+      worst = Math.max(worst, Math.abs(gaugedLoop(lp, phi) - base));
+      // the same sum along an OPEN path, which is the control: it must move
+      const a = lp[0], b = lp[1];
+      const fa = (() => { const s: V = Math.abs(a[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+        const e1 = unit(cross(a, s)), e2 = cross(a, e1);
+        return unit(add(mul(e1, Math.cos(phi[0])), mul(e2, Math.sin(phi[0])))); })();
+      const fb = (() => { const s: V = Math.abs(b[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+        const e1 = unit(cross(b, s)), e2 = cross(b, e1);
+        return unit(add(mul(e1, Math.cos(phi[1])), mul(e2, Math.sin(phi[1])))); })();
+      const va = transport(a, b, fa);
+      opens.push(Math.atan2(dot(cross(va, fb), b), dot(va, fb)));
+    }
+    openSpread = Math.max(openSpread, Math.max(...opens) - Math.min(...opens));
+  }
+  line(`     closed loop, 200 random site gauges: max deviation  ${worst.toExponential(1)}`);
+  line(`     one open link, the control:          spread         ${openSpread.toFixed(3)} rad`);
+  line();
+  line("  The loop does not move — up to whole turns, which is all a phase is");
+  line("  ever defined to — and a single link moves by the whole circle. That");
+  line("  is the distinction being claimed, measured rather than asserted.");
+  line();
+  line("  Which is the whole of why a phase around a loop is observable and a");
+  line("  phase at a point is not: the equator has no marked point on it, and");
+  line("  gauge invariance is that absence.");
+
+  line();
+  line("=".repeat(78));
+  line("2. AND A QUANTISED RING MAKES ALL OF IT IDENTICALLY ZERO");
+  line("=".repeat(78));
+  line();
+  line("  The arc's ring has CYCLE = 8 members, so the smallest move the phase");
+  line(`  can make is SPIN = ${SPIN.toFixed(4)} rad = 45°. What does a smooth`);
+  line("  texture actually ask of it per step?");
+  line();
+  line("     plaquette          advance per step (rad)     as a fraction of SPIN");
+  for (const [name, lp] of loops) {
+    let biggest = 0;
+    for (let i = 0; i < lp.length; i++) {
+      const a = lp[i], b = lp[(i + 1) % lp.length];
+      const seedv: V = Math.abs(a[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+      const v0 = unit(cross(a, seedv));
+      const v1 = transport(a, b, v0);
+      const s2: V = Math.abs(b[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+      const ref = unit(cross(b, s2));
+      biggest = Math.max(biggest,
+        Math.abs(Math.atan2(dot(cross(v1, ref), b), dot(v1, ref))));
+    }
+    line(`     ${name.padEnd(18)}${biggest.toExponential(3).padStart(18)}` +
+      `${(biggest / SPIN).toExponential(2).padStart(24)}`);
+  }
+  line();
+  line("  One to two orders of magnitude under one quantum. So if the phase");
+  line("  is ON the ring — an integer index k, moving by whole steps — every");
+  line("  advance rounds to nothing:");
+  line();
+  line("     plaquette          quantised holonomy    continuum holonomy");
+  for (const [name, lp] of loops) {
+    // the honest quantised transport: accumulate the index, snapping each step
+    let k = 0, resid = 0;
+    for (let i = 0; i < lp.length; i++) {
+      const a = lp[i], b = lp[(i + 1) % lp.length];
+      const seedv: V = Math.abs(a[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+      const v0 = unit(cross(a, seedv));
+      const v1 = transport(a, b, v0);
+      const s2: V = Math.abs(b[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+      const ref = unit(cross(b, s2));
+      const adv = Math.atan2(dot(cross(v1, ref), b), dot(v1, ref));
+      const steps = Math.round(adv / SPIN);
+      k += steps; resid += adv - steps * SPIN;
+    }
+    line(`     ${name.padEnd(18)}${(k * SPIN).toExponential(3).padStart(16)}` +
+      `${holonomy(lp).toExponential(3).padStart(22)}`);
+  }
+  line();
+  line("  Identically zero on every loop tested, and it is not a matter of");
+  line("  finding a texture that twists harder: a texture that advanced a whole");
+  line("  45° per lattice step would turn the north right over in eight cells,");
+  line("  which is not a texture, it is noise.");
+  line();
+  line("     SO THE ARC ASSERTS TWO THINGS THAT CANNOT BOTH HOLD.");
+  line();
+  line("     the ring       phase ∈ {0..7}, quantum 45°, a discrete U(1)");
+  line("     the flux       holonomy = swept solid angle, continuous, ~1e−2 rad");
+  line();
+  line("  Take the ring and there is no Aharonov–Bohm, no flux from any smooth");
+  line("  texture, and nothing for minimal coupling to couple to. Take the flux");
+  line("  and the phase is continuous, which is fine — but then it is not the");
+  line("  eight vacant directions, and the whole 'the lattice left exactly the");
+  line("  right amount of room for it' argument goes with it, because eight");
+  line("  directions is not a continuum.");
+
+  line();
+  line("=".repeat(78));
+  line("3. THE THIRD OPTION, WHICH THE ARC DOES NOT CONSIDER");
+  line("=".repeat(78));
+  line();
+  line("  Keep the ring and let the strand be a SUPERPOSITION over its members");
+  line("  rather than sitting on one. Then the advance is an expectation and");
+  line("  need not be a whole step: a distribution over the eight, rotated by");
+  line("  a small angle, is a nearby distribution over the eight.");
+  line();
+  line("     advance asked    ⟨k⟩ before    ⟨k⟩ after    realised advance");
+  for (const adv of [1e-4, 1e-2, 0.1, SPIN]) {
+    // a von-Mises-ish distribution on the ring, rotated
+    const w = (mu: number) => {
+      const p = Array.from({ length: CYCLE }, (_, k) => Math.exp(2 * Math.cos(k * SPIN - mu)));
+      const z = p.reduce((a, b) => a + b);
+      return p.map(v => v / z);
+    };
+    const ang = (p: number[]) => {
+      let c = 0, s = 0;
+      p.forEach((v, k) => { c += v * Math.cos(k * SPIN); s += v * Math.sin(k * SPIN); });
+      return Math.atan2(s, c);
+    };
+    const before = ang(w(0)), after = ang(w(adv));
+    line(`     ${adv.toExponential(1).padStart(12)}${before.toExponential(2).padStart(14)}` +
+      `${after.toExponential(2).padStart(13)}${(after - before).toExponential(3).padStart(20)}`);
+  }
+  line();
+  line("  The realised advance tracks the asked-for one down to 1e−4, so a");
+  line("  superposition on the eight-member ring carries a continuous phase");
+  line("  while the ring stays discrete. That is the ordinary relationship");
+  line("  between a finite basis and a continuous parameter, and it is what the");
+  line("  arc needs if it wants to keep both halves of what it has claimed.");
+  line();
+  line("  It is not free either: it makes the phase an amplitude over the eight");
+  line("  rather than a position among them, which is a bigger object than the");
+  line("  'one of eight vacant directions' the arc costed. Whether Layer 1 has");
+  line("  room for THAT is a different count and is not done here.");
+
+  line();
+  line("=".repeat(78));
+  line("4. AND Ω/2 AND g = 2 ARE ONE ASSUMPTION USED TWICE");
+  line("=".repeat(78));
+  line();
+  line("  §1 measures Ω. The arc's own table reports Φ = Ω/2 and calls the half");
+  line("  a flux normalisation; four sections later the same half reappears as");
+  line("  g = 2, presented as a consequence of the lattice's double cover — a");
+  line("  directed north returning after 8 steps where an undirected axis");
+  line("  returns after 4.");
+  line();
+  line("     THE HALF IS THE DOUBLE COVER. Writing Ω/2 in the flux table");
+  line("     already inserts the thing that g = 2 is then derived from.");
+  line();
+  line("  That is not a refutation of either. It is a statement that the book");
+  line("  is entitled to exactly one of them as an assumption and must get the");
+  line("  other as a result, and at the moment it takes both as given. Pick");
+  line("  which one is primitive.");
+
+  return L.join("\n");
+}
+
+console.log(holonomyReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts
index 83609ca..b29cf7a 100644
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/maxwell.ts
@@ -79,17 +79,37 @@ console.log();
 console.log("=".repeat(78));
 console.log("3. THE FULL AUDIT");
 console.log("=".repeat(78));
-type Row = [string, "derived" | "built in" | "not derived" | "REFUTED", string];
+type Row = [string, "derived" | "conditional" | "built in" | "not derived" | "REFUTED", string];
 const AUDIT: Row[] = [
   ["the 1/r²", "derived", "flux over a growing shell — see 1 above"],
   ["the sign law, for a bias", "derived", "(1 − P_a·P_b)/2 — `coulomb`"],
   ["two signs, and they cancel", "derived", "polarity is ±1 and sums"],
   ["the ± ledger balances", "derived", "BITE = 1 exists exactly for this"],
-  ["magnetisation is quantised", "derived", "dwell is a count of ticks — `scale`"],
-  ["∇·B = 0", "derived", "no way to be sided without two sides"],
+  ["the source rule, −div p", "derived", "what the annihilation ledger leaves — `escape` §1"],
+  ["magnetisation is quantised", "derived", "dwell is a count — but on a FACE axis; `ring`"],
+  ["∇·B = 0", "derived", "Σ(−div p) telescopes, for ANY p — `divp` §4"],
   ["no magnetic monopoles", "derived", "the same statement"],
   ["the lightest constituent wins", "derived", "µ/M ∝ 1/m² — `scale`"],
   ["densities superpose", "derived", "they simply add"],
+  ["a coupling between emitters", "derived", "1st moment of annihilation is odd — `response`"],
+  ["it acts on p, not on the sign", "derived", "a moment about an axis is a torque — `align`"],
+  ["a direction-independent sign", "derived", "the non-sided branch already — `aggregate` §3"],
+  ["REGIONAL SOURCING", "not derived", "strength = local −div p — `aggregate` §5"],
+  ["the dipole angular law", "conditional", "3cos²θ − 1 — given regional sourcing"],
+  ["dipole–dipole force, 1/R⁴", "conditional", "4.003 — given regional sourcing"],
+  ["all five orientations", "conditional", "incl. pole-to-pole — given regional sourcing"],
+  ["cutting a magnet halves it", "conditional", "net 0, exp 3.005 — given regional sourcing"],
+  ["far field needs only a NET p", "derived", "an integral functional — `texture` §1"],
+  ["the coupling is exchange-like", "derived", "no bond direction in it — `exchange` §3"],
+  ["orientation-dependent PULL", "derived", "aligned pairs annihilate, anti do not"],
+  ["order by MIGRATION", "derived", "like orientations cluster, ⟨cosΔ⟩ 0→0.89 — `feedback` §4"],
+  ["local order / ferromagnetism", "conditional", "uniform IF axes relaxed — they cannot; `feedback`"],
+  ["remanence / hysteresis", "conditional", "open loop, same condition — `exchange` §4"],
+  ["FEEDBACK ONTO A SOURCE", "not derived", "nothing writes to a source — `feedback` §1"],
+  ["it must act on the AXIS", "derived", "rate-feedback makes mass local — `permute` §2"],
+  ["ordering robust to which rule", "derived", "3 unrelated reads, same ferro — `permute` §3"],
+  ["the sign of the coupling", "not derived", "one bit, owed to gravity — `response` §3"],
+  ["a domain SIZE", "REFUTED", "λ/2 is 10⁻¹⁹ m vs 10⁻⁵ m — `domainsize`"],
   ["Gauss, ∇·E = ρ/ε₀", "not derived", "the SHAPE is; there is no charge here"],
   ["electric charge at all", "not derived", "P is not charge — `coulomb` §4"],
   ["charge quantisation", "not derived", "needs matter to say what is held"],
@@ -102,30 +122,66 @@ const AUDIT: Row[] = [
   ["Lorentz force qv×B", "not derived", "nothing deflects a moving charge"],
   ["transverse polarisation", "not derived", "emission is a scalar sign"],
   ["gauge invariance", "not derived", "there are no potentials to be free of"],
-  ["the dipole angular law", "derived", "3cos²θ − 1 to 3 dp — `poles`"],
-  ["dipole–dipole force, 1/R⁴", "derived", "slope −2.00 on gravity's 1/R² — `poles`"],
-  ["all five orientations", "derived", "including pole-to-pole — `poles`"],
-  ["cutting a magnet halves it", "derived", "the sign is a region's boundary"],
   ["the magnetic coupling", "not derived", "√(µ0/4πG)·M kg/m² — measured — `budget`"],
   ["force linear in the field", "REFUTED", "it is bilinear — meetings, not fields"],
-  ["g = 2", "REFUTED", "µ/L = q/2m with r cancelling, so g = 1"],
-  ["magnetocrystalline anisotropy", "REFUTED", "predicts ⟨111⟩ by 11.1% everywhere"],
+  ["g = 2", "REFUTED", "g = 1; Layer 2 offers a route, tangled with Ω/2"],
+  ["magnetocrystalline anisotropy", "REFUTED", "11.1% — but computed on ⟨111⟩ with CYCLE=8"],
 ];
+
 const tally: Record<string, number> = {};
 for (const [what, how, why] of AUDIT) {
   tally[how] = (tally[how] ?? 0) + 1;
-  console.log(`   ${how === "REFUTED" ? "✗" : how === "derived" ? "✓" : "·"} ` +
+  console.log(`   ${how === "REFUTED" ? "✗" : how === "derived" ? "✓" : how === "conditional" ? "~" : "·"} ` +
     `${what.padEnd(32)} ${how.padEnd(12)} ${why}`);
 }
 console.log();
-for (const k of ["derived", "built in", "not derived", "REFUTED"])
+for (const k of ["derived", "conditional", "built in", "not derived", "REFUTED"])
   console.log(`      ${k.padEnd(14)} ${String(tally[k] ?? 0).padStart(3)}`);
 console.log(`      ${"TOTAL".padEnd(14)} ${String(AUDIT.length).padStart(3)}`);
 
 console.log();
 console.log("=".repeat(78));
-console.log("4. AND WHAT IS LEFT MISSING IS ONE THING, ON THE ELECTRIC SIDE");
+console.log("4. TWO THINGS ARE MISSING, AND ONLY ONE IS ON THE ELECTRIC SIDE");
 console.log("=".repeat(78));
+console.log("   FIRST, ON THE MAGNETIC SIDE, and it is one row: REGIONAL");
+console.log("   SOURCING. `escape` derives the source density −div p from the");
+console.log("   annihilation ledger exactly. What is not shown is that a region");
+console.log("   then RE-EMITS its unpaired excess as its own source, rather than");
+console.log("   the excess simply being what escaped along the bonds it escaped");
+console.log("   on. The four CONDITIONAL rows above rest on that one sentence.");
+console.log();
+console.log("   Two things this is NOT, both of which earlier drafts got wrong.");
+console.log("   It is not 'isotropic emission' — a pulse goes one way, and a");
+console.log("   direction-independent SIGN is the non-sided branch the model has");
+console.log("   had all along. And it cannot be supplied by scattering: the");
+console.log("   inverse-square law IS ballistic shell dilution, so a diffusing");
+console.log("   emission would give 1/r and take gravity with it (`aggregate`).");
+console.log();
+console.log("   What it IS: the Layer-2 arc's regional-sourcing assumption,");
+console.log("   already written down to pay a bound-state debt in the quantum");
+console.log("   arc. Two arcs, one sentence — which is what makes it a");
+console.log("   hypothesis worth testing rather than a patch.");
+console.log();
+console.log("   AND SEPARATELY, THE DEEPER ONE: THE MODEL IS ONE-WAY. A source's");
+console.log("   state is a pure function of its own parameters and the tick —");
+console.log("   `bearing(s,tick) = phase + tick·rate(s)/CYCLE` — and nothing in");
+console.log("   `physics.ts` or `gravity.ts` ever writes to a source. Sources");
+console.log("   write to space; space never writes back.");
+console.log();
+console.log("   Gravity never needed it: a pull is a fact about the space between");
+console.log("   two things, not about either of them changing. EVERY ORDERING");
+console.log("   RESULT NEEDS IT, and this is the first question the book has been");
+console.log("   asked that requires the arrow to point the other way. `response`");
+console.log("   and `exchange` stop at the same wall from two sides — one asking");
+console.log("   what an arriving pulse does to a beat, the other what it does to");
+console.log("   an axis.");
+console.log();
+console.log("   What the model DOES own without feedback is an orientation-");
+console.log("   dependent PULL, and `feedback` §4 shows that alone segregates a");
+console.log("   mobile population by orientation — order by migration rather than");
+console.log("   by rotation. Real, and the wrong kind of order for a magnet.");
+console.log();
+console.log("   SECOND, ON THE ELECTRIC SIDE, which is the older gap.");
 console.log("   Read the REFUTED and the not-derived rows together and they say");
 console.log("   the same sentence. Every one of them needs a FIELD — something");
 console.log("   that exists between the sources, carries its own state, obeys its");
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/permute.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/permute.ts
new file mode 100644
index 0000000..49075c1
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/permute.ts
@@ -0,0 +1,289 @@
+/**
+ * WHAT COULD THE MISSING FEEDBACK BE — a search over the rules that would let
+ * space write back to a source.
+ *
+ * `feedback` establishes that nothing in the model writes to a source, and that
+ * every ordering result needs something to. This file enumerates what such a
+ * rule could be and puts each candidate to the same four tests.
+ *
+ * THE SPACE OF RULES is a product. A feedback rule reads something local and
+ * changes something about the source:
+ *
+ *   READ                                      ACT
+ *     the arriving polarity, as a SCALAR        turn the axis towards it
+ *     the arriving polarity, as a VECTOR        turn the axis away from it
+ *     the annihilation rate, as a SCALAR        change the beat (the mass)
+ *     the annihilation asymmetry, as a VECTOR   shift the phase
+ *
+ * Only some pairings are dimensionally sensible — a scalar cannot say which way
+ * to turn, a vector is the wrong shape to add to a rate — which cuts the grid
+ * down before any measuring starts. Then:
+ *
+ *   TEST 1  does it break gravity? The rate IS the mass, so anything that
+ *           writes to a rate makes mass depend on the neighbourhood.
+ *   TEST 2  can it lock at all? `response` showed an even coupling cannot.
+ *   TEST 3  what does it order INTO — ferromagnetic or antiferromagnetic?
+ *   TEST 4  does it need a new constant?
+ */
+
+const TAU = Math.PI * 2;
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+
+const WAYS: V[] = (() => {
+  const out: V[] = [];
+  for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++)
+    if (x || y || z) out.push([x, y, z]);
+  return out;
+})();
+const UWAYS = WAYS.map(unit);
+
+let seed = 20260816;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+const reseed = () => { seed = 20260816; };
+
+const RING = 8;
+const ax = (k: number): V => [Math.cos(TAU * k / RING), Math.sin(TAU * k / RING), 0];
+
+/** the sign a sided source with axis p puts into the exit nearest to û */
+const emitted = (p: V, u: V) => {
+  let best = 0, bd = -2;
+  for (let i = 0; i < UWAYS.length; i++) { const c = dot(UWAYS[i], u); if (c > bd) { bd = c; best = i; } }
+  const s = dot(p, UWAYS[best]);
+  return Math.abs(s) < 1e-9 ? 0 : s > 0 ? 1 : -1;
+};
+
+/** `exchange`'s line reading: do a pair annihilate on the segment between them */
+const couples = (pa: V, pb: V, bhat: V) => {
+  const sa = emitted(pa, bhat), sb = emitted(pb, bhat);
+  if (sa === 0 || sb === 0) return 0;
+  return sa === sb ? 1 : 0;
+};
+
+const cube = (L: number): V[] => {
+  const out: V[] = [];
+  const h = (L - 1) / 2;
+  for (let i = 0; i < L; i++) for (let j = 0; j < L; j++) for (let k = 0; k < L; k++)
+    out.push([i - h, j - h, k - h]);
+  return out;
+};
+
+// ─── the candidates, as a score over the axis a source could take ──────────
+//
+// A feedback rule has to be written as "what would this orientation get me",
+// evaluated for each candidate axis — not as a vector computed from the
+// CURRENT axis and then maximised against. The second form is what a first
+// draft of this file did, and for any read that depends on the source's own
+// orientation it is simply wrong.
+
+type Score = (cand: V, i: number, at: V[], k: number[]) => number;
+
+/** the net signed pulse arriving at i, projected on a candidate axis */
+const arrivingFlux: Score = (cand, i, at, k) => {
+  let acc = 0;
+  for (let j = 0; j < at.length; j++) {
+    if (i === j) continue;
+    const d = sub(at[i], at[j]), r = len(d);
+    if (r < 1e-9) continue;
+    const u = unit(d);                          // the way j's pulse is travelling
+    acc += emitted(ax(k[j]), u) * dot(cand, u) / (r * r);
+  }
+  return acc;
+};
+
+/** how much of i's emission gets annihilated, if i took the candidate axis */
+const destroyed: Score = (cand, i, at, k) => {
+  let acc = 0;
+  for (let j = 0; j < at.length; j++) {
+    if (i === j) continue;
+    const d = sub(at[j], at[i]), r = len(d);
+    if (r < 1e-9) continue;
+    acc += couples(cand, ax(k[j]), unit(d)) / (r * r);
+  }
+  return acc;
+};
+
+/** the signed tally at i — `departure`'s quantity — projected on a candidate */
+const tallyAgree: Score = (cand, i, at, k) => {
+  let acc = 0;
+  for (let j = 0; j < at.length; j++) {
+    if (i === j) continue;
+    const d = sub(at[i], at[j]), r = len(d);
+    if (r < 1e-9) continue;
+    acc += emitted(ax(k[j]), unit(d)) * emitted(cand, unit(d)) / (r * r);
+  }
+  return acc;
+};
+
+type Rule = { name: string; score: Score; act: "max" | "min"; note: string };
+
+const RULES: Rule[] = [
+  { name: "axis → with arriving flux", score: arrivingFlux, act: "max",
+    note: "point the way the net signed pulse is going" },
+  { name: "axis → against arriving flux", score: arrivingFlux, act: "min",
+    note: "the same read, opposite sign" },
+  { name: "axis → most of it destroyed", score: destroyed, act: "max",
+    note: "turn to face where the emission is eaten" },
+  { name: "axis → least of it destroyed", score: destroyed, act: "min",
+    note: "turn to keep the emission" },
+  { name: "axis → agree with neighbours", score: tallyAgree, act: "max",
+    note: "match the sign the neighbourhood is putting out" },
+  { name: "axis → disagree", score: tallyAgree, act: "min",
+    note: "and the opposite of that" },
+];
+
+
+/** iterate a rule to a fixed point on a block, from random axes */
+const settle = (rule: Rule, at: V[], steps = 300) => {
+  const k = at.map(() => Math.floor(rnd() * RING));
+  for (let t = 0; t < steps; t++) {
+    let moved = 0;
+    for (let i = 0; i < at.length; i++) {
+      let best = k[i], bd = rule.act === "max" ? -Infinity : Infinity;
+      for (let c = 0; c < RING; c++) {
+        const v = rule.score(ax(c), i, at, k);
+        if (rule.act === "max" ? v > bd : v < bd) { bd = v; best = c; }
+      }
+      if (best !== k[i]) { k[i] = best; moved++; }
+    }
+    if (!moved) break;
+  }
+  let c = 0, s = 0, ca = 0, sa = 0;
+  at.forEach((p, i) => {
+    const sign = ((Math.round(p[0]) + Math.round(p[1]) + Math.round(p[2])) % 2 + 2) % 2 ? -1 : 1;
+    c += Math.cos(TAU * k[i] / RING); s += Math.sin(TAU * k[i] / RING);
+    ca += sign * Math.cos(TAU * k[i] / RING); sa += sign * Math.sin(TAU * k[i] / RING);
+  });
+  const n = at.length;
+  return { ferro: Math.hypot(c, s) / n, anti: Math.hypot(ca, sa) / n };
+};
+
+export function permuteReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("1. THE GRID, AND WHAT DIMENSION ALONE REMOVES FROM IT");
+  line("=".repeat(78));
+  line();
+  line("     READ                              ACT");
+  line("     arriving polarity, SCALAR         turn the axis  ✗  a scalar cannot");
+  line("                                                          say which way");
+  line("     arriving polarity, SCALAR         change the beat ✓");
+  line("     arriving polarity, SCALAR         shift the phase ✓  = `response`");
+  line("     arriving polarity, VECTOR         turn the axis  ✓");
+  line("     arriving polarity, VECTOR         change the beat ✗  wrong shape");
+  line("     destruction rate, SCALAR          change the beat ✓");
+  line("     destruction rate, SCALAR          turn the axis  ✗  same as above");
+  line("     destruction asymmetry, VECTOR     turn the axis  ✓");
+  line();
+  line("  Four survive as sensible. Two of them write to a BEAT and two to an");
+  line("  AXIS, and that split turns out to decide everything.");
+
+  line();
+  line("=".repeat(78));
+  line("2. TEST 1 KILLS EVERY RULE THAT WRITES TO A BEAT");
+  line("=".repeat(78));
+  line();
+  line("  Because in this model the beat IS the mass — `beat = 1/mass`, and the");
+  line("  gravity arc counts nothing about a source except how often it lets");
+  line("  go. So a rule that changes a source's rate in response to its");
+  line("  surroundings makes MASS DEPEND ON THE NEIGHBOURHOOD.");
+  line();
+  line("     · two identical bodies would weigh differently near a magnet");
+  line("     · G would not be a constant, it would be a field");
+  line("     · and the equivalence principle goes, since inertial mass would");
+  line("       track local emission and gravitational mass would too, but the");
+  line("       measured ratio would depend on where you stood");
+  line();
+  line("  There is no small version of this either: the whole point of the");
+  line("  ordering is that the feedback is strong enough to lock 10²³ emitters,");
+  line("  and a mass perturbation that large is ruled out by roughly every");
+  line("  measurement ever made. `response`'s phase route escapes it — a phase");
+  line("  shift is not a rate change — but a phase shift cannot turn an axis,");
+  line("  and the axis is what magnetism needs.");
+  line();
+  line("     SO THE FEEDBACK MUST WRITE TO THE AXIS, AND NOT TO THE RATE.");
+  line("     That is a real narrowing and it comes for free.");
+
+  line();
+  line("=".repeat(78));
+  line("3. THE AXIS RULES, MEASURED");
+  line("=".repeat(78));
+  line();
+  line("  Each rule iterated to a fixed point on a 5³ block from random axes.");
+  line("  `ferro` is |⟨p̂⟩|; `anti` is the same on a two-sublattice");
+  line("  checkerboard, so a large `anti` with a small `ferro` is an");
+  line("  antiferromagnet.");
+  line();
+  line("     rule                              ferro     anti     settles into");
+  const at = cube(5);
+  for (const rule of RULES) {
+    reseed();
+    const r = settle(rule, at);
+    const what = r.ferro > 0.9 ? "FERROMAGNET"
+      : r.anti > 0.9 ? "antiferromagnet"
+      : r.ferro > 0.5 ? "partly ferro"
+      : r.anti > 0.5 ? "partly anti" : "no order";
+    line(`     ${rule.name.padEnd(34)}${r.ferro.toFixed(3).padStart(6)}` +
+      `${r.anti.toFixed(3).padStart(9)}     ${what}`);
+  }
+  line();
+  line("  THREE DIFFERENT READS, AND ALL THREE GIVE A FERROMAGNET — as long as");
+  line("  the sign is the aligning one. And the three opposite-sign rules do not");
+  line("  give an antiferromagnet, they give nothing: frustrated, order");
+  line("  parameters at the noise floor on both sublattices.");
+  line();
+  line("  Which is the most useful thing in this file. The ordering does NOT");
+  line("  depend on which read the feedback uses — the net arriving flux, the");
+  line("  fraction of a source's own emission that gets eaten, and plain");
+  line("  agreement with the neighbourhood all land in the same place. So the");
+  line("  model does not owe a particular rule. IT OWES ONE BIT: that the");
+  line("  feedback exists, acts on the axis, and has the aligning sign.");
+  line();
+  line("  And that bit is the same one `response` §3 ends on, asked of the beat");
+  line("  instead of the axis — whether a source turns towards what is");
+  line("  happening to it or away. One bit, twice.");
+
+  line();
+  line("=".repeat(78));
+  line("4. WHAT THE SEARCH ACTUALLY SETTLES");
+  line("=".repeat(78));
+  line();
+  line("     NARROWED, and for a reason rather than by taste:");
+  line("       the feedback writes to the AXIS. Rate-feedback is excluded by");
+  line("       gravity outright, and phase-feedback cannot turn an axis.");
+  line();
+  line("     ROBUST, which was not expected:");
+  line("       WHICH axis rule does not matter. Three unrelated reads give the");
+  line("       same ferromagnet, so the result is not a fit to a rule chosen");
+  line("       for it — that was the worry, and the measurement answers it.");
+  line();
+  line("     NOT SETTLED:");
+  line("       the SIGN. Aligning gives a ferromagnet, opposing gives nothing,");
+  line("       and the model says neither. It is one bit and it is the same bit");
+  line("       `response` owes for the beat.");
+  line();
+  line("  AND FEEDBACK ALONE WOULD NOT FINISH MAGNETISM. Even with the right");
+  line("  rule in hand the ledger still owes:");
+  line();
+  line("     · REGIONAL SOURCING — that a region re-emits its unpaired excess,");
+  line("       which is what stands between −div p and the far field");
+  line("     · THE COUPLING — 4.5·10⁷ kg/m² of pole face, measured not counted,");
+  line("       and α with it");
+  line("     · THE RING FORK — continuous phase or quantised ring, which the");
+  line("       magnetisation quantum depends on");
+  line("     · g = 2 and the ⟨111⟩ anisotropy, both still refuted");
+  line();
+  line("  So the answer to 'would feedback make it accurate' is no. It would");
+  line("  make the ORDERING derivable, which is one row of four in the magnetic");
+  line("  half and none of the electric one.");
+
+  return L.join("\n");
+}
+
+console.log(permuteReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/response.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/response.ts
new file mode 100644
index 0000000..d272644
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/response.ts
@@ -0,0 +1,248 @@
+/**
+ * IS THERE ANYTHING IN THIS MODEL THAT MAKES ONE EMITTER LISTEN TO ANOTHER?
+ *
+ * `domains` derives a Kuramoto coupling from two ingredients: the emitted sign
+ * is cos(2πβ), and "the receiver's rotation responds to what arrives". The
+ * first is in `physics.ts`. THE SECOND IS NOT — `rate(s)` reads `s.turning`,
+ * `s.flips` and nothing else, so as the model stands an emitter's beat is a
+ * property of the emitter and no arriving pulse can touch it. The whole
+ * ordering mechanism, and the domain result with it, rests on a sensitivity
+ * that has to be either derived or admitted.
+ *
+ * This file asks whether it can be derived, and the answer is a qualified yes
+ * with one sign left undetermined.
+ *
+ *   §1  The obvious candidate fails, and fails structurally. What the model
+ *       already has is ANNIHILATION, and the annihilation count between two
+ *       emitters is EVEN in their phase difference. An even coupling cannot
+ *       lock anything: it has no way to tell ahead from behind.
+ *
+ *   §2  But annihilation happens SOMEWHERE, and a turning source that loses
+ *       space asymmetrically about its own axis is being pushed round. The
+ *       first moment of the annihilation density is ODD — exactly, at every
+ *       phase difference — with no cosine component and no mean. It is a
+ *       coarse staircase rather than a smooth sine, but its symmetry is the
+ *       part that matters, and its lowest harmonic is sin(2πΔβ): the Kuramoto
+ *       coupling, out of rule (G/1) rather than assumed.
+ *
+ *   §3  What that fixes and what it does not.
+ */
+
+const TAU = Math.PI * 2;
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const sgn = (x: number) => (Math.abs(x) < 1e-9 ? 0 : x > 0 ? 1 : -1);
+
+/** an axis turning in the xy-plane, at phase β in turns */
+const axis = (b: number): V => [Math.cos(TAU * b), Math.sin(TAU * b), 0];
+
+/** the cells around a point, out to a radius, excluding the point itself */
+const around = (c: V, R: number): V[] => {
+  const out: V[] = [];
+  const r = Math.ceil(R);
+  for (let x = -r; x <= r; x++) for (let y = -r; y <= r; y++) for (let z = -r; z <= r; z++) {
+    const p: V = [c[0] + x, c[1] + y, c[2] + z];
+    const d = Math.hypot(x, y, z);
+    if (d > 0.5 && d <= R) out.push(p);
+  }
+  return out;
+};
+
+const SEP = 8;
+const N_AT: V = [0, 0, 0], M_AT: V = [SEP, 0, 0];
+const NEAR = around(N_AT, 4);
+
+/**
+ * What the two emitters do to the space around n, at one instant.
+ *
+ * Both are sided sources: each puts sgn(axis·d) into the direction d. Where the
+ * two disagree, they annihilate — rule (G/1) with the signs kept, which is the
+ * same event `poles`, `ordering` and `escape` all use.
+ *
+ * Returns the annihilation count, and its first moment about n measured in the
+ * plane the axis turns in: the LEVER is the signed sine of the angle from n's
+ * own axis to the cell, so a positive moment means space is being destroyed
+ * ahead of where n is pointing.
+ */
+const encounter = (bn: number, bm: number) => {
+  const an = axis(bn), am = axis(bm);
+  let count = 0, moment = 0;
+  for (const y of NEAR) {
+    const dn = unit(sub(y, N_AT)), dm = unit(sub(y, M_AT));
+    const sn = sgn(dot(an, dn)), sm = sgn(dot(am, dm));
+    if (sn === 0 || sm === 0 || sn === sm) continue;
+    // weight by how much of m's pulse actually reaches here: 1/r²
+    const w = 1 / (len(sub(y, M_AT)) ** 2);
+    count += w;
+    // signed sine of the angle from n's axis to this direction, in the xy-plane
+    moment += w * (an[0] * dn[1] - an[1] * dn[0]);
+  }
+  return { count, moment };
+};
+
+/** least-squares amplitude of sin(2πΔ) and cos(2πΔ) in a sampled function */
+const harmonics = (f: (d: number) => number, n = 720) => {
+  let s = 0, c = 0, mean = 0;
+  for (let i = 0; i < n; i++) {
+    const d = i / n, v = f(d);
+    mean += v / n;
+    s += 2 * v * Math.sin(TAU * d) / n;
+    c += 2 * v * Math.cos(TAU * d) / n;
+  }
+  return { mean, sin: s, cos: c };
+};
+
+let seed = 20260815;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+const reseed = () => { seed = 20260815; };
+
+/** the Kuramoto run of `domains`, with an arbitrary coupling shape */
+const lock = (N: number, K: number, shape: (d: number) => number, steps = 4000, dt = 0.01) => {
+  const b = Array.from({ length: N }, () => rnd());
+  const w = Array.from({ length: N }, () => 1 + 0.1 * (2 * rnd() - 1));
+  for (let t = 0; t < steps; t++) {
+    const db = new Array(N).fill(0);
+    for (let i = 0; i < N; i++) {
+      let drive = 0;
+      for (let j = 0; j < N; j++) if (i !== j) drive += shape(b[j] - b[i]);
+      db[i] = w[i] + (K / N) * drive;
+    }
+    for (let i = 0; i < N; i++) b[i] = (b[i] + dt * db[i]) % 1;
+  }
+  let c = 0, s = 0;
+  for (const x of b) { c += Math.cos(TAU * x); s += Math.sin(TAU * x); }
+  return Math.hypot(c, s) / N;
+};
+
+export function responseReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("1. THE MODEL HAS NO RATE RESPONSE, AND THE OBVIOUS ONE WOULD NOT WORK");
+  line("=".repeat(78));
+  line();
+  line("  `rate(s)` in physics.ts reads s.turning, s.flips, and nothing else.");
+  line("  No arriving pulse enters it. So `domains` assumed something the model");
+  line("  does not have — the question is whether the model can be made to");
+  line("  supply it without a new rule.");
+  line();
+  line("  The one thing that DOES happen when a pulse arrives is annihilation.");
+  line("  So measure it: two sided emitters, the count of annihilations near");
+  line("  the first, against the phase difference.");
+  line();
+  line("     Δβ        annihilation count near n");
+  for (const d of [0, 0.0625, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875]) {
+    const a = encounter(0, d), b = encounter(0, -d);
+    line(`     ${d.toFixed(3)}    ${a.count.toFixed(6).padStart(12)}` +
+      `      (at −Δβ: ${b.count.toFixed(6)})`);
+  }
+  const hc = harmonics(d => encounter(0, d).count);
+  line();
+  line(`     sin component of the count   ${hc.sin.toExponential(2)}`);
+  line(`     cos component of the count   ${hc.cos.toExponential(2)}`);
+  line();
+  line("  THE COUNT IS EVEN. It is the same at +Δβ and at −Δβ to every digit,");
+  line("  and its sine component is nought. That is fatal on its own terms:");
+  line("  an even coupling cannot tell ahead from behind, so it cannot pull a");
+  line("  laggard forward and a leader back, so it cannot lock. Measured:");
+  line();
+  line("     coupling shape                    4000      16000     64000 ticks");
+  for (const [nm, sh] of [["even, ∝ (1 − cos 2πΔβ)/2", (d: number) => (1 - Math.cos(TAU * d)) / 2],
+                          ["odd,  ∝ sin 2πΔβ", (d: number) => Math.sin(TAU * d)]] as [string, (d: number) => number][]) {
+    const os: string[] = [];
+    for (const st of [4000, 16000, 64000]) { reseed(); os.push(lock(64, 2, sh, st).toFixed(4)); }
+    line(`     ${nm.padEnd(32)}${os.join("    ")}`);
+  }
+  line();
+  line("  The odd coupling locks and stays locked. The even one drifts — it is");
+  line("  not nought, because a non-negative drive that is larger when out of");
+  line("  phase does bunch things somewhat, but it does not settle and it does");
+  line("  not approach one. So 'annihilation changes the rate' is not enough,");
+  line("  however true: the response has to know WHICH WAY, and a count does");
+  line("  not.");
+
+  line();
+  line("=".repeat(78));
+  line("2. BUT ANNIHILATION HAPPENS SOMEWHERE, AND THE PLACE IS ODD");
+  line("=".repeat(78));
+  line();
+  line("  A count throws away the one thing rule (G/1) actually produces, which");
+  line("  is a LOCATION. Space is destroyed at particular cells, and a source");
+  line("  with an axis has a front and a back. If more space goes ahead of");
+  line("  where n is pointing than behind it, n is being pushed round — and");
+  line("  that is a rate response with a direction in it, out of the rule the");
+  line("  model already has.");
+  line();
+  line("  The first moment of the annihilation density about n, in the plane");
+  line("  its axis turns in:");
+  line();
+  line("     Δβ         moment          at −Δβ        sum (0 if odd)");
+  for (const d of [0.05, 0.125, 0.1875, 0.25, 0.3125, 0.375, 0.5]) {
+    const a = encounter(0, d).moment, b = encounter(0, -d).moment;
+    line(`     ${d.toFixed(3)}   ${a.toExponential(3).padStart(12)}   ${b.toExponential(3).padStart(12)}` +
+      `   ${(a + b).toExponential(1).padStart(12)}`);
+  }
+  const hm = harmonics(d => encounter(0, d).moment);
+  line();
+  line(`     mean                        ${hm.mean.toExponential(2)}`);
+  line(`     sin component               ${hm.sin.toExponential(3)}`);
+  line(`     cos component               ${hm.cos.toExponential(2)}`);
+  line(`     |cos| / |sin|               ${Math.abs(hm.cos / hm.sin).toExponential(2)}`);
+  line();
+  line("  ODD — exactly, at every Δβ, to 10⁻¹⁷ — and with no cosine component");
+  line("  and no mean. Note what it is NOT: it is not a smooth sine. The signs");
+  line("  are sgn(axis·d) over 26 directions, so the moment is a staircase that");
+  line("  only moves when the axis crosses onto a new set of exits, and most");
+  line("  of the samples above sit on a flat. What survives the coarseness is");
+  line("  the symmetry, and the symmetry is the whole of what matters here:");
+  line("  the lowest harmonic of an odd staircase is a sine, and an odd");
+  line("  coupling locks whatever else is riding on it.");
+  line();
+  line("     drive on n from m  ∝  sin(2π(βₘ − βₙ))/r²");
+  line();
+  line("  WHICH IS THE COUPLING `domains` ASSUMED, derived from rule (G/1)");
+  line("  instead. The harmonic expansion and the product-to-sum step in that");
+  line("  file are not needed — the lattice hands over the odd first harmonic");
+  line("  directly, because annihilation has a place and an axis has a side.");
+  line();
+  line("  And the 1/r² is not put in either: it is the weight with which m's");
+  line("  pulses arrive, which is `chance` and is the same 1/r² as everything");
+  line("  else in the book.");
+
+  line();
+  line("=".repeat(78));
+  line("3. WHAT IS FIXED, AND THE ONE THING THAT IS NOT");
+  line("=".repeat(78));
+  line();
+  line("     FIXED    that there is a rate response at all, and that it is odd");
+  line("              in the phase difference. Both come out of annihilation");
+  line("              having a location. `domains` no longer assumes its");
+  line("              coupling; it measures a consequence of (G/1).");
+  line();
+  line("     NOT FIXED THE SIGN. The moment says space is destroyed");
+  line("              preferentially on one side of n. It does NOT say whether");
+  line("              losing space ahead of you speeds you up or slows you");
+  line("              down — that is a statement about how a source's beat");
+  line("              depends on the space around it, and the book does not");
+  line("              have one. K > 0 locks, K < 0 scatters, and the sign of K");
+  line("              is exactly this unknown.");
+  line();
+  line("  Which is a much smaller debt than the one it replaces, and a much");
+  line("  sharper one: not 'is there a coupling' but 'does an emitter run fast");
+  line("  or slow in shortened space'. The gravity arc is the natural place for");
+  line("  it — it is the arc that says what annihilated space does to an");
+  line("  interval — and it is one sign, not a mechanism.");
+  line();
+  line("     AND IT IS THE WHOLE OF WHETHER MATTER IS FERROMAGNETIC. One sign,");
+  line("     one bit, and it decides whether a lump of aligned emitters holds");
+  line("     together or scatters.");
+
+  return L.join("\n");
+}
+
+console.log(responseReport());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ring.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ring.ts
new file mode 100644
index 0000000..7521cd7
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/ring.ts
@@ -0,0 +1,193 @@
+/**
+ * IS THE EQUATOR A RING — and for which norths?
+ *
+ * The Layer-2 arc is built on one geometric claim: sort the DEG = 26 ways out
+ * of a cell by which side of a local north they fall on, and the ones left
+ * over — the equator — "close into a single ring at forty-five degrees a
+ * step, which is CYCLE = 8 and SPIN = 2π/CYCLE".
+ *
+ * That is the whole foundation. The charge is the sign along the axis, the
+ * phase is the position around the ring, and the phase is a genuine U(1) only
+ * if the ring is uniform. `lattice.ts` does have a CYCLE = 8, but it is
+ * `turnRing`'s — eight in-plane directions of a PLANE — and a plane is not an
+ * equator. They coincide for one class of axis and the arc does not say which.
+ *
+ * So: take every north the lattice has, cut the equator, sort it by angle, and
+ * look at the spacing. And then ask the same question of every dimension,
+ * since a ring with nothing on it is a phase with nowhere to live.
+ */
+
+const DIMS = 3;
+const SHEET = Math.pow(3, DIMS - 1) - 1, DEG = Math.pow(3, DIMS) - 1;
+
+type V = number[];
+const dot = (a: V, b: V) => a.reduce((s, x, i) => s + x * (b[i] || 0), 0);
+const norm = (a: V) => Math.hypot(...a);
+const unit = (a: V): V => { const l = norm(a) || 1; return a.map(x => x / l); };
+const cross = (a: V, b: V): V =>
+  [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+
+/** every way out of a point in d dimensions: 3^d − 1 offsets in {−1,0,1} */
+const directions = (d: number): V[] => {
+  const out: V[] = [];
+  (function build(p: V) {
+    if (p.length === d) { if (p.some(v => v !== 0)) out.push(p); return; }
+    for (const v of [-1, 0, 1]) build([...p, v]);
+  })([]);
+  return out;
+};
+
+const WAYS = directions(3);
+
+/**
+ * The equator of an axis: the directions with no component along it. "No
+ * component" is exact here — a lattice direction either has a zero dot with
+ * the axis or it does not, and nothing is near the line.
+ */
+const equator = (axis: V) => WAYS.filter(w => Math.abs(dot(unit(w), unit(axis))) < 1e-12);
+
+/** the equator sorted by azimuth, and the gaps between consecutive members */
+const ring = (axis: V) => {
+  const n = unit(axis);
+  // any two directions spanning the plane, to measure azimuth against
+  const seed = Math.abs(n[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+  const e1 = unit(cross(n, seed)), e2 = cross(n, e1);
+  const members = equator(axis).map(w => {
+    const u = unit(w);
+    return { w, u, a: Math.atan2(dot(u, e2), dot(u, e1)) };
+  }).sort((p, q) => p.a - q.a);
+  const gaps: number[] = [];
+  for (let i = 0; i < members.length; i++) {
+    const j = (i + 1) % members.length;
+    let g = members[j].a - members[i].a;
+    if (g <= 0) g += 2 * Math.PI;
+    gaps.push(g * 180 / Math.PI);
+  }
+  return { members, gaps };
+};
+
+const CLASS = (v: V) => {
+  const n = v.filter(x => x !== 0).length;
+  return n === 1 ? "face" : n === 2 ? "edge" : "corner";
+};
+
+export function ringReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("THE EQUATOR IS A UNIFORM RING FOR 14 OF THE 26 NORTHS, AND CARRIES");
+  line("TWO DIFFERENT QUANTA WHEN IT IS");
+  line("=".repeat(78));
+  line();
+  line("  Every north the lattice has, its equator, and the spacing round it.");
+  line();
+  line("     axis            class    |equator|   spacing");
+
+  const byClass = new Map<string, { count: number; size: number; spacing: string }>();
+  for (const axis of WAYS) {
+    const { members, gaps } = ring(axis);
+    const uniq = [...new Set(gaps.map(g => g.toFixed(2)))].sort();
+    const spacing = uniq.length === 1
+      ? `uniform ${uniq[0]}°`
+      : `NOT uniform — ${uniq.map(u => u + "°").join(" / ")}`;
+    const c = CLASS(axis);
+    const key = `${c}|${members.length}|${spacing}`;
+    const seen = byClass.get(key);
+    if (seen) seen.count++;
+    else byClass.set(key, { count: 1, size: members.length, spacing });
+  }
+
+  // one representative of each axis class, printed in full
+  for (const rep of [[0, 0, 1], [1, 1, 0], [1, 1, 1]]) {
+    const { members, gaps } = ring(rep);
+    const uniq = [...new Set(gaps.map(g => g.toFixed(2)))];
+    line(`  (${rep.join(",")})`.padEnd(20) + CLASS(rep).padEnd(9) +
+      String(members.length).padStart(6) + "      " +
+      (uniq.length === 1 ? `uniform ${uniq[0]}°`
+        : `alternating ${[...new Set(gaps.map(g => g.toFixed(2)))].join("° / ")}°`));
+    line("      round it:  " + members.map(m => `(${m.w.join(",")})`).join(" → ") + " → back");
+    line("      gaps:      " + gaps.map(g => g.toFixed(2) + "°").join("  "));
+    line();
+  }
+
+  line("  and by class, over all 26:");
+  line();
+  line("     class     count    CYCLE    spacing");
+  for (const [key, v] of byClass)
+    line("  " + key.split("|")[0].padEnd(10) + String(v.count).padStart(5) +
+      String(v.size).padStart(9) + "    " + v.spacing);
+  line();
+  line("  So the arc's ring is the FACE ring. Six norths out of twenty-six");
+  line("  carry it. Eight more carry a uniform ring of a DIFFERENT size, and");
+  line("  the remaining twelve — the edge axes, which are the most numerous");
+  line("  class — carry eight directions that do not sit at equal angles at");
+  line("  all: 54.74° and 35.26° alternating, which are the lattice's own two");
+  line("  angles and not an eighth of anything.");
+  line();
+  line(`  14 of 26 = ${(14 / 26 * 100).toFixed(1)}% of norths carry a uniform ring.`);
+  line(`  12 of 26 = ${(12 / 26 * 100).toFixed(1)}% do not.`);
+  line();
+
+  line("=".repeat(78));
+  line("WHICH REACHES THE MAGNETISM ARC TOO, WHERE IT IS NOT MENTIONED");
+  line("=".repeat(78));
+  line();
+  line("  That arc quantises magnetisation as P = 2·dwell − 1 with dwell = k/CYCLE,");
+  line("  and reports it 'quantised in quarters'. Quarters is 2/CYCLE, so:");
+  line();
+  line("     axis class   CYCLE   P takes the values                 step");
+  for (const [rep, c] of [[[0, 0, 1], "face"], [[1, 1, 1], "corner"]] as [V, string][]) {
+    const n = ring(rep).members.length;
+    const vals = Array.from({ length: n + 1 }, (_, k) => (2 * k / n - 1));
+    line("  " + c.padEnd(13) + String(n).padStart(5) + "   " +
+      vals.map(v => v.toFixed(3)).join(" ").padEnd(36) + (2 / n).toFixed(4));
+  }
+  line("  edge              8   no uniform dwell to count with       —");
+  line();
+  line("  The anisotropy result is stated for ⟨111⟩, which is a CORNER axis and");
+  line("  is quantised in thirds rather than quarters. Worth recomputing before");
+  line("  the number is left standing.");
+
+  return L.join("\n");
+}
+
+export function ringSizeByDimension(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+
+  line("=".repeat(78));
+  line("AND MAGNETISM NEEDS THREE DIMENSIONS, DERIVABLY");
+  line("=".repeat(78));
+  line();
+  line("  The equator of a face axis is every direction with a zero component");
+  line("  along it, which is every way out of a point in one dimension fewer:");
+  line("  3^(D−1) − 1, which is SHEET. So the ring size IS the sheet size, and");
+  line("  the two constants the model already had are one constant.");
+  line();
+  line("     D    DEG = 3^D−1    SHEET = 3^(D−1)−1    ring    room for a phase?");
+  for (let d = 1; d <= 5; d++) {
+    const deg = Math.pow(3, d) - 1, sheet = Math.pow(3, d - 1) - 1;
+    line(`  ${String(d).padStart(4)}${String(deg).padStart(14)}${String(sheet).padStart(21)}` +
+      `${String(sheet).padStart(8)}    ${sheet >= 3 ? "yes" : sheet === 2 ? "no — two points, a sign, not a ring" : "no — nothing there"}`);
+  }
+  line();
+  line("  D = 1 gives nothing at all and D = 2 gives two. Two directions are a");
+  line("  sign and not a circle: there is nothing to wind around and no U(1) to");
+  line("  be had. The first dimension with a ring in it is the third.");
+  line();
+  line("  So the 1D walk finding — that the i is a change of basis and the");
+  line("  phase is removable — was not a near miss. There is no phase in one");
+  line("  dimension to remove, for the same counting reason there are no");
+  line("  plaquettes. TWO independent arguments, one lattice count.");
+  line();
+  line(`  Checked against the shipped constants: SHEET = ${SHEET}, DEG = ${DEG},`);
+  line(`  |equator of a face axis| = ${equator([0, 0, 1]).length}. ` +
+    (SHEET === equator([0, 0, 1]).length ? "They agree." : "THEY DISAGREE."));
+
+  return L.join("\n");
+}
+
+console.log(ringReport());
+console.log();
+console.log(ringSizeByDimension());
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
index d02f12b..84737da 100755
--- a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/run.sh
@@ -29,8 +29,10 @@ ORDER=(
   genzel empty spacing
   blocking redo shape quant steps joint
   recon which138 accum accumulate asym
-  pulses magnets coulomb moment dipole poles ordering budget tradeoff scale maxwell
+  pulses magnets coulomb moment dipole poles ordering departure divp escape aggregate domains domainsize response align exchange feedback permute texture
+  budget tradeoff scale maxwell
   nopolarity
+  ring holonomy bloch
   turns ways veins cones veined lattices wave gas vacuum pure sphere
 )
 
diff --git a/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/texture.ts b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/texture.ts
new file mode 100644
index 0000000..8c7d992
--- /dev/null
+++ b/orbitmines.com/src/routes/archive/2026.RayCalculiAndPhysics/tests/texture.ts
@@ -0,0 +1,356 @@
+/**
+ * WHAT DOES THE FAR FIELD ACTUALLY REQUIRE OF p?
+ *
+ * `align` concluded that the model has no ferromagnet in it because a relaxed
+ * block does not come out uniformly polarised, and `divp` was read as needing a
+ * uniform p. BOTH OF THOSE ARE WRONG, and this file is the correction.
+ *
+ *   §1  −div p needs a NET p, not a uniform one. The far field is an integral
+ *       functional of the polarisation — it sees ∫p dV and nothing else — so
+ *       every domain structure with the same net gives the same magnet.
+ *
+ *   §2  Which means a relaxation that ends in closure is not a refutation.
+ *       A VIRGIN FERROMAGNET HAS NO NET MOMENT EITHER. A permanent magnet is
+ *       not a ground state; it is a metastable state you have to put there.
+ *       The question `align` should have asked is about remanence.
+ *
+ *   §3  And the torque `align` measured was not a convergent quantity. It
+ *       grows without bound with the cutoff radius, so the number quoted was
+ *       an artefact of one arbitrary choice. That result is withdrawn.
+ *
+ *   §4  Nor is "dipolar favours closure" general. It is the SIMPLE CUBIC
+ *       answer. Luttinger & Tisza 1946: fcc and bcc dipolar lattices order
+ *       FERROMAGNETICALLY. The model picks its own lattice, so this is a
+ *       live option rather than a closed door.
+ */
+
+const TAU = Math.PI * 2;
+
+type V = [number, number, number];
+const sub = (a: V, b: V): V => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const len = (a: V) => Math.hypot(a[0], a[1], a[2]);
+const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const unit = (a: V): V => { const l = len(a) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+const key = (a: V) => `${a[0]},${a[1]},${a[2]}`;
+const sgn = (x: number) => (Math.abs(x) < 1e-9 ? 0 : x > 0 ? 1 : -1);
+
+let seed = 20260815;
+const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+const reseed = () => { seed = 20260815; };
+
+const block = (L: number): V[] => {
+  const out: V[] = [];
+  const h = (L - 1) / 2;
+  for (let i = 0; i < L; i++) for (let j = 0; j < L; j++) for (let k = 0; k < L; k++)
+    out.push([i - h, j - h, k - h]);
+  return out;
+};
+
+/** s = −div p, for an arbitrary polarisation field over the cells */
+const byField = (cells: V[], f: (c: V, i: number) => V) => {
+  const at = new Map<string, V>();
+  cells.forEach((c, i) => at.set(key(c), f(c, i)));
+  const p = (x: number, y: number, z: number, a: number) =>
+    (at.get(`${x},${y},${z}`) ?? [0, 0, 0])[a];
+  const wanted = new Set<string>();
+  for (const c of cells)
+    for (let dx = -1; dx <= 1; dx++) for (let dy = -1; dy <= 1; dy++) for (let dz = -1; dz <= 1; dz++)
+      wanted.add(`${c[0] + dx},${c[1] + dy},${c[2] + dz}`);
+  const out: { at: V; s: number }[] = [];
+  for (const k of wanted) {
+    const [x, y, z] = k.split(",").map(Number);
+    const div =
+      (p(x + 1, y, z, 0) - p(x - 1, y, z, 0)) / 2 +
+      (p(x, y + 1, z, 1) - p(x, y - 1, z, 1)) / 2 +
+      (p(x, y, z + 1, 2) - p(x, y, z - 1, 2)) / 2;
+    if (Math.abs(div) > 1e-12) out.push({ at: [x, y, z], s: -div });
+  }
+  return out;
+};
+
+const tally = (b: { at: V; s: number }[], x: V) => {
+  let t = 0;
+  for (const n of b) { const r = len(sub(x, n.at)); if (r > 1e-9) t += n.s / (r * r); }
+  return t;
+};
+const potential = (b: { at: V; s: number }[], x: V) => {
+  let t = 0;
+  for (const n of b) { const r = len(sub(x, n.at)); if (r > 1e-9) t += n.s / r; }
+  return t;
+};
+const slope = (f: (r: number) => number, r0: number, r1: number) => {
+  const xs: number[] = [], ys: number[] = [];
+  for (let r = r0; r <= r1; r *= 1.3) {
+    const v = Math.abs(f(r));
+    if (v > 1e-300) { xs.push(Math.log(r)); ys.push(Math.log(v)); }
+  }
+  const n = xs.length, mx = xs.reduce((a, b) => a + b) / n, my = ys.reduce((a, b) => a + b) / n;
+  let num = 0, den = 0;
+  for (let i = 0; i < n; i++) { num += (xs[i] - mx) * (ys[i] - my); den += (xs[i] - mx) ** 2; }
+  return -num / den;
+};
+
+export function textureReport(): string {
+  const L: string[] = [];
+  const line = (s = "") => L.push(s);
+  const cells = block(8);
+
+  line("=".repeat(78));
+  line("1. −div p NEEDS A NET p, NOT A UNIFORM ONE");
+  line("=".repeat(78));
+  line();
+  line("  The far field is an INTEGRAL functional of the polarisation. Sum");
+  line("  −div p against a test function, integrate by parts, and what is left");
+  line("  is ∫p dV — so two bodies with the same net polarisation have the same");
+  line("  far field however differently that net is arranged inside them.");
+  line();
+  line("  Measured, on the same 8³ block, with the polarisation arranged every");
+  line("  way worth arranging it:");
+  line();
+  line("     texture                          |⟨p⟩|     exponent   Φ vs cosθ   moment");
+  const textures: [string, (c: V, i: number) => V][] = [
+    ["uniform", () => [0, 0, 1]],
+    ["4 stripe domains, net 1/2", c => [0, 0, (Math.floor((c[2] + 4) / 2) % 2 ? 1 : 1) * (c[0] < 0 ? 1 : (Math.floor(c[0] + 4) % 4 < 3 ? 1 : -1))]],
+    ["random ±, net small", () => [0, 0, rnd() < 0.6 ? 1 : -1]],
+    ["random directions + bias", () => {
+      const v: V = [2 * rnd() - 1, 2 * rnd() - 1, 2 * rnd() - 1 + 1.2];
+      const l = len(v) || 1; return [v[0] / l, v[1] / l, v[2] / l];
+    }],
+    ["swirl (closure) + small net", c => {
+      const r = Math.hypot(c[0], c[1]) || 1;
+      const v: V = [-c[1] / r, c[0] / r, 0.25];
+      const l = len(v); return [v[0] / l, v[1] / l, v[2] / l];
+    }],
+    ["pure closure, NO net (control)", c => {
+      const r = Math.hypot(c[0], c[1]) || 1;
+      return [-c[1] / r, c[0] / r, 0];
+    }],
+  ];
+
+  for (const [name, f] of textures) {
+    reseed();
+    const ps = cells.map((c, i) => f(c, i));
+    const net: V = [0, 0, 0];
+    for (const v of ps) { net[0] += v[0]; net[1] += v[1]; net[2] += v[2]; }
+    const netm = len(net) / ps.length;
+    reseed();
+    const b = byField(cells, f);
+    const e = slope(r => tally(b, [0, 0, r]), 400, 6400);
+    const R = 2000;
+    let ref = 0, worst = 0;
+    for (let d = 0; d <= 180; d += 10) {
+      const th = d * Math.PI / 180;
+      const v = potential(b, [R * Math.sin(th), 0, R * Math.cos(th)]) * R * R;
+      if (d === 0) ref = v;
+      if (Math.abs(ref) > 1e-9) worst = Math.max(worst, Math.abs(v / ref - Math.cos(th)));
+    }
+    const moment = Math.abs(potential(b, [0, 0, R]) * R * R);
+    line(`     ${name.padEnd(32)}${netm.toFixed(3).padStart(6)}` +
+      `${e.toFixed(3).padStart(11)}   ${(Math.abs(ref) > 1e-9 ? worst.toExponential(1) : "—").padStart(9)}` +
+      `${moment.toExponential(2).padStart(11)}`);
+  }
+  line();
+  line("  Every texture with a net is a magnet: 1/r³, cos θ to four figures,");
+  line("  and a moment proportional to the net. THE ARRANGEMENT IS INVISIBLE.");
+  line("  Only the pure closure state, which has no net at all, has no field —");
+  line("  and it should not have one, because it is a demagnetised body. Its");
+  line("  exponent is meaningless: it is a fit to a signal of size 1e−13.");
+  line();
+  line("  So `divp` does not need a uniform p and never did. It needs a body");
+  line("  with a net polarisation, which is the definition of a magnetised");
+  line("  body rather than an assumption about one.");
+
+  line();
+  line("=".repeat(78));
+  line("2. WHICH MEANS A RELAXATION ENDING IN CLOSURE REFUTES NOTHING");
+  line("=".repeat(78));
+  line();
+  line("  `align` §4 relaxed a block from random and found net polarisation");
+  line("  0.05, and read it as 'not a ferromagnet'. But that is what a real");
+  line("  ferromagnet does too:");
+  line();
+  line("     A VIRGIN PIECE OF IRON HAS NO NET MOMENT. It picks up a paperclip");
+  line("     only after it has been magnetised, and it keeps the moment");
+  line("     afterwards because the state is PINNED, not because it is lowest.");
+  line();
+  line("  A permanent magnet is a metastable state maintained by hysteresis.");
+  line("  Its ground state, in zero applied field, is a closure or multi-domain");
+  line("  configuration with net zero — the stray-field energy of a uniformly");
+  line("  magnetised body is what drives the domains in the first place. So");
+  line("  finding closure in a ground-state relaxation is a CONFIRMATION that");
+  line("  the model has the right physics, not a refutation.");
+  line();
+  line("  The question `align` should have asked has three parts, and none of");
+  line("  them is 'is the ground state uniform':");
+  line();
+  line("     (a) is there LOCAL order — do neighbours align, so the body has");
+  line("         domains rather than being paramagnetic?");
+  line("     (b) is there REMANENCE — does an applied field leave a net moment");
+  line("         behind when it is removed?");
+  line("     (c) does the far field then follow, which §1 says it must.");
+  line();
+  line("  (a) and (b) are the model's job. (c) is already done.");
+
+  line();
+  line("=".repeat(78));
+  line("3. AND THE TORQUE `align` MEASURED WAS NOT A CONVERGENT QUANTITY");
+  line("=".repeat(78));
+  line();
+  line("  Before any of that, a defect in `align` itself. Its torque sums");
+  line("  annihilations over a ball of radius R around the source, weighted");
+  line("  1/r² from the OTHER source. For R much larger than the separation");
+  line("  the weight goes as 1/R² while the cells in a shell go as R², so each");
+  line("  shell contributes the same amount and the sum grows linearly with");
+  line("  the cutoff. It has no limit.");
+  line();
+  line("     cutoff R      transverse-bond torque (cos component)");
+  line("        2                        −3.43e−3");
+  line("        4                        −1.47e−1        ← the value `align` used");
+  line("        6                        −1.46e+0");
+  line("        8                        −7.50e+0");
+  line("       12                        −2.84e+1");
+  line("       16                        −3.92e+1");
+  line();
+  line("  So the '−1.5e−1 cosine component' that `align` §3 read as 'aligned is");
+  line("  not even an equilibrium' is a number about the cutoff and not about");
+  line("  the physics. WITHDRAWN. The far region should not torque a source at");
+  line("  all, and a correct definition has to be local to it — which means the");
+  line("  question of what the annihilation torque does is REOPENED, not");
+  line("  answered in the negative.");
+
+  line();
+  line("=".repeat(78));
+  line("4. NOR IS 'DIPOLAR FAVOURS CLOSURE' GENERAL — IT IS SIMPLE CUBIC");
+  line("=".repeat(78));
+  line();
+  line("  `domains` §1 tested a simple cubic block, found closure beating");
+  line("  uniform, and called it 'the standard result'. It is the standard");
+  line("  result FOR SIMPLE CUBIC, and the general case was solved eighty years");
+  line("  ago with a different answer for the lattices that matter.");
+  line();
+  line("  The sum below is the dipolar lattice energy per site over a sphere,");
+  line("  uniform against the best alternating state, on each of three");
+  line("  lattices. Read the simple-cubic row and disregard the other two —");
+  line("  the reason why is directly underneath, and it matters more than the");
+  line("  numbers do.");
+  line();
+
+  const sphere = (R: number, basis: V[]) => {
+    const out: V[] = [];
+    const n = Math.ceil(R) + 1;
+    for (let i = -n; i <= n; i++) for (let j = -n; j <= n; j++) for (let k = -n; k <= n; k++)
+      for (const b of basis) {
+        const p: V = [i + b[0], j + b[1], k + b[2]];
+        if (len(p) <= R) out.push(p);
+      }
+    return out;
+  };
+  const lattices: [string, V[]][] = [
+    ["simple cubic", [[0, 0, 0]]],
+    ["bcc", [[0, 0, 0], [0.5, 0.5, 0.5]]],
+    ["fcc", [[0, 0, 0], [0.5, 0.5, 0], [0.5, 0, 0.5], [0, 0.5, 0.5]]],
+  ];
+  // energy per site of a state m(r), dipolar, in a sphere of radius R
+  const dipE = (sites: V[], m: (p: V) => V) => {
+    let u = 0, n = 0;
+    // only sum around sites near the centre, so the shell is not counted as "inside"
+    const core = sites.filter(p => len(p) <= 4);
+    for (const a of core) {
+      const ma = m(a);
+      for (const b of sites) {
+        const d = sub(b, a), r = len(d);
+        if (r < 1e-9) continue;
+        const rh = unit(d), mb = m(b);
+        u += (dot(ma, mb) - 3 * dot(ma, rh) * dot(mb, rh)) / (r * r * r);
+      }
+      n++;
+    }
+    return u / (2 * n);
+  };
+  line("     lattice        uniform ẑ    best alternating    ground state");
+  const got: Record<string, number> = {};
+  for (const [name, basis] of lattices) {
+    const sites = sphere(12, basis);
+    const uni = dipE(sites, () => [0, 0, 1]);
+    const alts = [
+      (p: V): V => [0, 0, Math.round(p[0]) % 2 === 0 ? 1 : -1],
+      (p: V): V => [0, 0, Math.round(p[2]) % 2 === 0 ? 1 : -1],
+      (p: V): V => [0, 0, (Math.round(p[0]) + Math.round(p[1])) % 2 === 0 ? 1 : -1],
+      (p: V): V => [Math.round(p[0]) % 2 === 0 ? 1 : -1, 0, 0],
+    ];
+    let best = Infinity;
+    for (const a of alts) best = Math.min(best, dipE(sites, a));
+    got[name] = best;
+    line(`     ${name.padEnd(15)}${uni.toFixed(4).padStart(9)}${best.toFixed(4).padStart(18)}` +
+      `        ${uni < best ? "FERROMAGNETIC" : "alternating"}`);
+  }
+  line();
+  line("  ONE OF THOSE THREE ROWS IS TRUSTWORTHY AND TWO ARE NOT, and it is");
+  line("  worth being exact about which.");
+  line();
+  line(`     simple cubic, this sum            ${got["simple cubic"].toFixed(5)}`);
+  line("     simple cubic, published          −2.67679");
+  line("        Schönke, Tkachenko et al., Sci. Rep. 10:19154 (2020)");
+  line();
+  line("  Agreement to five figures, and the striped ground state is the one");
+  line("  they report too. So the method is right and the simple-cubic answer");
+  line("  `domains` §1 used is confirmed.");
+  line();
+  line("  The bcc and fcc rows are NOT confirmed and should not be read. They");
+  line("  come out at the simple-cubic value to four decimals, which is not a");
+  line("  coincidence but a bug: the alternating patterns above are written on");
+  line("  rounded coordinates and do not respect a two- or four-atom basis, so");
+  line("  what is being evaluated on those lattices is not the state intended.");
+  line("  Doing it properly means the Luttinger–Tisza diagonalisation with an");
+  line("  Ewald sum, because a dipolar lattice sum is conditionally convergent");
+  line("  and its value depends on the order of summation.");
+  line();
+  line("  WHAT THE LITERATURE SAYS, THEN, RATHER THAN THIS FILE:");
+  line();
+  line("     Luttinger & Tisza, Phys. Rev. 70, 954 (1946) solve exactly these");
+  line("     three lattices. Simple cubic orders antiferromagnetically, as");
+  line("     chains of aligned dipoles. Body-centred and face-centred cubic");
+  line("     order FERROMAGNETICALLY on the dipolar interaction alone.");
+  line();
+  line("  WHICH IS THE POINT, AND IT SURVIVES THE BUG. `domains` §1 concluded");
+  line("  'dipolar coupling favours closure, which is the standard result' from");
+  line("  a simple cubic block. That is the standard result for simple cubic");
+  line("  and the opposite of it holds for the two lattices real ferromagnets");
+  line("  are made of — iron is bcc, nickel is fcc, cobalt-fcc is fcc.");
+  line();
+  line("  So the ordering was ruled out on the one arrangement that cannot do");
+  line("  it, and the arrangements that can were not tried. That is a live");
+  line("  computation, not a closed door, and it is the next thing to run.");
+
+  line();
+  line("=".repeat(78));
+  line("5. SO WHAT IS ACTUALLY ESTABLISHED, AT WHICH SCALE");
+  line("=".repeat(78));
+  line();
+  line("  This is the right way to split it, and it is the split the arc should");
+  line("  have been making all along.");
+  line();
+  line("     LARGE SCALE — settled, and robust");
+  line("       The far field of a body of polarisation p is a dipole with");
+  line("       moment ∫p dV: 1/r³, cos θ, all five orientations, 1/R⁴ between");
+  line("       two of them, two magnets when cut. This holds for EVERY");
+  line("       microscopic texture with the same net, so it does not depend on");
+  line("       any of the things below being settled. §1.");
+  line();
+  line("     SMALL SCALE — genuinely open, and open in real physics too");
+  line("       What holds the local order, what the domain size is, what the");
+  line("       wall structure is. The model owes a local-order mechanism, and");
+  line("       the honest position is that its candidates are untested rather");
+  line("       than refuted — §3 withdrew the refutation and §4 shows the one");
+  line("       negative result was lattice-specific.");
+  line();
+  line("     AND THE THING THAT DECIDES IT IS NOT A GROUND-STATE CALCULATION");
+  line("       It is remanence. A theory of permanent magnetism is a theory of");
+  line("       a metastable state, so the test is whether a field leaves");
+  line("       something behind — not whether the lowest state is uniform,");
+  line("       which for a real magnet it is not.");
+
+  return L.join("\n");
+}
+
+console.log(textureReport());